classiq 0.36.0__py3-none-any.whl → 0.37.0__py3-none-any.whl

classiq/__init__.py

@@ -1,4 +1,5 @@
 """Classiq SDK."""
+
 import sys
 from typing import List
 

classiq/_internals/api_wrapper.py

@@ -24,6 +24,10 @@ from classiq._internals.jobs import JobPoller
 from classiq.exceptions import ClassiqAPIError, ClassiqValueError
 
 ResultType = TypeVar("ResultType", bound=pydantic.BaseModel)
+CLASSIQ_ACCEPT_HEADER = "X-Classiq-Accept-Version"
+
+_ACCEPT_HEADER = "X-Classiq-Accept-Version"
+_CONTENT_TYPE_HEADER = "X-Classiq-Content-Type-Version"
 
 
 class HTTPMethod(StrEnum):
@@ -72,11 +76,13 @@ class ApiWrapper:
         body: Optional[Dict] = None,
         params: Optional[Dict] = None,
         use_versioned_url: bool = True,
+        headers: Optional[Dict[str, str]] = None,
     ) -> dict:
         res = await client().call_api(
             http_method=http_method,
             url=url,
             body=body,
+            headers=headers,
             params=params,
             use_versioned_url=use_versioned_url,
         )
@@ -101,10 +107,16 @@ class ApiWrapper:
             url=routes.CONVERSION_GENERATED_CIRCUIT_TO_EXECUTION_INPUT_FULL,
             model=circuit,
         )
+        headers = {
+            _ACCEPT_HEADER: "v1",
+            _CONTENT_TYPE_HEADER: execution_input["version"],
+        }
         data = await cls._call_task(
             http_method=HTTPMethod.POST,
-            url=routes.EXECUTION_JOBS_FULL_PATH,
+            headers=headers,
+            url=routes.EXECUTION_JOBS_NON_VERSIONED_FULL_PATH,
             body=execution_input,
+            use_versioned_url=False,
         )
         return execution_request.ExecutionJobDetails.parse_obj(data)
 
@@ -113,9 +125,12 @@ class ApiWrapper:
         cls,
         job_id: JobID,
     ) -> execution_request.ExecutionJobDetails:
+        headers = {_CONTENT_TYPE_HEADER: "v1"}
         data = await cls._call_task(
             http_method=HTTPMethod.GET,
-            url=f"{routes.EXECUTION_JOBS_FULL_PATH }/{job_id.job_id}",
+            headers=headers,
+            url=f"{routes.EXECUTION_JOBS_NON_VERSIONED_FULL_PATH}/{job_id.job_id}",
+            use_versioned_url=False,
         )
         return execution_request.ExecutionJobDetails.parse_obj(data)
 
