classiq 0.36.1__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

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/execution/jobs.py

@@ -7,9 +7,9 @@ from classiq.interface.execution.jobs import ExecutionJobDetailsV1
 from classiq.interface.executor.execution_request import ExecutionJobDetails
 from classiq.interface.executor.execution_result import ResultsCollection
 from classiq.interface.jobs import JobStatus, JSONObject
-from classiq.interface.server.routes import EXECUTION_JOBS_FULL_PATH
+from classiq.interface.server.routes import EXECUTION_JOBS_NON_VERSIONED_FULL_PATH
 
-from classiq._internals.api_wrapper import ApiWrapper
+from classiq._internals.api_wrapper import CLASSIQ_ACCEPT_HEADER, ApiWrapper
 from classiq._internals.async_utils import syncify_function
 from classiq._internals.client import client
 from classiq._internals.jobs import JobID, JobPoller
@@ -17,6 +17,9 @@ from classiq.exceptions import ClassiqAPIError
 
 _JobDetails = Union[ExecutionJobDetails, ExecutionJobDetailsV1]
 
+_JOB_DETAILS_VERSION = "v1"
+_JOB_RESULT_VERSION = "v1"
+
 
 class ExecutionJob:
     _details: _JobDetails
@@ -98,7 +101,9 @@ class ExecutionJob:
 
         if self._result is None:
             self._result = (
-                await ApiWrapper.call_get_execution_job_result(self._job_id)
+                await ApiWrapper.call_get_execution_job_result(
+                    job_id=self._job_id, version=_JOB_RESULT_VERSION
+                )
             ).results
         return self._result
 
@@ -117,7 +122,11 @@ class ExecutionJob:
                 return True
             return None
 
-        poller = JobPoller(base_url=EXECUTION_JOBS_FULL_PATH)
+        poller = JobPoller(
+            base_url=EXECUTION_JOBS_NON_VERSIONED_FULL_PATH,
+            use_versioned_url=False,
+            additional_headers={CLASSIQ_ACCEPT_HEADER: _JOB_DETAILS_VERSION},
+        )
         await poller.poll(
             job_id=self._job_id,
             response_parser=response_parser,

classiq/executor.py

@@ -1,4 +1,5 @@
 """Executor module, implementing facilities for executing quantum programs using Classiq platform."""
+
 import functools
 from typing import Optional, Tuple, Union
 
@@ -32,8 +33,8 @@ from classiq.synthesis import SerializedQuantumProgram
 
 BatchExecutionResult: TypeAlias = Union[ExecutionDetails, BaseException]
 ProgramAndResult: TypeAlias = Tuple[QuantumProgram, BatchExecutionResult]
-BackendPreferencesProgramAndResult: TypeAlias = Tuple[
-    BackendPreferencesTypes, QuantumProgram, BatchExecutionResult
+BackendPreferencesAndResult: TypeAlias = Tuple[
+    BackendPreferencesTypes, int, BatchExecutionResult
 ]
 _MAX_ARGUMENTS_SIZE = 1024
 

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

classiq/interface/analyzer/analysis_params.py

@@ -51,12 +51,6 @@ class AnalysisHardwareListParams(AnalysisParams, HardwareListParams):
     transpilation_params: AnalysisHardwareTranspilationParams
 
 
-class ResourceEstimatorParams(pydantic.BaseModel):
-    circuit_id: str
-    error_budget: float
-    physical_error_rate: float
-
-
 class HardwareParams(pydantic.BaseModel):
     device: PydanticNonEmptyString = pydantic.Field(default=None, description="Devices")
     provider: AnalyzerProviderVendor

classiq/interface/analyzer/result.py

@@ -136,10 +136,6 @@ class DevicesResult(VersionedModel):
     status: GraphStatus
 
 
-class ResourceEstimatorResult(VersionedModel):
-    report_json: str
-
-
 class QuantumCircuitProperties(pydantic.BaseModel):
     depth: pydantic.NonNegativeInt = pydantic.Field(
         default=..., description="Circuit depth"

classiq/interface/backend/backend_preferences.py

@@ -204,8 +204,8 @@ class GCPBackendPreferences(BackendPreferences):
 
 class OQCBackendPreferences(BackendPreferences):
     backend_service_provider: ProviderTypeVendor.OQC
-    oqc_email: str = pydantic.Field(description="OQC Email")
-    oqc_password: str = pydantic.Field(description="OQC email password")
+    username: str = pydantic.Field(description="OQC username")
+    password: str = pydantic.Field(description="OQC password")
 
     @pydantic.root_validator(pre=True)
     def _set_backend_service_provider(cls, values: Dict[str, Any]) -> Dict[str, Any]:

classiq/interface/backend/quantum_backend_providers.py

@@ -16,7 +16,7 @@ class ProviderVendor(StrEnum):
     AMAZON_BRAKET = "Amazon Braket"
     IONQ = "IonQ"
     GOOGLE = "Google"
-    ALICE_AND_BOB = "Alice and Bob"
+    ALICE_AND_BOB = "Alice & Bob"
     OQC = "OQC"
 
 

classiq/interface/execution/resource_estimator.py

@@ -0,0 +1,7 @@
+import pydantic
+
+
+class ResourceEstimatorParams(pydantic.BaseModel):
+    circuit_id: str
+    error_budget: float
+    physical_error_rate: float

classiq/interface/execution/result.py

@@ -0,0 +1,5 @@
+from classiq.interface.helpers.versioned_model import VersionedModel
+
+
+class ResourceEstimatorResult(VersionedModel):
+    report_json: str

classiq/interface/generator/ansatz_library.py

@@ -52,9 +52,9 @@ class RandomTwoQubitGatesArgs(CustomAnsatzArgs):
 
 
 class TwoLocalArgs(CustomAnsatzArgs):
-    rotation_blocks: Optional[
-        Union[RotationBlocksType, List[RotationBlocksType]]
-    ] = RotationBlocksType.ry
+    rotation_blocks: Optional[Union[RotationBlocksType, List[RotationBlocksType]]] = (
+        RotationBlocksType.ry
+    )
     entanglement_blocks: Optional[
         Union[EntanglementBlocksType, List[EntanglementBlocksType]]
     ] = EntanglementBlocksType.cx

classiq/interface/generator/arith/binary_ops.py

@@ -583,9 +583,7 @@ class Modulo(EffectiveUnaryOpParams[int]):
     ) -> int:
         repr_qubits_float = math.log2(right_arg)
         repr_qubits = round(repr_qubits_float)
-        assert (
-            abs(repr_qubits - repr_qubits_float) < 10**-8
-        ), NOT_POWER_OF_TWO_ERROR_MSG
+        assert abs(repr_qubits - repr_qubits_float) < 10**-8, NOT_POWER_OF_TWO_ERROR_MSG
         output_size = values.get("output_size")
         if output_size is not None:
             repr_qubits = min(repr_qubits, output_size)

classiq/interface/generator/expressions/atomic_expression_functions.py

@@ -11,6 +11,8 @@ SUPPORTED_ATOMIC_EXPRESSION_FUNCTIONS = {
     "get_type",
     "struct_literal",
     "get_field",
+    "fraction_digits",
+    "is_signed",
     "molecule_problem_to_hamiltonian",
     "fock_hamiltonian_problem_to_hamiltonian",
     "molecule_ground_state_solution_post_process",