classiq 0.94.2__py3-none-any.whl → 0.95.0__py3-none-any.whl

classiq/_internals/authentication/auth0.py

@@ -1,4 +1,5 @@
 import urllib.parse
+import warnings
 from dataclasses import dataclass
 from typing import Any
 
@@ -20,6 +21,7 @@ class AuthSettings(BaseSettings):
         default="f6721qMOVoDAOVkzrv8YaWassRKSFX6Y",
         validation_alias="CLASSIQ_AUTH_CLIENT_ID",
     )
+    organization: str = Field(default="", validation_alias="CLASSIQ_AUTH_ORGANIZATION")
 
     model_config = SettingsConfigDict(extra="allow")
 
@@ -53,6 +55,10 @@ class Auth0:
     def _client_id(self) -> str:
         return self._auth_settings.client_id
 
+    @property
+    def _organization(self) -> str:
+        return self._auth_settings.organization
+
     async def _make_request(
         self,
         url: str,
@@ -76,13 +82,20 @@ class Auth0:
             f"Request to Auth0 failed with error code {code}: {data.get('error')}"
         )
 
-    async def get_device_data(self, get_refresh_token: bool = True) -> dict[str, Any]:
+    async def get_device_data(
+        self, require_refresh_token: bool = True
+    ) -> dict[str, Any]:
         payload = {
-            "client_id": self._auth_settings.client_id,
+            "client_id": self._client_id,
             "audience": self._auth_settings.audience,
         }
-        if get_refresh_token:
+        if require_refresh_token:
             payload["scope"] = "offline_access"
+        if self._organization:
+            warnings.warn(
+                "Organizations are not supported in device auth flow.",
+                stacklevel=1,
+            )
 
         return await self._make_request(
             url="/oauth/device/code",
@@ -102,6 +115,22 @@ class Auth0:
             allow_error=codes.FORBIDDEN,
         )
 