@@ -123,11 +138,13 @@ class ApiWrapper:
     async def call_get_execution_job_result(
         cls,
         job_id: JobID,
+        version: str,
     ) -> classiq.interface.executor.execution_result.ExecuteGeneratedCircuitResults:
         data = await cls._call_task(
             http_method=HTTPMethod.GET,
-            url=f"{routes.EXECUTION_SERVICE_JOBS_FULL_PATH}/{job_id.job_id}/result",
+            url=f"{routes.EXECUTION_JOBS_NON_VERSIONED_FULL_PATH}/{job_id.job_id}/result",
             use_versioned_url=False,
+            headers={CLASSIQ_ACCEPT_HEADER: version},
         )
         return classiq.interface.executor.execution_result.ExecuteGeneratedCircuitResults.parse_obj(
             data
@@ -141,7 +158,7 @@ class ApiWrapper:
     ) -> ExecutionJobDetailsV1:
         data = await cls._call_task(
             http_method=HTTPMethod.PATCH,
-            url=f"{routes.EXECUTION_SERVICE_JOBS_FULL_PATH}/{job_id.job_id}",
+            url=f"{routes.EXECUTION_JOBS_NON_VERSIONED_FULL_PATH}/{job_id.job_id}",
             params={
                 "name": name,
             },
@@ -157,7 +174,7 @@ class ApiWrapper:
     ) -> ExecutionJobsQueryResultsV1:
         data = await cls._call_task(
             http_method=HTTPMethod.GET,
-            url=f"{routes.EXECUTION_SERVICE_JOBS_FULL_PATH}",
+            url=f"{routes.EXECUTION_JOBS_NON_VERSIONED_FULL_PATH}",
             params={
                 "offset": offset,
                 "limit": limit,
@@ -277,7 +294,8 @@ class ApiWrapper:
         cls, problem: ground_state_problem.CHEMISTRY_PROBLEMS_TYPE
     ) -> operator.PauliOperator:
         poller = JobPoller(
-            base_url=routes.GENERATE_HAMILTONIAN_FULL_PATH, use_versioned_url=False
+            base_url=routes.GENERATE_HAMILTONIAN_FULL_PATH,
+            use_versioned_url=False,
         )
         result = await poller.run_pydantic(problem, timeout_sec=None)
         return _parse_job_response(result, operator.PauliOperator)

classiq/_internals/authentication/device.py

@@ -18,7 +18,9 @@ class DeviceRegistrar:
     _TIMEOUT_SEC: float = timedelta(minutes=15).total_seconds()
 
     @classmethod
-    async def register(cls, get_refresh_token: bool = True) -> Tokens:
+    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
@@ -27,9 +29,10 @@ class DeviceRegistrar:
         print(f"Your user code: {data['user_code']}")
         verification_url = data["verification_uri_complete"]
         print(
-            f"If a browser doesn't automatically open, please visit the url: {verification_url}"
+            f"If a browser doesn't automatically open, please visit this URL from any trusted device: {verification_url}"
         )
-        webbrowser.open(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,

classiq/_internals/authentication/token_manager.py

@@ -7,6 +7,7 @@ from typing import Optional
 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.config import Configuration
 from classiq.exceptions import (
     ClassiqAuthenticationError,
     ClassiqPasswordManagerSelectionError,
@@ -17,9 +18,14 @@ _logger = logging.getLogger(__name__)
 
 
 class TokenManager:
-    def __init__(self, password_manager: Optional[pm.PasswordManager] = None) -> None:
+    def __init__(
+        self,
+        config: Configuration,
+        password_manager: Optional[pm.PasswordManager] = None,
+    ) -> None:
+        self._config = config
         if password_manager is None:
-            password_manager = self._make_password_manager()
+            password_manager = self._make_password_manager(self._config)
         # We use threading.Lock instead of asyncio.Lock because the latter is coupled
         # to a specific event loop, which is undesirable
         self._lock = threading.Lock()
@@ -32,15 +38,23 @@ class TokenManager:
             )
 
     @classmethod
-    def _make_password_manager(cls) -> pm.PasswordManager:
+    def _should_skip_authentication(cls) -> bool:
         parser = argparse.ArgumentParser()
         parser.add_argument(
             "--skip-authentication", action="store_true", required=False
         )
         args, _ = parser.parse_known_args()
 
-        if args.skip_authentication:
+        return args.skip_authentication
+
+    @classmethod
+    def _make_password_manager(cls, config: Configuration) -> pm.PasswordManager:
+        should_skip_authentication = cls._should_skip_authentication()
+
+        if should_skip_authentication:
             return pm.DummyPasswordManager()
+        if config.text_only:
+            return pm.FilePasswordManager()
         for password_manager in PASSWORD_MANAGERS:
             if password_manager.is_supported():
                 return password_manager
@@ -108,5 +122,7 @@ 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)
+        tokens = await DeviceRegistrar.register(
+            get_refresh_token=True, text_only=self._config.text_only
+        )
         self._save_tokens(tokens, force_override_refresh_token=True)

classiq/_internals/client.py

@@ -135,7 +135,7 @@ class Client:
 
     def __init__(self, conf: config.Configuration) -> None:
         self._config = conf
-        self._token_manager = token_manager.TokenManager()
+        self._token_manager = token_manager.TokenManager(config=self._config)
         self._ssl_context = ssl.create_default_context()
         self._HTTP_TIMEOUT_SECONDS = (
             3600  # Needs to be synced with load-balancer timeout
@@ -205,6 +205,7 @@ class Client:
         body: Optional[Dict] = None,
         params: Optional[Dict] = None,
         use_versioned_url: bool = True,
+        headers: Optional[Dict[str, str]] = None,
     ) -> Union[Dict, str]:
         if use_versioned_url:
             url = self.make_versioned_url(url)
@@ -214,6 +215,7 @@ class Client:
                 url=url,
                 json=body,
                 params=params,
+                headers=headers,
             )
             self.handle_response(response)
             return response.json()
