classiq 0.102.0__py3-none-any.whl → 1.0.0__py3-none-any.whl

classiq/__init__.py

@@ -52,6 +52,7 @@ from classiq.open_library import *  # noqa: F403
 from classiq.open_library import __all__ as _open_library_all
 from classiq.qmod import *  # noqa: F403
 from classiq.qmod import __all__ as _qmod_all
+from classiq.qprog_to_cudaq import qprog_to_cudaq_kernel
 from classiq.quantum_program import ExecutionParams, assign_parameters, transpile
 from classiq.synthesis import (
     QmodFormat,
@@ -117,6 +118,7 @@ __all__ = (
         "matrix_to_hamiltonian",
         "matrix_to_pauli_operator",
         "pauli_operator_to_matrix",
+        "qprog_to_cudaq_kernel",
         "quantum_program_from_qasm",
         "quantum_program_from_qasm_async",
         "QmodFormat",

classiq/_internals/authentication/auth0.py

@@ -11,6 +11,8 @@ from classiq.interface.exceptions import ClassiqAuthenticationError
 
 from classiq._internals.config import CONFIG_ENV_FILES
 
+GRANT_TYPE_CLIENT_CREDENTIALS = "client_credentials"
+
 
 class AuthSettings(BaseSettings):
     domain: str = Field(
@@ -144,3 +146,30 @@ class Auth0:
             access_token=data["access_token"],
             refresh_token=data.get("refresh_token", None),
         )
+
+    async def client_credentials_login(
+        self, client_id: str, client_secret: str, organization: str | None = None
+    ) -> dict[str, Any]:
+        """Authenticate using client credentials (M2M flow).
+
+        Args:
+            client_id: The M2M application client ID
+            client_secret: The M2M application client secret
+            organization: Optional organization ID for organization-specific access
+
+        Returns:
+            Dictionary containing token data from Auth0
+        """
+        payload = {
+            "client_id": client_id,
+            "client_secret": client_secret,
+            "grant_type": GRANT_TYPE_CLIENT_CREDENTIALS,
+            "audience": self._auth_settings.audience,
+        }
+        if organization:
+            payload["organization"] = organization
+
+        return await self._make_request(
+            url="/oauth/token",
+            payload=payload,
+        )

classiq/_internals/authentication/auth_flow_factory.py

@@ -0,0 +1,43 @@
+import logging
+
+from classiq._internals.authentication import password_manager as pm
+from classiq._internals.authentication.authorization_flow import AuthorizationFlow
+from classiq._internals.authentication.hybrid_flow import HybridFlow
+from classiq._internals.authentication.machine_credentials_flow import (
+    M2MClientCredentialsFlow,
+)
+from classiq._internals.config import Configuration
+
+_logger = logging.getLogger(__name__)
+
+
+class AuthFlowFactory:
+    """Factory for creating appropriate authorization and authentication flows based on context."""
+
+    @staticmethod
+    def create_flow(
+        password_manager: pm.PasswordManager, config: Configuration
+    ) -> AuthorizationFlow:
+        """
+        Create an authentication with or without authentication flow based on the password manager type.
+
+        Args:
+            password_manager: The password manager instance.
+            config: Configuration for authentication.
+
+        Returns:
+            Appropriate AuthorizationFlow instance (M2MClientCredentialsFlow or HybridFlow).
+
+        Raises:
+            ClassiqAuthenticationError: If M2M token generation failed.
+        """
+        # M2M authentication flow using client credentials to authenticate with Auth0 and get access token
+        if isinstance(password_manager, pm.M2MPasswordManager):
+            return M2MClientCredentialsFlow(
+                client_id=password_manager.client_id,
+                client_secret=password_manager.client_secret,
+                organization=password_manager.org_id,
+            )
+
+        # Interactive user authentication flow
+        return HybridFlow(require_refresh_token=True, text_only=config.text_only)

classiq/_internals/authentication/machine_credentials_flow.py

@@ -0,0 +1,26 @@
+from classiq._internals.authentication.auth0 import Tokens
+from classiq._internals.authentication.authorization_flow import AuthorizationFlow
+
+
+class M2MClientCredentialsFlow(AuthorizationFlow):
+    """Machine-to-Machine (M2M) authentication using OAuth2 Client Credentials flow."""
+
+    def __init__(
+        self,
+        client_id: str,
+        client_secret: str,
+        organization: str | None = None,
+    ) -> None:
+        # M2M authentication doesn't use refresh tokens or interactive flows
+        super().__init__(require_refresh_token=False, text_only=False)
+        self.client_id = client_id
+        self.client_secret = client_secret
+        self.organization = organization
+
+    async def get_tokens(self) -> Tokens:
+        data = await self.auth0_client.client_credentials_login(
+            client_id=self.client_id,
+            client_secret=self.client_secret,
+            organization=self.organization,
+        )
+        return self.handle_ready_data(data)

classiq/_internals/authentication/password_manager.py

@@ -37,6 +37,8 @@ class PasswordManagerSettings(BaseSettings):
 
 class PasswordManager(abc.ABC):
     _SERVICE_NAME: str = "classiqTokenService"
+    text_only_supported: bool = True
+    has_refresh_token: bool = True
 
     def __init__(self) -> None:
         self._settings = PasswordManagerSettings()
@@ -76,6 +78,8 @@ class PasswordManager(abc.ABC):
 
 
 class KeyringPasswordManager(PasswordManager):
+    text_only_supported: bool = False
+
     def _get(self, key: str) -> str | None:
         return keyring.get_password(service_name=self._SERVICE_NAME, username=key)
 
@@ -154,3 +158,83 @@ class FilePasswordManager(PasswordManager):
     @staticmethod
     def is_supported() -> bool:
         return "windows" not in platform.platform().lower()
+
+
+class M2MPasswordManager(PasswordManager):
+    """Password manager for M2M authentication using environment variables.
+
+    Supports machine-to-machine authentication by reading credentials from:
+    - CLASSIQ_CLIENT_ID (required)
+    - CLASSIQ_CLIENT_SECRET (required)
+    - CLASSIQ_ORG_ID (optional)
+
+    This manager stores tokens in memory after M2M authentication.
+    """
+
+    has_refresh_token: bool = False
+
+    M2M_CREDS_ENV_KEYS = {
+        "client_id": "CLASSIQ_CLIENT_ID",
+        "client_secret": "CLASSIQ_CLIENT_SECRET",
+        "org_id": "CLASSIQ_ORG_ID",
+    }
+
+    M2M_REQUIRED_CREDS = {"client_id", "client_secret"}
+
+    def __init__(self) -> None:
+        super().__init__()
+        self._token_storage: dict[str, str | None] = {}
+        # Initialize all environment variable values
+        self._m2m_creds: dict[str, str | None] = {
+            key: os.getenv(env_key) for key, env_key in self.M2M_CREDS_ENV_KEYS.items()
+        }
+
+    def _get(self, key: str) -> str | None:
+        """Get token from in-memory storage."""
+        return self._token_storage.get(key)
+
+    def _set(self, key: str, value: str | None) -> None:
+        """Store token in memory."""
+        if value is None:
+            self._clear(key)
+            return
+        self._token_storage[key] = value
+
+    def _clear(self, key: str) -> None:
+        """Clear token from memory storage."""
+        self._token_storage.pop(key, None)
+
+    @staticmethod
+    def is_supported() -> bool:
+        """Check if required M2M environment variables are present."""
+        manager = M2MPasswordManager()
+        return all(
+            manager._m2m_creds.get(key) for key in M2MPasswordManager.M2M_REQUIRED_CREDS
+        )
+
+    def _get_required_cred(self, key: str) -> str:
+        value = self._m2m_creds.get(key)
+        if value is None:
+            raise ValueError(
+                f"M2M authentication requires {self.M2M_CREDS_ENV_KEYS[key]} environment variable"
+            )
+        return value
+
+    # to prevent mypy from complaining about the return type
+    def _get_optional_cred(self, key: str) -> str | None:
+        return self._m2m_creds.get(key)
+
+    @property
+    def client_id(self) -> str:
+        """Get client ID from initialized credentials."""
+        return self._get_required_cred("client_id")
+
+    @property
+    def client_secret(self) -> str:
+        """Get client secret from initialized credentials."""
+        return self._get_required_cred("client_secret")
+
+    @property
+    def org_id(self) -> str | None:
+        """Get organization ID from initialized credentials (optional)."""
+        return self._get_optional_cred("org_id")

classiq/_internals/authentication/token_manager.py

@@ -11,13 +11,15 @@ from classiq.interface.exceptions import (
 
 from classiq._internals.authentication import password_manager as pm
 from classiq._internals.authentication.auth0 import Auth0, Tokens
-from classiq._internals.authentication.hybrid_flow import HybridFlow
+from classiq._internals.authentication.auth_flow_factory import AuthFlowFactory
 from classiq._internals.config import Configuration
 
-PASSWORD_MANAGERS: Sequence[type[pm.PasswordManager]] = [
+SUPPORTED_PASSWORD_MANAGERS: Sequence[type[pm.PasswordManager]] = [
+    pm.M2MPasswordManager,
     pm.KeyringPasswordManager,
     pm.FilePasswordManager,
 ]
+
 _logger = logging.getLogger(__name__)
 
 
@@ -57,9 +59,11 @@ class TokenManager:
 
         if should_skip_authentication:
             return pm.DummyPasswordManager()
-        if config.text_only:
-            return pm.FilePasswordManager()
-        for password_manager in PASSWORD_MANAGERS:
+
+        # Filter out M2MPasswordManager and FilePasswordManager in text-only mode
+        for password_manager in SUPPORTED_PASSWORD_MANAGERS:
+            if config.text_only and not password_manager.text_only_supported:
+                continue
             if password_manager.is_supported():
                 return password_manager()
         raise ClassiqPasswordManagerSelectionError(
@@ -75,6 +79,10 @@ class TokenManager:
         self._save_tokens(tokens)
 
     async def update_expired_access_token(self) -> None:
+        if not self._password_manager.has_refresh_token:
+            await self._authentication_helper()
+            return
+
         if self._refresh_token is not None:
             await self._refresh()
             return
@@ -84,6 +92,11 @@ class TokenManager:
         )
 
     async def manual_authentication(self, overwrite: bool) -> None:
+        # For M2M authentication, always re-authenticate (no refresh token concept)
+        if not self._password_manager.has_refresh_token:
+            await self._authentication_helper()
+            return
+
         if self._refresh_token is None:
             await self._authentication_helper()
             return
@@ -126,8 +139,11 @@ class TokenManager:
     async def _authentication_helper(self) -> None:
         # TODO: consider using refresh token rotation
         #  (https://auth0.com/docs/tokens/refresh-tokens/refresh-token-rotation)
-        authorization_flow = HybridFlow(
-            require_refresh_token=True, text_only=self._config.text_only
+        authorization_flow = AuthFlowFactory.create_flow(
+            password_manager=self._password_manager, config=self._config
         )
         tokens = await authorization_flow.get_tokens()
-        self._save_tokens(tokens, force_override_refresh_token=True)
+
+        # Password managers without refresh tokens don't use rotation
+        force_override = self._password_manager.has_refresh_token
+        self._save_tokens(tokens, force_override_refresh_token=force_override)

classiq/analyzer/show_interactive_hack.py

@@ -7,8 +7,6 @@ from tempfile import NamedTemporaryFile
 from urllib.parse import urljoin
 
 from classiq.interface.analyzer.result import DataID
-from classiq.interface.exceptions import ClassiqAnalyzerVisualizationError
-from classiq.interface.generator.model.preferences.preferences import QuantumFormat
 from classiq.interface.generator.quantum_program import QuantumProgram
 
 from classiq._internals.api_wrapper import ApiWrapper
@@ -116,12 +114,6 @@ def get_visualization_renderer() -> VisualizationRenderer:
 
 
 async def handle_remote_app(circuit: QuantumProgram, display_url: bool = True) -> None:
-    if circuit.outputs.get(QuantumFormat.QASM) is None:
-        raise ClassiqAnalyzerVisualizationError(
-            "Missing QASM transpilation: visualization is only supported "
-            "for QASM programs. Try adding QASM to the output formats "
-            "synthesis preferences"
-        )
     circuit_dataid = DataID(id=circuit.program_id)
 
     renderer = get_visualization_renderer()

classiq/applications/chemistry/op_utils.py

@@ -74,6 +74,38 @@ def qubit_op_to_qmod(
     )
 
 
+def qmod_to_qubit_op(operator: SparsePauliOp) -> QubitOperator:
+    """
+    Transforms Qmod's SparsePauliOp data structure to OpenFermion's QubitOperator data structure.
+
+    Args:
+        operator (SparsePauliOp): The operator to be transformed
+
+    Returns:
+        QubitOperator: The operator in OpenFermion's data structure
+    """
+
+    # Initiating the QubitOperator as the 0 operator
+    qo = QubitOperator()
+    for sparse_pauli_term in operator.terms:
+        # loop over all the IndexedPaulis
+        coeff = sparse_pauli_term.coefficient
+        if sparse_pauli_term.paulis:
+            qo.terms[
+                tuple(
+                    [
+                        (p.index, p.pauli.name)
+                        for p in sparse_pauli_term.paulis  # type: ignore[attr-defined]
+                        if p.pauli is not Pauli.I
+                    ]
+                )
+            ] = coeff
+        # Operator is the identity
+        else:
+            qo.terms[()] = coeff
+    return qo
+
+
 _PAULIS_TO_XZ = {"I": (0, 0), "X": (1, 0), "Z": (0, 1), "Y": (1, 1)}
 _XZ_TO_PAULIS = {(0, 0): "I", (1, 0): "X", (0, 1): "Z", (1, 1): "Y"}
 

classiq/applications/combinatorial_optimization/combinatorial_problem.py

@@ -37,7 +37,7 @@ class CombinatorialProblem:
         self,
         pyo_model: pyo.ConcreteModel,
         num_layers: int,
-        penalty_factor: int = 1,
+        penalty_factor: float = 1,
     ):
         self.problem_vars_, self.cost_func = pyo_model_to_qmod_problem(
             pyo_model, penalty_factor

classiq/evaluators/qmod_annotated_expression.py

@@ -207,7 +207,7 @@ class QmodAnnotatedExpression:
             node = id(node)
         return node in self._quantum_subscripts
 
-    def get_quantum_subcript(
+    def get_quantum_subscript(
         self, node: ast.AST | QmodExprNodeId
     ) -> QuantumSubscriptAnnotation:
         if isinstance(node, ast.AST):

classiq/evaluators/qmod_expression_visitors/qmod_expression_evaluator.py

@@ -77,7 +77,6 @@ class QmodExpressionEvaluator(ast.NodeVisitor):
         self,
         expr_val: QmodAnnotatedExpression,
         *,
-        treat_qnum_as_float: bool = False,
         machine_precision: int = DEFAULT_MACHINE_PRECISION,
         classical_struct_declarations: Sequence[StructDeclaration] | None = None,
         enum_declarations: Sequence[EnumDeclaration] | None = None,
@@ -88,7 +87,6 @@ class QmodExpressionEvaluator(ast.NodeVisitor):
         scope: Mapping[str, Any] | None = None,
     ) -> None:
         self._expr_val = expr_val
-        self._treat_qnum_as_float = treat_qnum_as_float
         self._machine_precision = machine_precision
         self._classical_struct_decls = nameables_to_dict(
             classical_struct_declarations or []
@@ -114,9 +112,7 @@ class QmodExpressionEvaluator(ast.NodeVisitor):
 
     def visit_BinOp(self, node: ast.BinOp) -> None:
         super().generic_visit(node)
-        eval_binary_op(
-            self._expr_val, node, self._treat_qnum_as_float, self._machine_precision
-        )
+        eval_binary_op(self._expr_val, node, self._machine_precision)
 
     def visit_UnaryOp(self, node: ast.UnaryOp) -> None:
         super().generic_visit(node)
@@ -164,7 +160,6 @@ class QmodExpressionEvaluator(ast.NodeVisitor):
                 self._expr_val,
                 node,
                 func_name,
-                self._treat_qnum_as_float,
                 self._machine_precision,
             )
             return
@@ -256,7 +251,6 @@ class QmodExpressionEvaluator(ast.NodeVisitor):
 def evaluate_qmod_expression(
     expr: str,
     *,
-    treat_qnum_as_float: bool = False,
     machine_precision: int = DEFAULT_MACHINE_PRECISION,
     classical_struct_declarations: Sequence[StructDeclaration] | None = None,
     enum_declarations: Sequence[EnumDeclaration] | None = None,
@@ -270,7 +264,6 @@ def evaluate_qmod_expression(
     expr_value = QmodAnnotatedExpression(expr_ast)
     QmodExpressionEvaluator(
         expr_value,
-        treat_qnum_as_float=treat_qnum_as_float,
         machine_precision=machine_precision,
         classical_struct_declarations=classical_struct_declarations,
         enum_declarations=enum_declarations,

classiq/evaluators/qmod_expression_visitors/qmod_expression_simplifier.py

@@ -122,7 +122,7 @@ class _InverseVarMaskTransformer(OutOfPlaceNodeTransformer):
 
 class _SympyCompatibilityTransformer(OutOfPlaceNodeTransformer):
     def visit_BoolOp(self, node: ast.BoolOp) -> ast.Call:
-        if len(node.values) != 2:
+        if len(node.values) < 2:
             raise ClassiqInternalExpansionError
         node = cast(ast.BoolOp, self.generic_visit(node))
         if isinstance(node.op, ast.Or):

classiq/evaluators/qmod_node_evaluators/attribute_evaluation.py

@@ -107,7 +107,7 @@ def _eval_type_attribute(
     if isinstance(subject_type, QuantumNumeric):
         if attr == "is_signed":
             expr_val.set_type(node, Bool())
-            if subject_type.has_sign:
+            if subject_type.has_constant_sign:
                 expr_val.set_value(node, subject_type.sign_value)
                 _remove_quantum_var(expr_val, subject)
             elif subject_type.has_size_in_bits:
@@ -120,7 +120,7 @@ def _eval_type_attribute(
             return
         if attr == "fraction_digits":
             expr_val.set_type(node, Integer())
-            if subject_type.has_fraction_digits:
+            if subject_type.has_constant_fraction_digits:
                 expr_val.set_value(node, subject_type.fraction_digits_value)
                 _remove_quantum_var(expr_val, subject)
             elif subject_type.has_size_in_bits:

classiq/evaluators/qmod_node_evaluators/binary_op_evaluation.py

@@ -50,7 +50,6 @@ def _validate_binary_op(
     op: ast.AST,
     left_type: QmodType,
     right_type: QmodType,
-    treat_qnum_as_float: bool,
 ) -> None:
     if not _binary_op_allowed(left_type, right_type, op):
         raise ClassiqExpansionError(
@@ -76,20 +75,19 @@ def _validate_binary_op(
             f"Binary operation {type(op).__name__!r} is not supported"
         )
 
-    if not treat_qnum_as_float:
-        if isinstance(op, ast.FloorDiv) and (
-            not is_classical_type(left_type) or not is_classical_type(right_type)
-        ):
-            raise ClassiqExpansionError(
-                f"{type(op).__name__!r} with quantum variables is not supported"
-            )
+    if isinstance(op, ast.FloorDiv) and (
+        not is_classical_type(left_type) or not is_classical_type(right_type)
+    ):
+        raise ClassiqExpansionError(
+            f"{type(op).__name__!r} with quantum variables is not supported"
+        )
 
-        if not is_classical_type(right_type) and isinstance(
-            op, (ast.Div, ast.Mod, ast.Pow, ast.LShift, ast.RShift)
-        ):
-            raise ClassiqExpansionError(
-                f"Right-hand side of binary operation {type(op).__name__!r} must be classical numeric value"
-            )
+    if not is_classical_type(right_type) and isinstance(
+        op, (ast.Div, ast.Mod, ast.Pow, ast.LShift, ast.RShift)
+    ):
+        raise ClassiqExpansionError(
+            f"Right-hand side of binary operation {type(op).__name__!r} must be classical numeric value"
+        )
 
 
 def _infer_binary_op_type(
@@ -98,7 +96,6 @@ def _infer_binary_op_type(
     left_type: QmodType,
     right_type: QmodType,
     machine_precision: int,
-    treat_qnum_as_float: bool,
 ) -> QmodType:
     op = node.op
 
@@ -113,19 +110,13 @@ def _infer_binary_op_type(
             return Integer()
         return Real()
 
-    left_attrs = get_numeric_attrs(
-        expr_val, node.left, left_type, machine_precision, treat_qnum_as_float
-    )
-    right_attrs = get_numeric_attrs(
-        expr_val, node.right, right_type, machine_precision, treat_qnum_as_float
-    )
+    left_attrs = get_numeric_attrs(expr_val, node.left, left_type, machine_precision)
+    right_attrs = get_numeric_attrs(expr_val, node.right, right_type, machine_precision)
 
     if left_attrs is None or right_attrs is None:
         return QuantumNumeric()
 
-    right_value = get_classical_value_for_arithmetic(
-        expr_val, node.right, right_type, treat_qnum_as_float
-    )
+    right_value = get_classical_value_for_arithmetic(expr_val, node.right, right_type)
 
     if isinstance(op, ast.Add):
         result_attrs = compute_result_attrs_add(
@@ -157,14 +148,14 @@ def _infer_binary_op_type(
         return QuantumNumeric()
 
     elif isinstance(op, ast.Mod):
-        if right_value is None or treat_qnum_as_float:
+        if right_value is None:
             return QuantumNumeric()
         result_attrs = compute_result_attrs_modulo(
             left_attrs, right_attrs, machine_precision
         )
 
     elif isinstance(op, ast.Pow):
-        if right_value is None or treat_qnum_as_float:
+        if right_value is None:
             return QuantumNumeric()
         result_attrs = compute_result_attrs_power(
             left_attrs, right_attrs, machine_precision
@@ -252,7 +243,6 @@ def _eval_binary_op_constant(
 def eval_binary_op(
     expr_val: QmodAnnotatedExpression,
     node: ast.BinOp,
-    treat_qnum_as_float: bool,
     machine_precision: int,
 ) -> None:
     left = node.left
@@ -261,7 +251,7 @@ def eval_binary_op(
 
     left_type = expr_val.get_type(left)
     right_type = expr_val.get_type(right)
-    _validate_binary_op(op, left_type, right_type, treat_qnum_as_float)
+    _validate_binary_op(op, left_type, right_type)
 
     inferred_type = _infer_binary_op_type(
         expr_val,
@@ -269,7 +259,6 @@ def eval_binary_op(
         left_type,
         right_type,
         machine_precision,
-        treat_qnum_as_float,
     )
     expr_val.set_type(node, inferred_type)
 

classiq/evaluators/qmod_node_evaluators/min_max_evaluation.py

@@ -31,7 +31,6 @@ def _infer_min_max_op_type(
     node: ast.Call,
     func_name: str,
     args_types: list[QmodType],
-    treat_qnum_as_float: bool,
     machine_precision: int,
 ) -> QmodType:
     if all(is_classical_type(arg_type) for arg_type in args_types):
@@ -41,9 +40,7 @@ def _infer_min_max_op_type(
 
     args_attrs: list[NumericAttributes] = []
     for arg, arg_type in zip(node.args, args_types):
-        attrs = get_numeric_attrs(
-            expr_val, arg, arg_type, machine_precision, treat_qnum_as_float
-        )
+        attrs = get_numeric_attrs(expr_val, arg, arg_type, machine_precision)
         if attrs is None:
             return QuantumNumeric()
         args_attrs.append(attrs)
@@ -62,7 +59,6 @@ def eval_min_max_op(
     expr_val: QmodAnnotatedExpression,
     node: ast.Call,
     func_name: str,
-    treat_qnum_as_float: bool,
     machine_precision: int,
 ) -> None:
     if len(node.args) < 1:
@@ -79,7 +75,6 @@ def eval_min_max_op(
         node,
         func_name,
         args_types,
-        treat_qnum_as_float,
         machine_precision,
     )
     expr_val.set_type(node, inferred_type)

classiq/evaluators/qmod_node_evaluators/numeric_attrs_utils.py

@@ -21,14 +21,11 @@ def get_numeric_attrs(
     node: ast.AST,
     qmod_type: QmodType,
     machine_precision: int,
-    treat_qnum_as_float: bool,
 ) -> NumericAttributes | None:
     if isinstance(qmod_type, Bool):
         return NumericAttributes.from_bounds(0, 1, 0, machine_precision)
     if is_classical_type(qmod_type):
-        value = get_classical_value_for_arithmetic(
-            expr_val, node, qmod_type, treat_qnum_as_float
-        )
+        value = get_classical_value_for_arithmetic(expr_val, node, qmod_type)
         if value is None:
             return None
         return NumericAttributes.from_constant(value, machine_precision)
@@ -44,7 +41,6 @@ def get_classical_value_for_arithmetic(
     expr_val: QmodAnnotatedExpression,
     node: ast.AST,
     qmod_type: QmodType,
-    treat_qnum_as_float: bool,
 ) -> float | None:
     if not is_classical_type(qmod_type):
         return None
@@ -55,8 +51,6 @@ def get_classical_value_for_arithmetic(
     if isinstance(value, sympy.Basic):
         value = get_sympy_val(value)
     if not isinstance(value, (int, float)):
-        if treat_qnum_as_float and isinstance(value, complex):
-            return None
         raise ClassiqExpansionError(
             "Arithmetic of quantum variables and non-real values is not supported"
         )