+    def get_authorize_url(
+        self, redirect_uri: str, require_refresh_token: bool = True
+    ) -> str:
+        params = {
+            "client_id": self._client_id,
+            "response_type": "code",
+            "audience": self._auth_settings.audience,
+            "redirect_uri": redirect_uri,
+        }
+        if require_refresh_token:
+            params["scope"] = "offline_access"
+        if self._organization:
+            # Otherwise, let the Auth0 handle
+            params["organization"] = self._organization
+        return f"{self._base_url}/authorize?{urllib.parse.urlencode(params)}"
+
     async def refresh_access_token(self, refresh_token: str) -> Tokens:
         # TODO handle failure
         payload = {

classiq/_internals/authentication/authorization_code.py

@@ -0,0 +1,9 @@
+from classiq._internals.authentication.authorization_flow import AuthorizationFlow
+
+
+class AuthorizationCodeFlow(AuthorizationFlow):
+    async def authorize(self, redirect_uri: str) -> None:
+        auth_url = self.auth0_client.get_authorize_url(
+            redirect_uri, self.require_refresh_token
+        )
+        self.open_url(auth_url)

classiq/_internals/authentication/authorization_flow.py

@@ -0,0 +1,41 @@
+import webbrowser
+from typing import Any
+
+from classiq.interface.exceptions import ClassiqAuthenticationError
+
+from classiq._internals.authentication.auth0 import Auth0, Tokens
+
+
+class AuthorizationFlow:
+    def __init__(self, require_refresh_token: bool = True, text_only: bool = False):
+        self.require_refresh_token = require_refresh_token
+        self.text_only = text_only
+        self.auth0_client = Auth0()
+
+    async def get_tokens(self) -> Tokens:
+        raise NotImplementedError
+
+    def handle_ready_data(self, data: dict[str, Any]) -> Tokens:
+        access_token: str | None = data.get("access_token") or None
+        # If refresh token was not requested, this would be None
+        refresh_token: str | None = data.get("refresh_token") or None
+
+        if access_token is None or (
+            self.require_refresh_token is True and refresh_token is None
+        ):
+            raise ClassiqAuthenticationError(
+                "Token generation failed for unknown reason (missing access token or refresh token)."
+            )
+
+        return Tokens(access_token=access_token, refresh_token=refresh_token)
+
+    def open_url(self, url: str) -> None:
+        if self.text_only:
+            print(  # noqa: T201
+                f"Please visit this URL from any trusted device to authenticate: {url}"
+            )
+        else:
+            webbrowser.open(url)
+            print(  # noqa: T201
+                f"If a browser doesn't automatically open, please visit this URL from any trusted device to authenticate: {url}"
+            )

classiq/_internals/authentication/device.py

@@ -1,6 +1,6 @@
 import asyncio
-import webbrowser
 from collections.abc import Iterable
+from dataclasses import dataclass
 from datetime import timedelta
 from typing import Any, TypeVar
 
@@ -10,74 +10,55 @@ from classiq.interface.exceptions import (
 )
 
 from classiq._internals.async_utils import poll_for
-from classiq._internals.authentication.auth0 import Auth0, Tokens
+from classiq._internals.authentication.auth0 import Tokens
+from classiq._internals.authentication.authorization_flow import AuthorizationFlow
 
 T = TypeVar("T")
 
 
-class DeviceRegistrar:
+@dataclass
+class DeviceData:
+    user_code: str
+    device_code: str
+    interval: float
+    expires_in: float
+    verification_uri: str
+    verification_uri_complete: str
+
+
+class DeviceCodeFlow(AuthorizationFlow):
     _TIMEOUT_ERROR = (
         "Device registration timed out. Please re-initiate the flow and "
         "authorize the device within the timeout."
     )
     _TIMEOUT_SEC: float = timedelta(minutes=15).total_seconds()
 
-    @classmethod
-    async def register(
-        cls, get_refresh_token: bool = True, text_only: bool = False
-    ) -> Tokens:
-        auth0_client = Auth0()
-        data: dict[str, Any] = await auth0_client.get_device_data(
-            get_refresh_token=get_refresh_token
+    async def get_device_data(self) -> DeviceData:
+        device_data: dict[str, Any] = await self.auth0_client.get_device_data(
+            require_refresh_token=self.require_refresh_token
         )
+        return DeviceData(**device_data)
 
-        print(f"Your user code: {data['user_code']}")  # noqa: T201
-        verification_url = data["verification_uri_complete"]
-        print(  # noqa: T201
-            f"If a browser doesn't automatically open, please visit this URL from any trusted device: {verification_url}"
-        )
-        if not text_only:
-            webbrowser.open(verification_url)
-        timeout = min(data["expires_in"], cls._TIMEOUT_SEC)
-        return await cls._poll_tokens(
-            auth0_client=auth0_client,
-            device_code=data["device_code"],
-            interval=data["interval"],
+    async def poll_tokens(self, device_data: DeviceData) -> Tokens:
+        interval = device_data.interval
+        timeout = min(device_data.expires_in, self._TIMEOUT_SEC)
+        return await self._poll_tokens(
+            device_code=device_data.device_code,
+            interval=interval,
             timeout=timeout,
-            get_refresh_token=get_refresh_token,
         )
 
-    @classmethod
-    def _handle_ready_data(
-        cls, data: dict[str, Any], get_refresh_token: bool
-    ) -> Tokens:
-        access_token: str | None = data.get("access_token")
-        # If refresh token was not requested, this would be None
-        refresh_token: str | None = data.get("refresh_token")
-
-        if access_token is None or (
-            get_refresh_token is True and refresh_token is None
-        ):
-            raise ClassiqAuthenticationError(
-                "Token generation failed for unknown reason."
-            )
-
-        return Tokens(access_token=access_token, refresh_token=refresh_token)
-
-    @classmethod
     async def _poll_tokens(
-        cls,
-        auth0_client: Auth0,
+        self,
         device_code: str,
-        interval: int,
+        interval: float,
         timeout: float,
-        get_refresh_token: bool = True,
     ) -> Tokens:
         async def poller() -> dict[str, Any]:
             nonlocal device_code
-            return await auth0_client.poll_tokens(device_code=device_code)
+            return await self.auth0_client.poll_tokens(device_code=device_code)
 
-        def interval_coro() -> Iterable[int]:
+        def interval_coro() -> Iterable[float]:
             nonlocal interval
             while True:
                 yield interval
@@ -88,14 +69,14 @@ class DeviceRegistrar:
         ):
             error_code: str | None = data.get("error")
             if error_code is None:
-                return cls._handle_ready_data(data, get_refresh_token)
+                return self.handle_ready_data(data)
             elif error_code == "authorization_pending":
                 pass
             elif error_code == "slow_down":
                 # This value is used by poll_for via interval_coro
                 interval *= 2
             elif error_code == "expired_token":
-                raise ClassiqExpiredTokenError(cls._TIMEOUT_ERROR)
+                raise ClassiqExpiredTokenError(self._TIMEOUT_ERROR)
             elif error_code == "access_denied":
                 error_description = data.get("error_description")
                 if error_description is None:
@@ -109,4 +90,4 @@ class DeviceRegistrar:
                     f"Device registration failed with an unknown error: {error_code}."
                 )
         else:
-            raise ClassiqAuthenticationError(cls._TIMEOUT_ERROR)
+            raise ClassiqAuthenticationError(self._TIMEOUT_ERROR)

classiq/_internals/authentication/hybrid_flow.py

@@ -0,0 +1,19 @@
+from classiq._internals.authentication.auth0 import Tokens
+from classiq._internals.authentication.authorization_code import AuthorizationCodeFlow
+from classiq._internals.authentication.authorization_flow import AuthorizationFlow
+from classiq._internals.authentication.device import DeviceCodeFlow
+
+
+class HybridFlow(AuthorizationFlow):
+    def __init__(
+        self, require_refresh_token: bool = True, text_only: bool = False
+    ) -> None:
+        super().__init__(require_refresh_token, text_only)
+        self.device_flow = DeviceCodeFlow(require_refresh_token, text_only)
+        self.auth_code_flow = AuthorizationCodeFlow(require_refresh_token, text_only)
+
+    async def get_tokens(self) -> Tokens:
+        device_data = await self.device_flow.get_device_data()
+        await self.auth_code_flow.authorize(device_data.verification_uri_complete)
+        print(f"Your user code: {device_data.user_code}")  # noqa: T201
+        return await self.device_flow.poll_tokens(device_data)

classiq/_internals/authentication/token_manager.py

@@ -10,8 +10,8 @@ from classiq.interface.exceptions import (
 )
 
 from classiq._internals.authentication import password_manager as pm
-from classiq._internals.authentication.auth0 import Auth0
-from classiq._internals.authentication.device import DeviceRegistrar, Tokens
+from classiq._internals.authentication.auth0 import Auth0, Tokens
+from classiq._internals.authentication.hybrid_flow import HybridFlow
 from classiq._internals.config import Configuration
 
 PASSWORD_MANAGERS: Sequence[type[pm.PasswordManager]] = [
@@ -126,7 +126,8 @@ class TokenManager:
     async def _authentication_helper(self) -> None:
         # TODO: consider using refresh token rotation
         #  (https://auth0.com/docs/tokens/refresh-tokens/refresh-token-rotation)
-        tokens = await DeviceRegistrar.register(
-            get_refresh_token=True, text_only=self._config.text_only
+        authorization_flow = HybridFlow(
+            require_refresh_token=True, text_only=self._config.text_only
         )
+        tokens = await authorization_flow.get_tokens()
         self._save_tokens(tokens, force_override_refresh_token=True)

classiq/applications/__init__.py

@@ -1,6 +1,6 @@
-from classiq.applications import chemistry, combinatorial_optimization, qsp, qsvm
+from classiq.applications import chemistry, combinatorial_optimization, qsp
 
-__all__ = ["chemistry", "combinatorial_optimization", "qsp", "qsvm"]
+__all__ = ["chemistry", "combinatorial_optimization", "qsp"]
 
 
 _NON_IMPORTED_PUBLIC_SUBMODULES = ["qnn"]

classiq/applications/qsp/qsp.py

@@ -50,7 +50,7 @@ def qsvt_phases(
 ) -> np.ndarray:
     r"""
     Get QSVT phases that will generate the given Chebyshev polynomial.
-    The phases are ready to be used in `qsvt` and `qsvt_lcu` functions in the classiq library. The convetion
+    The phases are ready to be used in `qsvt` and `qsvt_lcu` functions in the classiq library. The convention
     is the reflection signal operator, and the measurement basis is the hadamard basis (see https://arxiv.org/abs/2105.02859
     APPENDIX A.).
     The current implementation is using the pyqsp package, based on techniques in https://arxiv.org/abs/2003.02831.
@@ -118,7 +118,7 @@ def qsvt_phases(
 
 def _plot_qsp_approx(
     poly_cheb: np.ndarray,
-    f_target: Callable[[np.ndarray], np.ndarray],
+    f_target: Callable[[float], complex],
     interval: tuple[float, float] = (-1, 1),
 ) -> None:
     from matplotlib import pyplot as plt
@@ -126,7 +126,7 @@ def _plot_qsp_approx(
     grid_full = np.linspace(-1, 1, 3000)
     grid_interval = np.linspace(interval[0], interval[1], 3000)
 
-    y_target = f_target(grid_interval)
+    y_target = np.vectorize(f_target, otypes=[float])(grid_interval)
     y_approx = np.polynomial.Chebyshev(poly_cheb)(grid_full)
 
     # Plot
@@ -153,7 +153,7 @@ def _plot_qsp_approx(
 
 
 def qsp_approximate(
-    f_target: Callable[[np.ndarray], np.ndarray],
+    f_target: Callable[[float], complex],
     degree: int,
     parity: int | None = None,
     interval: tuple[float, float] = (-1, 1),
@@ -193,7 +193,8 @@ def qsp_approximate(
     # Select grid points for the objective in [w_min, w_max]
     xj_obj = xj_full[(xj_full >= interval[0]) & (xj_full <= interval[1])]
 
-    yj_obj = f_target(xj_obj)
+    yj_obj = np.vectorize(f_target, otypes=[float])(xj_obj)
+
     # heuristic verification
     bound = min(1, bound)
     assert (

classiq/evaluators/qmod_node_evaluators/classical_function_evaluation.py

@@ -7,6 +7,7 @@ import sympy
 from classiq.interface.exceptions import (
     ClassiqExpansionError,
     ClassiqInternalExpansionError,
+    ClassiqValueError,
 )
 from classiq.interface.generator.functions.classical_function_declaration import (
     ClassicalFunctionDeclaration,
@@ -208,6 +209,15 @@ def try_eval_sympy_function(
 
 def try_eval_builtin_function(
     expr_val: QmodAnnotatedExpression, node: ast.Call, func_name: str
+) -> bool:
+    try:
+        return _try_eval_builtin_function(expr_val, node, func_name)
+    except ValueError as e:
+        raise ClassiqValueError(str(e)) from e
+
+
+def _try_eval_builtin_function(
+    expr_val: QmodAnnotatedExpression, node: ast.Call, func_name: str
 ) -> bool:
     args_are_int = all(isinstance(expr_val.get_type(arg), Integer) for arg in node.args)
     args_are_real = all(

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

classiq/interface/backend/backend_preferences.py

@@ -172,10 +172,11 @@ class AwsBackendPreferences(BackendPreferences):
         backend_service_provider (ProviderTypeVendor.AMAZON_BRAKET):
             The service provider for the backend, which is Amazon Braket.
 
-        aws_role_arn (pydantic_backend.PydanticAwsRoleArn):
-            The Amazon Resource Name (ARN) of the role that will be assumed for execution
-            on your Braket account. This is a required field and should be provided to allow
-            secure and authorized access to AWS resources.
+        aws_access_key_id (str):
+            The access key id of AWS user with full braket access
+
+        aws_secret_access_key (str):
+            The secret key assigned to the access key id for the user with full braket access.
 
         s3_bucket_name (str):
             The name of the S3 bucket where results and other related data will be stored.
@@ -193,9 +194,13 @@ class AwsBackendPreferences(BackendPreferences):
     backend_service_provider: ProviderTypeVendor.AMAZON_BRAKET = pydantic.Field(
         default=ProviderVendor.AMAZON_BRAKET
     )
-    aws_role_arn: str | None = pydantic.Field(
+    aws_access_key_id: str | None = pydantic.Field(
+        default=None,
+        description="Key id assigned to user with credentials to access Braket service",
+    )
+    aws_secret_access_key: str | None = pydantic.Field(
         default=None,
-        description="ARN of the role to be assumed for execution on your Braket account.",
+        description="Secret access key assigned to user with credentials to access Braket service",
     )
     s3_bucket_name: str | None = pydantic.Field(
         default=None, description="S3 Bucket Name"

classiq/interface/exceptions.py

@@ -95,10 +95,6 @@ class ClassiqQFuncError(ClassiqValueError):
     pass
 
 
-class ClassiqQSVMError(ClassiqValueError):
-    pass
-
-
 class ClassiqQNNError(ClassiqValueError):
     pass
 

classiq/interface/generator/application_apis/__init__.py

@@ -4,6 +4,5 @@ from classiq.interface.generator.builtin_api_builder import (
 
 from .arithmetic_declarations import *  # noqa: F403
 from .combinatorial_optimization_declarations import *  # noqa: F403
-from .qsvm_declarations import *  # noqa: F403
 
 populate_builtin_declarations(vars().values())

classiq/interface/generator/function_param_list.py

@@ -42,7 +42,6 @@ from classiq.interface.generator.hardware_efficient_ansatz import (
 from classiq.interface.generator.identity import Identity
 from classiq.interface.generator.mcu import Mcu
 from classiq.interface.generator.mcx import Mcx
-from classiq.interface.generator.qsvm import QSVMFeatureMap
 from classiq.interface.generator.randomized_benchmarking import RandomizedBenchmarking
 from classiq.interface.generator.reset import Reset
 from classiq.interface.generator.standard_gates.standard_gates_param_list import (
@@ -108,7 +107,6 @@ function_param_library: FunctionParamLibrary = FunctionParamLibrary(
             RandomizedBenchmarking,
             UGate,
             AmplitudeLoading,
-            QSVMFeatureMap,
             HadamardTransform,
             Copy,
             Reset,

classiq/interface/generator/generated_circuit_data.py

@@ -1,6 +1,6 @@
 import logging
 import re
-from typing import Literal, Optional, TypeAlias
+from typing import Literal, TypeAlias
 from uuid import UUID
 
 import pydantic
@@ -188,8 +188,6 @@ class FunctionDebugInfoInterface(pydantic.BaseModel):
     back_refs: StatementBlock = Field(default_factory=list)
 
     model_config = ConfigDict(extra="allow")
-    # Temporary field to store the override debug info for parallel old/new visualization
-    override_debug_info: Optional["FunctionDebugInfoInterface"] = None
 
     @property
     def is_allocate_or_free(self) -> bool:
@@ -317,9 +315,6 @@ class FunctionDebugInfoInterface(pydantic.BaseModel):
         )
 
     def inverse(self) -> "FunctionDebugInfoInterface":
-        if self.override_debug_info is not None:
-            self.override_debug_info = self.override_debug_info.inverse()
-            return self
         inverse_generated_function = (
             self.generated_function.model_copy(
                 update=dict(registers=self._inverse_registers)

classiq/interface/generator/quantum_program.py

@@ -65,7 +65,6 @@ class QuantumProgram(VersionedModel, CircuitCodeInterface):
     transpiled_circuit: TranspiledCircuitData | None = pydantic.Field(default=None)
     creation_time: str = pydantic.Field(default_factory=_get_formatted_utc_current_time)
     synthesis_duration: SynthesisStepDurations | None = pydantic.Field(default=None)
-    debug_info: list[FunctionDebugInfoInterface] | None = pydantic.Field(default=None)
     compressed_debug_info: bytes | None = pydantic.Field(default=None)
     program_id: str = pydantic.Field(default_factory=get_uuid_as_str)
     execution_primitives_input: PrimitivesInput | None = pydantic.Field(default=None)
@@ -169,9 +168,6 @@ class QuantumProgram(VersionedModel, CircuitCodeInterface):
         )
 
     def get_debug_info(self) -> list[FunctionDebugInfoInterface] | None:
-        # Support legacy uncompressed debug info
-        if self.debug_info is not None:
-            return self.debug_info
         if self.compressed_debug_info is None:
             return None
         decompressed_debug_info_dict_list = decompress(self.compressed_debug_info)

classiq/interface/generator/transpiler_basis_gates.py

@@ -64,6 +64,9 @@ DEFAULT_BASIS_GATES: BasisGates = SINGLE_QUBIT_GATES | BASIC_TWO_QUBIT_GATES
 ALL_GATES: BasisGates = (
     SINGLE_QUBIT_GATES | TWO_QUBIT_GATES | THREE_QUBIT_GATES | NON_UNITARY_GATES
 )
+ALL_NON_3_QBIT_GATES: BasisGates = (
+    SINGLE_QUBIT_GATES | TWO_QUBIT_GATES | NON_UNITARY_GATES
+)
 
 ROUTING_TWO_QUBIT_BASIS_GATES: BasisGates = frozenset(
     ("cx", "ecr", "rzx", "ryy", "rxx", "rzz", "cy", "cz", "cp", "swap")

classiq/interface/generator/types/builtin_enum_declarations.py

@@ -20,16 +20,7 @@ class Pauli(IntEnum):
     Z = 3
 
 
-class QSVMFeatureMapEntanglement(IntEnum):
-    FULL = 0
-    LINEAR = 1
-    CIRCULAR = 2
-    SCA = 3
-    PAIRWISE = 4
-
-
 __all__ = [
     "Optimizer",
     "Pauli",
-    "QSVMFeatureMapEntanglement",
 ]

classiq/interface/interface_version.py

@@ -1 +1 @@
-INTERFACE_VERSION = "13"
+INTERFACE_VERSION = "14"

classiq/interface/model/block.py

@@ -14,3 +14,7 @@ class Block(QuantumOperation):
     statements: "StatementBlock"
 
     label: str | None = pydantic.Field(default=None)
+
+    @property
+    def blocks(self) -> dict[str, "StatementBlock"]:
+        return {"statements": self.statements}

classiq/interface/model/classical_if.py

@@ -31,6 +31,10 @@ class ClassicalIf(QuantumOperation):
     def expressions(self) -> list[Expression]:
         return [self.condition]
 
+    @property
+    def blocks(self) -> dict[str, "StatementBlock"]:
+        return {"then": self.then, "else_": self.else_}
+
     @property
     def wiring_inputs(self) -> Mapping[str, HandleBinding]:
         return functools.reduce(

classiq/interface/model/control.py

@@ -47,3 +47,10 @@ class Control(QuantumExpressionOperation):
 
     def _as_back_ref(self: ASTNodeType) -> ASTNodeType:
         return reset_lists(self, ["body", "else_block"])
+
+    @property
+    def blocks(self) -> dict[str, "StatementBlock"]:
+        blocks = {"body": self.body}
+        if self.else_block is not None:
+            blocks["else_block"] = self.else_block
+        return blocks

classiq/interface/model/invert.py

@@ -14,3 +14,7 @@ class Invert(QuantumOperation):
 
     def _as_back_ref(self: ASTNodeType) -> ASTNodeType:
         return reset_lists(self, ["body"])
+
+    @property
+    def blocks(self) -> dict[str, "StatementBlock"]:
+        return {"body": self.body}

classiq/interface/model/model_visitor.py

@@ -1,5 +1,12 @@
+from collections.abc import Collection
+
+from pydantic import BaseModel
+
 from classiq.interface.debug_info.debug_info import DebugInfoCollection
-from classiq.interface.generator.visitor import Transformer, Visitor
+from classiq.interface.generator.visitor import RetType, Transformer, Visitor
+from classiq.interface.model.model import Model
+from classiq.interface.model.native_function_definition import NativeFunctionDefinition
+from classiq.interface.model.quantum_statement import QuantumStatement
 
 
 class ModelVisitor(Visitor):
@@ -7,8 +14,40 @@ class ModelVisitor(Visitor):
         return
 
 
+class ModelStatementsVisitor(ModelVisitor):
+    def visit_BaseModel(self, node: BaseModel) -> RetType | None:
+        if isinstance(node, Model):
+            return self.visit(node.functions)
+        if isinstance(node, NativeFunctionDefinition):
+            return self.visit(node.body)
+        if isinstance(node, QuantumStatement):
+            for block in node.blocks.values():
+                self.visit(block)
+            return None
+        return super().visit_BaseModel(node)
+
+
 class ModelTransformer(Transformer):
     def visit_DebugInfoCollection(
         self, debug_info: DebugInfoCollection
     ) -> DebugInfoCollection:
         return debug_info
+
+
+class ModelStatementsTransformer(ModelTransformer):
+    def visit_BaseModel(
+        self, node: BaseModel, fields_to_skip: Collection[str] | None = None
+    ) -> RetType:
+        if isinstance(node, Model):
+            new_functions = self.visit(node.functions)
+            return node.model_copy(update=dict(functions=new_functions))
+        if isinstance(node, NativeFunctionDefinition):
+            new_body = self.visit(node.body)
+            return node.model_copy(update=dict(body=new_body))
+        if isinstance(node, QuantumStatement):
+            new_blocks = {
+                block_name: self.visit(block)
+                for block_name, block in node.blocks.items()
+            }
+            return node.model_copy(update=new_blocks)
+        return super().visit_BaseModel(node, fields_to_skip)

classiq/interface/model/power.py

@@ -20,3 +20,7 @@ class Power(QuantumOperation):
     @property
     def expressions(self) -> list[Expression]:
         return [self.power]
+
+    @property
+    def blocks(self) -> dict[str, "StatementBlock"]:
+        return {"body": self.body}