@@ -223,12 +225,15 @@ class Client:
         http_method: str,
         url: str,
         body: Optional[Dict] = None,
+        headers: Optional[Dict] = None,
         use_versioned_url: bool = True,
     ) -> Union[Dict, str]:
         if use_versioned_url:
             url = self.make_versioned_url(url)
         with httpx.Client(**self._make_client_args()) as sync_client:
-            response = sync_client.request(method=http_method, url=url, json=body)
+            response = sync_client.request(
+                method=http_method, url=url, json=body, headers=headers
+            )
             self.handle_response(response)
             return response.json()
 

classiq/_internals/config.py

@@ -1,4 +1,5 @@
 """Configuration of the SDK module."""
+
 import os
 import pathlib
 from typing import List, Optional, Union
@@ -32,6 +33,9 @@ class Configuration(BaseModel):
     mode: SDKMode = pydantic.Field(
         default=SDKMode.PROD, description="The operational mode of the SDK"
     )
+    text_only: bool = pydantic.Field(
+        default=False, description="Should classiq avoid relying on GUI"
+    )
 
 
 _DEFAULT_CONFIG_FILES = [str(pathlib.Path("classiq", "config.ini"))]
@@ -94,6 +98,13 @@ def init(args: Optional[Union[str, List[str]]] = None) -> Configuration:
         type=SDKMode,
         default=SDKMode.PROD,
     )
+    arg_parser.add_argument(
+        "--text-only",
+        dest="classiq_text_only",
+        help="Should classiq avoid relying on GUI",
+        env_var="CLASSIQ_TEXT_ONLY",
+        action="store_true",
+    )
 
     parsed_args, _ = arg_parser.parse_known_args(args=args)
     return Configuration(
@@ -101,4 +112,5 @@ def init(args: Optional[Union[str, List[str]]] = None) -> Configuration:
         ide=parsed_args.classiq_ide,
         should_check_host=not parsed_args.classiq_skip_check_host,
         mode=parsed_args.classiq_mode,
+        text_only=parsed_args.classiq_text_only,
     )

classiq/_internals/host_checker.py

@@ -45,7 +45,7 @@ class HostChecker:
         if lhs_version == cls._UNKNOWN_VERSION or rhs_version == cls._UNKNOWN_VERSION:
             # In case one of those versions is unknown, they are considered equal
             _logger.debug(
-                "Either {} or {} is an unknown version. Assuming both versions are equal.",
+                "Either %s or %s is an unknown version. Assuming both versions are equal.",
                 lhs_version,
                 rhs_version,
             )

classiq/_internals/jobs.py

@@ -56,8 +56,10 @@ class JobPoller:
         base_url: str,
         required_headers: Optional[Set[str]] = None,
         use_versioned_url: bool = True,
+        additional_headers: Optional[Dict[str, str]] = None,
     ) -> None:
         self._required_headers = required_headers or set()
+        self._additional_headers = additional_headers
         client_instance = client()
         self._base_url = (
             client_instance.make_versioned_url(base_url)
@@ -93,7 +95,7 @@ class JobPoller:
         # Update headers in case they change
         self._async_client.headers.update(client().get_headers())
         response = await self._async_client.request(
-            method=http_method, url=url, json=body
+            method=http_method, url=url, json=body, headers=self._additional_headers
         )
         client().handle_response(response)
         return response

classiq/_internals/type_validation.py

@@ -11,8 +11,7 @@ U = TypeVar("U")
 @overload
 def validate_type(
     obj: Any, expected_type: Type[T], operation: str, exception_type: Type[Exception]
-) -> T:
-    ...
+) -> T: ...
 
 
 @overload
@@ -21,8 +20,7 @@ def validate_type(
     expected_type: Tuple[Type[T], Type[U]],
     operation: str,
     exception_type: Type[Exception],
-) -> Union[T, U]:
-    ...
+) -> Union[T, U]: ...
 
 
 @overload
@@ -31,8 +29,7 @@ def validate_type(
     expected_type: Tuple[Type[T], ...],
     operation: str,
     exception_type: Type[Exception],
-) -> Any:
-    ...
+) -> Any: ...
 
 
 def validate_type(

classiq/analyzer/analyzer.py

@@ -1,4 +1,5 @@
 """Analyzer module, implementing facilities for analyzing circuits using Classiq platform."""
+
 import json
 import webbrowser
 from importlib.util import find_spec

classiq/analyzer/rb.py

@@ -12,7 +12,7 @@ from classiq.interface.analyzer.result import RbResults
 from classiq._internals.api_wrapper import ApiWrapper
 from classiq._internals.async_utils import Asyncify
 from classiq.exceptions import ClassiqAnalyzerError
-from classiq.executor import BackendPreferencesProgramAndResult
+from classiq.executor import BackendPreferencesAndResult
 
 
 class RBAnalysis(metaclass=Asyncify):
@@ -86,8 +86,7 @@ def _strict_string(arg: Union[Enum, str]) -> str:
 
 
 def order_executor_data_by_hardware(
-    mixed_data: List[BackendPreferencesProgramAndResult],
-    clifford_numbers_per_program: Dict[str, int],
+    mixed_data: List[BackendPreferencesAndResult],
 ) -> List[AnalysisRBParams]:
     hardware_names: Set[str] = {
         _strict_string(hardware.backend_name) for hardware, _, _ in mixed_data
@@ -96,9 +95,8 @@ def order_executor_data_by_hardware(
         name: list() for name in hardware_names
     }
     cliffords_dicts: Dict[str, List[int]] = {name: list() for name in hardware_names}
-    for hardware, program, result in mixed_data:
+    for hardware, num_clifford, result in mixed_data:
         hw_name: str = _strict_string(hardware.backend_name)
-        num_clifford: int = clifford_numbers_per_program[program.code]  # type: ignore[index]
         counts_dicts[hw_name].append(result.counts)  # type: ignore[union-attr]
         cliffords_dicts[hw_name].append(num_clifford)
 

classiq/applications_model_constructors/chemistry_model_constructor.py

@@ -27,7 +27,6 @@ from classiq.interface.generator.functions.port_declaration import (
     PortDeclarationDirection,
 )
 from classiq.interface.model.handle_binding import HandleBinding
-from classiq.interface.model.local_variable_declaration import LocalVariableDeclaration
 from classiq.interface.model.model import Model, SerializedModel
 from classiq.interface.model.native_function_definition import NativeFunctionDefinition
 from classiq.interface.model.port_declaration import PortDeclaration
@@ -325,70 +324,49 @@ def _get_hartree_fock(
     )
 
 
-def _get_hea_function(
-    hea_parameters: HEAParameters, use_hartree_fock: bool
-) -> List[QuantumFunctionCall]:
-    result = []
-    if not use_hartree_fock:
-        result.append(
-            QuantumFunctionCall(
-                function="allocate",
-                positional_args=[
-                    Expression(expr=f"{hea_parameters.num_qubits}"),
-                    HandleBinding(name="x"),
-                ],
-            )
-        )
-    result.append(
-        QuantumFunctionCall(
-            function="full_hea",
-            params={
-                "num_qubits": Expression(expr=f"{hea_parameters.num_qubits}"),
-                "is_parametrized": Expression(
-                    expr=f"{[int(_is_parametric_gate(_HAE_GATE_MAPPING[gate])) for gate in hea_parameters.one_qubit_gates+hea_parameters.two_qubit_gates]}"
-                ),
-                "connectivity_map": Expression(
-                    expr=f"{[list(connectivity_pair) for connectivity_pair in hea_parameters.connectivity_map]}"
-                ),
-                "reps": Expression(expr=f"{hea_parameters.reps}"),
-                "angle_params": Expression(expr="t"),
-            },
-            operands={
-                "operands_1qubit": [
-                    QuantumLambdaFunction(body=[_HAE_GATE_MAPPING[gate]])
-                    for gate in hea_parameters.one_qubit_gates
-                ],
-                "operands_2qubit": [
-                    QuantumLambdaFunction(body=[_HAE_GATE_MAPPING[gate]])
-                    for gate in hea_parameters.two_qubit_gates
-                ],
-            },
-            inouts={"x": HandleBinding(name="qbv")}
-            if use_hartree_fock
-            else {"x": HandleBinding(name="x")},
-        )
+def _get_hea_function(hea_parameters: HEAParameters) -> QuantumFunctionCall:
+    return QuantumFunctionCall(
+        function="full_hea",
+        params={
+            "num_qubits": Expression(expr=f"{hea_parameters.num_qubits}"),
+            "is_parametrized": Expression(
+                expr=f"{[int(_is_parametric_gate(_HAE_GATE_MAPPING[gate])) for gate in hea_parameters.one_qubit_gates+hea_parameters.two_qubit_gates]}"
+            ),
+            "connectivity_map": Expression(
+                expr=f"{[list(connectivity_pair) for connectivity_pair in hea_parameters.connectivity_map]}"
+            ),
+            "reps": Expression(expr=f"{hea_parameters.reps}"),
+            "angle_params": Expression(expr="t"),
+        },
+        operands={
+            "operands_1qubit": [
+                QuantumLambdaFunction(body=[_HAE_GATE_MAPPING[gate]])
+                for gate in hea_parameters.one_qubit_gates
+            ],
+            "operands_2qubit": [
+                QuantumLambdaFunction(body=[_HAE_GATE_MAPPING[gate]])
+                for gate in hea_parameters.two_qubit_gates
+            ],
+        },
+        inouts={"x": HandleBinding(name="qbv")},
     )
-    return result
 
 
 def _get_ansatz(
     chemistry_problem: CHEMISTRY_PROBLEMS_TYPE,
-    use_hartree_fock: bool,
     ansatz_parameters: AnsatzParameters,
-) -> List[QuantumFunctionCall]:
+) -> QuantumFunctionCall:
     if isinstance(ansatz_parameters, HEAParameters):
-        return _get_hea_function(ansatz_parameters, use_hartree_fock)
-    return [
-        _get_chemistry_function(
-            chemistry_problem,
-            _ANSATZ_PARAMETERS_FUNCTION_NAME_MAPPING[type(ansatz_parameters)],
-            {"qbv": HandleBinding(name="qbv")},
-            {
-                param_name: Expression(expr=str(param_value))
-                for param_name, param_value in ansatz_parameters.__dict__.items()
-            },
-        )
-    ]
+        return _get_hea_function(ansatz_parameters)
+    return _get_chemistry_function(
+        chemistry_problem,
+        _ANSATZ_PARAMETERS_FUNCTION_NAME_MAPPING[type(ansatz_parameters)],
+        {"qbv": HandleBinding(name="qbv")},
+        {
+            param_name: Expression(expr=str(param_value))
+            for param_name, param_value in ansatz_parameters.__dict__.items()
+        },
+    )
 
 
 def _get_chemistry_vqe_additional_params(
@@ -485,20 +463,17 @@ def _get_chemistry_quantum_main(
     if use_hartree_fock:
         body.append(_get_hartree_fock(chemistry_problem))
 
-    body += _get_ansatz(chemistry_problem, use_hartree_fock, ansatz_parameters)
+    body.append(_get_ansatz(chemistry_problem, ansatz_parameters))
 
     return NativeFunctionDefinition(
         name="main",
         param_decls=_get_chemistry_quantum_main_params(ansatz_parameters),
         port_declarations=(
-            {"x": PortDeclaration(name="x", direction=PortDeclarationDirection.Output)}
-            if isinstance(ansatz_parameters, HEAParameters) and not use_hartree_fock
-            else {}
-        ),
-        local_handles=(
-            [
-                LocalVariableDeclaration(name="qbv"),
-            ]
+            {
+                "qbv": PortDeclaration(
+                    name="qbv", direction=PortDeclarationDirection.Output
+                )
+            }
         ),
         body=body,
     )

classiq/applications_model_constructors/grover_model_constructor.py

@@ -6,9 +6,11 @@ from classiq.interface.generator.functions.port_declaration import (
 )
 from classiq.interface.model.bind_operation import BindOperation
 from classiq.interface.model.handle_binding import HandleBinding, SlicedHandleBinding
-from classiq.interface.model.local_variable_declaration import LocalVariableDeclaration
 from classiq.interface.model.model import Model, SerializedModel
 from classiq.interface.model.native_function_definition import NativeFunctionDefinition
+from classiq.interface.model.numeric_reinterpretation import (
+    NumericReinterpretationOperation,
+)
 from classiq.interface.model.port_declaration import PortDeclaration
 from classiq.interface.model.quantum_expressions.arithmetic_operation import (
     ArithmeticOperation,
@@ -18,10 +20,9 @@ from classiq.interface.model.quantum_function_call import (
     QuantumLambdaFunction,
 )
 from classiq.interface.model.quantum_statement import QuantumStatement
-from classiq.interface.model.quantum_type import (
-    QuantumFixedReal,
-    QuantumInteger,
-    QuantumType,
+from classiq.interface.model.quantum_type import QuantumNumeric
+from classiq.interface.model.variable_declaration_statement import (
+    VariableDeclarationStatement,
 )
 
 from classiq import RegisterUserInput
@@ -108,13 +109,6 @@ def _construct_arithmetic_oracle(
     )
 
 
-def get_quantum_type(fraction_places: int) -> QuantumType:
-    if fraction_places > 0:
-        return QuantumFixedReal(fraction_places=Expression(expr=f"{fraction_places}"))
-
-    return QuantumInteger()
-
-
 def grover_main_port_declarations(
     definitions: List[Tuple[str, RegisterUserInput]],
     direction: PortDeclarationDirection,
@@ -123,25 +117,38 @@ def grover_main_port_declarations(
         name: PortDeclaration(
             name=name,
             size=Expression(expr=f"{reg.size}"),
-            quantum_type=get_quantum_type(reg.fraction_places),
+            quantum_type=QuantumNumeric(),
             direction=direction,
         )
         for name, reg in definitions
     }
 
 
-def _generate_local_variable_declarations(
+def _generate_variable_declaration_statements(
     definitions: List[Tuple[str, RegisterUserInput]]
-) -> List[LocalVariableDeclaration]:
-    ret = [LocalVariableDeclaration(name="gsq")]
+) -> List[VariableDeclarationStatement]:
+    ret = [VariableDeclarationStatement(name="gsq")]
     if len(definitions) >= 2:
         ret += [
-            LocalVariableDeclaration(name=f"split{i}")
+            VariableDeclarationStatement(name=f"split{i}")
             for i in range(len(definitions) - 2)
         ]
     return ret
 
 
+def reinterpret_registers(
+    definitions: List[Tuple[str, RegisterUserInput]]
+) -> List[QuantumStatement]:
+    return [
+        NumericReinterpretationOperation(
+            target=HandleBinding(name=name),
+            fraction_digits=Expression(expr=f"{definition.fraction_places}"),
+            is_signed=Expression(expr=f"{definition.is_signed}"),
+        )
+        for name, definition in definitions
+    ]
+
+
 def construct_grover_model(
     definitions: List[Tuple[str, RegisterUserInput]],
     expression: str,
@@ -163,6 +170,7 @@ def construct_grover_model(
                 name=_PREDICATE_FUNCTION_NAME,
                 port_declarations=predicate_port_decls,
                 body=[
+                    *reinterpret_registers(definitions),
                     ArithmeticOperation(
                         expression=Expression(expr=expression),
                         result_var=HandleBinding(name="res"),
@@ -175,8 +183,8 @@ def construct_grover_model(
                 port_declarations=grover_main_port_declarations(
                     definitions, PortDeclarationDirection.Output
                 ),
-                local_handles=_generate_local_variable_declarations(definitions),
                 body=[
+                    *_generate_variable_declaration_statements(definitions),
                     QuantumFunctionCall(
                         function="allocate",
                         positional_args=[
@@ -207,6 +215,7 @@ def construct_grover_model(
                         [reg.size for _, reg in definitions],
                         "gsq",
                     ),
+                    *reinterpret_registers(definitions),
                 ],
             ),
         ],

classiq/exceptions.py

@@ -13,6 +13,11 @@ class ClassiqError(Exception):
     def __init__(self, message: str) -> None:
         message_with_link = message + CLASSIQ_SLACK_COMMUNITY_LINK
         super().__init__(message_with_link)
+        self._raw_message = message
+
+    @property
+    def raw_message(self) -> str:
+        return self._raw_message
 
 
 class ClassiqExecutionError(ClassiqError):