classiq 0.69.0__py3-none-any.whl → 0.70.0__py3-none-any.whl

classiq/model_expansions/quantum_operations/quantum_function_call.py

@@ -1,9 +1,5 @@
 from typing import TYPE_CHECKING
 
-from classiq.interface.exceptions import ClassiqValueError
-from classiq.interface.generator.expressions.expression import Expression
-from classiq.interface.model.allocate import Allocate
-from classiq.interface.model.handle_binding import HandleBinding
 from classiq.interface.model.quantum_function_call import QuantumFunctionCall
 
 from classiq.model_expansions.closure import FunctionClosure
@@ -17,21 +13,12 @@ if TYPE_CHECKING:
     from classiq.model_expansions.interpreters.base_interpreter import BaseInterpreter
 
 
-ALLOCATE_COMPATIBILITY_ERROR_MESSAGE = (
-    "'allocate' expects two argument: The number of qubits to allocate (integer) and "
-    "the variable to be allocated (quantum variable)"
-)
-
-
 class QuantumFunctionCallEmitter(CallEmitter[QuantumFunctionCall]):
     def __init__(self, interpreter: "BaseInterpreter") -> None:
         super().__init__(interpreter)
         self._model = self._interpreter._model
 
     def emit(self, call: QuantumFunctionCall, /) -> bool:
-        if call.function == "allocate":  # FIXME: Remove compatibility (CAD-25935)
-            self._allocate_compatibility(call)
-            return True
         function = self._interpreter.evaluate(call.function).as_type(FunctionClosure)
         args = call.positional_args
         with ErrorManager().call(function.name):
@@ -40,15 +27,6 @@ class QuantumFunctionCallEmitter(CallEmitter[QuantumFunctionCall]):
             )
         return True
 
-    def _allocate_compatibility(self, call: QuantumFunctionCall) -> None:
-        if len(call.positional_args) != 2:
-            raise ClassiqValueError(ALLOCATE_COMPATIBILITY_ERROR_MESSAGE)
-        size, target = call.positional_args
-        if not isinstance(size, Expression) or not isinstance(target, HandleBinding):
-            raise ClassiqValueError(ALLOCATE_COMPATIBILITY_ERROR_MESSAGE)
-        allocate = Allocate(size=size, target=target, source_ref=call.source_ref)
-        self._interpreter.emit_statement(allocate)
-
 
 class DeclarativeQuantumFunctionCallEmitter(
     QuantumFunctionCallEmitter, DeclarativeCallEmitter

classiq/model_expansions/scope.py

@@ -19,7 +19,7 @@ from classiq.interface.generator.expressions.expression import Expression
 from classiq.interface.generator.expressions.expression_constants import (
     CPARAM_EXECUTION_SUFFIX_PATTERN,
 )
-from classiq.interface.generator.expressions.qmod_struct_instance import (
+from classiq.interface.generator.expressions.proxies.classical.qmod_struct_instance import (
     QmodStructInstance,
 )
 from classiq.interface.generator.functions.type_name import TypeName
@@ -72,9 +72,9 @@ class QuantumSymbol:
         array_length = self.quantum_type.length_value
         if start < 0 or end > array_length:
             raise ClassiqExpansionError(
-                f"Slice [{start}:{end}] is out of bounds of "
-                f"{self.quantum_type.type_name} {str(self.handle)!r} of length "
-                f"{array_length}"
+                f"Slice [{start}:{end}] is out of bounds for "
+                f"{self.quantum_type.type_name.lower()} {str(self.handle)!r} (of "
+                f"length {array_length})"
             )
         return QuantumSymbol(
             handle=SlicedHandleBinding(
@@ -96,8 +96,9 @@ class QuantumSymbol:
         array_length = self.quantum_type.length_value
         if index < 0 or index >= array_length:
             raise ClassiqExpansionError(
-                f"Subscript {index} is out of bounds of {self.quantum_type.type_name} "
-                f"{str(self.handle)!r} of length {array_length}"
+                f"Index {index} is out of bounds for "
+                f"{self.quantum_type.type_name.lower()} {str(self.handle)!r} (of "
+                f"length {array_length})"
             )
         return QuantumSymbol(
             handle=SubscriptHandleBinding(

classiq/model_expansions/scope_initialization.py

@@ -1,16 +1,17 @@
 from collections.abc import Sequence
-from typing import Any
 
-from classiq.interface.exceptions import ClassiqError
+from classiq.interface.exceptions import ClassiqError, ClassiqInternalExpansionError
 from classiq.interface.generator.constant import Constant
+from classiq.interface.generator.functions.classical_type import (
+    ClassicalArray,
+    ClassicalList,
+)
 from classiq.interface.generator.functions.concrete_types import ConcreteClassicalType
 from classiq.interface.model.handle_binding import HandleBinding
 from classiq.interface.model.model import MAIN_FUNCTION_NAME, Model
 from classiq.interface.model.native_function_definition import NativeFunctionDefinition
 from classiq.interface.model.port_declaration import PortDeclaration
-from classiq.interface.model.quantum_function_declaration import (
-    PositionalArg,
-)
+from classiq.interface.model.quantum_function_declaration import PositionalArg
 
 from classiq.model_expansions.closure import FunctionClosure, GenerativeFunctionClosure
 from classiq.model_expansions.evaluators.classical_expression import (
@@ -125,14 +126,6 @@ def init_builtin_types() -> None:
     QMODULE.type_decls |= BUILTIN_STRUCT_DECLARATIONS
 
 
-def _add_exec_param_parts_to_scope(param_val: Any, scope: Scope) -> None:
-    if not isinstance(param_val, list):
-        scope[str(param_val)] = Evaluated(value=param_val)
-        return
-    for param_part in param_val:
-        _add_exec_param_parts_to_scope(param_part, scope)
-
-
 def init_exec_params(model: Model, scope: Scope) -> dict[str, ConcreteClassicalType]:
     if model.execution_parameters is not None:
         exec_params = model.execution_parameters
@@ -144,8 +137,16 @@ def init_exec_params(model: Model, scope: Scope) -> dict[str, ConcreteClassicalT
             ).param_decls
         }
     for param_name, param_type in exec_params.items():
-        param_val = param_type.as_symbolic(param_name)
+        param_val = param_type.get_classical_proxy(
+            handle=HandleBinding(name=param_name)
+        )
         scope[param_name] = Evaluated(value=param_val)
-        if isinstance(param_val, list):
-            _add_exec_param_parts_to_scope(param_val, scope)
     return exec_params
+
+
+def _get_shape(classical_type: ConcreteClassicalType) -> tuple[int, ...]:
+    if isinstance(classical_type, ClassicalList):
+        raise ClassiqInternalExpansionError("Unexpected classical list")
+    if isinstance(classical_type, ClassicalArray):
+        return classical_type.size, *_get_shape(classical_type.element_type)
+    return ()

classiq/model_expansions/transformers/model_renamer.py

@@ -1,4 +1,5 @@
 import ast
+import re
 from collections.abc import Mapping, Sequence
 from dataclasses import dataclass
 from typing import TypeVar, cast
@@ -16,6 +17,12 @@ from classiq.model_expansions.visitors.variable_references import VarRefCollecto
 AST_NODE = TypeVar("AST_NODE", bound=NodeType)
 
 
+def _replace_full_word(pattern: str, substitution: str, target: str) -> str:
+    return re.sub(
+        rf"(^|\b|\W)({re.escape(pattern)})($|\b|\W)", rf"\1{substitution}\3", target
+    )
+
+
 @dataclass(frozen=True)
 class HandleRenaming:
     source_handle: HandleBinding
@@ -74,7 +81,7 @@ class ModelRenamer:
         symbol_mapping: SymbolRenaming,
         expression: Expression,
     ) -> Expression:
-        vrc = VarRefCollector(ignore_duplicated_handles=True)
+        vrc = VarRefCollector(ignore_duplicated_handles=True, ignore_sympy_symbols=True)
         vrc.visit(ast.parse(expression.expr))
 
         handle_names = {
@@ -87,10 +94,12 @@ class ModelRenamer:
             new_handle = handle.collapse()
             for handle_to_replace, replacement in handle_names.items():
                 new_handle = new_handle.replace_prefix(handle_to_replace, replacement)
-            new_expr_str = new_expr_str.replace(str(handle), str(new_handle))
+            new_expr_str = _replace_full_word(
+                str(handle), str(new_handle), new_expr_str
+            )
             if handle.qmod_expr != str(handle):
-                new_expr_str = new_expr_str.replace(
-                    handle.qmod_expr, new_handle.qmod_expr
+                new_expr_str = _replace_full_word(
+                    str(handle.qmod_expr), str(new_handle.qmod_expr), new_expr_str
                 )
 
         new_expr = Expression(expr=new_expr_str)

classiq/model_expansions/visitors/variable_references.py

@@ -24,10 +24,14 @@ from classiq.interface.model.handle_binding import (
 
 class VarRefCollector(ast.NodeVisitor):
     def __init__(
-        self, ignore_duplicated_handles: bool = False, unevaluated: bool = False
+        self,
+        ignore_duplicated_handles: bool = False,
+        unevaluated: bool = False,
+        ignore_sympy_symbols: bool = False,
     ) -> None:
         self._var_handles: dict[HandleBinding, bool] = {}
         self._ignore_duplicated_handles = ignore_duplicated_handles
+        self._ignore_sympy_symbols = ignore_sympy_symbols
         self._unevaluated = unevaluated
         self._is_nested = False
 
@@ -117,9 +121,9 @@ class VarRefCollector(ast.NodeVisitor):
         return handle
 
     def visit_Name(self, node: ast.Name) -> Optional[HandleBinding]:
-        if node.id in set(SYMPY_SUPPORTED_EXPRESSIONS) | set(
-            DEFAULT_SUPPORTED_FUNC_NAMES
-        ):
+        if not self._ignore_sympy_symbols and node.id in set(
+            SYMPY_SUPPORTED_EXPRESSIONS
+        ) | set(DEFAULT_SUPPORTED_FUNC_NAMES):
             return None
         handle = HandleBinding(name=node.id)
         if not self._is_nested:

classiq/open_library/functions/__init__.py

@@ -9,6 +9,7 @@ from .grover import *
 from .hea import *
 from .linear_pauli_rotation import *
 from .linear_pauli_rotation import _single_pauli
+from .lookup_table import span_lookup_table
 from .modular_exponentiation import *
 from .modular_exponentiation import _check_msb
 from .qaoa_penalty import *
@@ -131,6 +132,7 @@ __all__ = [
     "qsvt_lcu_step",
     "qsvt_step",
     "reflect_about_zero",
+    "span_lookup_table",
     "suzuki_trotter",
     "swap_test",
     "switch",

classiq/open_library/functions/lookup_table.py

@@ -0,0 +1,58 @@
+from itertools import product
+
+from classiq.interface.exceptions import ClassiqValueError
+
+from classiq.qmod.builtins.operations import assign, bind, within_apply
+from classiq.qmod.qmod_variable import QNum
+from classiq.qmod.symbolic import subscript
+from classiq.qmod.utilities import RealFunction, get_temp_var_name, qnum_values
+
+
+def _get_qnum_values(num: QNum) -> list[float]:
+    size = num.size
+    is_signed = num.is_signed
+    fraction_digits = num.fraction_digits
+    if (
+        not isinstance(size, int)
+        or not isinstance(is_signed, bool)
+        or not isinstance(fraction_digits, int)
+    ):
+        raise ClassiqValueError(
+            "Must call 'span_lookup_table' inside a generative qfunc"
+        )
+
+    return qnum_values(size, is_signed, fraction_digits)
+
+
+def span_lookup_table(func: RealFunction, *targets: QNum) -> QNum:
+    """
+    Applies a classical function to quantum numbers.
+
+    Works by reducing the function into a lookup table over all the possible values
+    of the quantum numbers.
+
+    Args:
+        func: A Python function
+        *targets: One or more initialized quantum numbers
+
+    Returns:
+        The quantum result of applying func to targets
+
+    Notes:
+        Must be called inside a generative function (`@qfunc(generative=True)`)
+    """
+    if len(targets) == 0:
+        raise ClassiqValueError("No targets specified")
+
+    target_vals = [_get_qnum_values(target) for target in targets]
+    lookup_table = [func(*vals[::-1]) for vals in product(*target_vals[::-1])]
+
+    index_size = sum(target.size for target in targets)
+    index: QNum = QNum(get_temp_var_name(), size=index_size)
+    result: QNum = QNum(get_temp_var_name("result"))
+
+    within_apply(
+        lambda: bind(list(targets), index),
+        lambda: assign(subscript(lookup_table, index), result),
+    )
+    return result

classiq/qmod/declaration_inferrer.py

@@ -38,6 +38,7 @@ from classiq.qmod.model_state_container import ModelStateContainer
 from classiq.qmod.python_classical_type import PythonClassicalType
 from classiq.qmod.qmod_variable import QVar
 from classiq.qmod.quantum_callable import QCallableList
+from classiq.qmod.semantics.validation.type_hints import validate_annotation
 from classiq.qmod.utilities import unmangle_keyword, version_portable_get_args
 
 if sys.version_info[0:2] >= (3, 9):
@@ -123,7 +124,7 @@ def _extract_operand_decl(
 
 
 def _extract_operand_param(py_type: Any) -> tuple[Optional[str], Any]:
-    if sys.version_info[0:2] < (3, 9) or get_origin(py_type) is not Annotated:
+    if get_origin(py_type) is not Annotated:
         return None, py_type
     args = get_args(py_type)
     if len(args) == 2:
@@ -163,6 +164,7 @@ def _extract_positional_args(
 ) -> Sequence[AnonPositionalArg]:
     result: list[AnonPositionalArg] = []
     for name, py_type in args:
+        validate_annotation(py_type)
         if name == "return":
             continue
         name = unmangle_keyword(name)

classiq/qmod/qmod_parameter.py

@@ -22,6 +22,11 @@ from classiq.qmod.cparam import (  # noqa: F401
     CParamScalar,
     CReal,
 )
+from classiq.qmod.generative import (
+    generative_mode_context,
+    interpret_expression,
+    is_generative_mode,
+)
 from classiq.qmod.model_state_container import ModelStateContainer
 from classiq.qmod.symbolic_expr import Symbolic, SymbolicExpr
 
@@ -66,6 +71,9 @@ class CParamList(CParam):
 
     @property
     def len(self) -> CParamScalar:
+        if is_generative_mode():
+            with generative_mode_context(False):
+                return interpret_expression(str(self.len))
         return CParamScalar(f"get_field({self}, 'len')")
 
 

classiq/qmod/qmod_variable.py

@@ -23,7 +23,7 @@ from typing_extensions import ParamSpec, Self, _AnnotatedAlias
 from classiq.interface.exceptions import ClassiqValueError
 from classiq.interface.generator.expressions.expression import Expression
 from classiq.interface.generator.expressions.non_symbolic_expr import NonSymbolicExpr
-from classiq.interface.generator.expressions.qmod_qarray_proxy import (
+from classiq.interface.generator.expressions.proxies.quantum.qmod_qarray_proxy import (
     ILLEGAL_SLICE_MSG,
     ILLEGAL_SLICING_STEP_MSG,
 )
@@ -72,12 +72,6 @@ from classiq.qmod.utilities import (
 )
 
 
-def _is_input_output_typehint(type_hint: Any) -> bool:
-    return isinstance(type_hint, _AnnotatedAlias) and isinstance(
-        type_hint.__metadata__[0], PortDeclarationDirection
-    )
-
-
 def get_type_hint_expr(type_hint: Any) -> str:
     if isinstance(type_hint, ForwardRef):  # expression in string literal
         return str(type_hint.__forward_arg__)
@@ -143,9 +137,12 @@ class QVar(Symbolic):
 
     @staticmethod
     def from_type_hint(type_hint: Any) -> Optional[type["QVar"]]:
-        if _is_input_output_typehint(type_hint):
-            return QVar.from_type_hint(type_hint.__args__[0])
-        type_ = get_origin(type_hint) or type_hint
+        non_annotated_type = (
+            type_hint.__origin__
+            if isinstance(type_hint, _AnnotatedAlias)
+            else type_hint
+        )
+        type_ = get_origin(non_annotated_type) or non_annotated_type
         if issubclass(type_, QVar):
             if issubclass(type_, QStruct):
                 with _no_current_expandable():
@@ -170,10 +167,10 @@ class QVar(Symbolic):
 
     @classmethod
     def port_direction(cls, type_hint: Any) -> PortDeclarationDirection:
-        if _is_input_output_typehint(type_hint):
-            assert len(type_hint.__metadata__) >= 1
-            return type_hint.__metadata__[0]
-        assert type_hint == cls or get_origin(type_hint) == cls
+        if isinstance(type_hint, _AnnotatedAlias):
+            for metadata in type_hint.__metadata__:
+                if isinstance(metadata, PortDeclarationDirection):
+                    return metadata
         return PortDeclarationDirection.Inout
 
     def __str__(self) -> str:

classiq/qmod/semantics/annotation/call_annotation.py

@@ -3,18 +3,9 @@ from contextlib import contextmanager
 from typing import Any, Optional
 
 from classiq.interface.exceptions import ClassiqError
-from classiq.interface.generator.expressions.expression import Expression
-from classiq.interface.generator.functions.classical_type import Integer
-from classiq.interface.generator.functions.port_declaration import (
-    PortDeclarationDirection,
-)
-from classiq.interface.model.classical_parameter_declaration import (
-    ClassicalParameterDeclaration,
-)
 from classiq.interface.model.model import Model
 from classiq.interface.model.model_visitor import ModelVisitor
 from classiq.interface.model.native_function_definition import NativeFunctionDefinition
-from classiq.interface.model.port_declaration import PortDeclaration
 from classiq.interface.model.quantum_function_call import QuantumFunctionCall
 from classiq.interface.model.quantum_function_declaration import (
     AnonQuantumOperandDeclaration,
@@ -24,36 +15,17 @@ from classiq.interface.model.quantum_function_declaration import (
 from classiq.interface.model.quantum_lambda_function import (
     QuantumLambdaFunction,
 )
-from classiq.interface.model.quantum_type import QuantumBitvector
 
 from classiq.qmod.builtins.functions import BUILTIN_FUNCTION_DECLARATIONS
 from classiq.qmod.semantics.annotation.qstruct_annotator import QStructAnnotator
 from classiq.qmod.semantics.error_manager import ErrorManager
 from classiq.qmod.semantics.lambdas import get_renamed_parameters
 
-ALLOCATE_DECL_FOR_COMPATIBILITY = QuantumFunctionDeclaration(
-    name="allocate",
-    positional_arg_declarations=[
-        ClassicalParameterDeclaration(
-            name="num_qubits",
-            classical_type=Integer(),
-        ),
-        PortDeclaration(
-            name="out",
-            quantum_type=QuantumBitvector(length=Expression(expr="num_qubits")),
-            direction=PortDeclarationDirection.Output,
-        ),
-    ],
-)
-
 
 def _annotate_function_call_decl(
     fc: QuantumFunctionCall,
     function_dict: Mapping[str, QuantumFunctionDeclaration],
 ) -> None:
-    if fc.function == "allocate":  # FIXME: Remove compatibility (CAD-25935)
-        fc.set_func_decl(ALLOCATE_DECL_FOR_COMPATIBILITY)
-        return
     if fc._func_decl is None:
         func_decl = function_dict.get(fc.func_name)
         if func_decl is None:

classiq/qmod/semantics/annotation/qstruct_annotator.py

@@ -9,8 +9,18 @@ class QStructAnnotator(ModelVisitor):
         self._visited: set[TypeName] = set()
 
     def visit_TypeName(self, type_name: TypeName) -> None:
+        self._annotate_quantum_struct(type_name)
+        self._annotate_classical_struct(type_name)
+
+    def _annotate_quantum_struct(self, type_name: TypeName) -> None:
+        if (
+            type_name.has_classical_struct_decl
+            or type_name.has_fields
+            or type_name in self._visited
+        ):
+            return
         decl = QMODULE.qstruct_decls.get(type_name.name)
-        if decl is None or type_name.has_fields or (type_name in self._visited):
+        if decl is None:
             return
         self._visited.add(type_name)
         new_fields = {
@@ -21,3 +31,13 @@ class QStructAnnotator(ModelVisitor):
         # qstructs
         self.visit(new_fields)
         type_name.set_fields(new_fields)
+
+    def _annotate_classical_struct(self, type_name: TypeName) -> None:
+        if type_name.has_classical_struct_decl or type_name.has_fields:
+            return
+        decl = QMODULE.type_decls.get(type_name.name)
+        if decl is None:
+            return
+        type_name.set_classical_struct_decl(decl)
+        for field_type in decl.variables.values():
+            self.visit(field_type)

classiq/qmod/semantics/validation/main_validation.py

@@ -25,7 +25,7 @@ def _validate_main_classical_param_type(
 ) -> None:
     if isinstance(param, ClassicalList):
         raise ClassiqExpansionError(
-            f"Classical array parameter {param_name!r} of function 'main' must must "
+            f"Classical array parameter {param_name!r} of function 'main' must "
             f"specify array length",
         )
     if isinstance(param, ClassicalArray):

classiq/qmod/semantics/validation/type_hints.py

@@ -0,0 +1,29 @@
+from typing import Any
+
+from typing_extensions import _AnnotatedAlias
+
+from classiq.interface.exceptions import ClassiqValueError
+from classiq.interface.generator.functions.port_declaration import (
+    PortDeclarationDirection,
+)
+
+annotation_map: dict[PortDeclarationDirection, str] = {
+    PortDeclarationDirection.Input: PortDeclarationDirection.Input.name,
+    PortDeclarationDirection.Output: PortDeclarationDirection.Output.name,
+}
+
+
+def validate_annotation(type_hint: Any) -> None:
+    if not isinstance(type_hint, _AnnotatedAlias):
+        return
+    directions: list[PortDeclarationDirection] = [
+        direction
+        for direction in type_hint.__metadata__
+        if isinstance(direction, PortDeclarationDirection)
+    ]
+    if len(directions) <= 1:
+        return
+    raise ClassiqValueError(
+        f"Multiple directions are not allowed in a single type hint: "
+        f"[{', '.join(annotation_map[direction] for direction in reversed(directions))}]\n"
+    )

classiq/qmod/utilities.py

@@ -3,6 +3,7 @@ import inspect
 import itertools
 import keyword
 import sys
+from collections import Counter
 from collections.abc import Iterable
 from enum import Enum as PythonEnum
 from types import FrameType
@@ -21,7 +22,7 @@ from typing import (
 
 from typing_extensions import ParamSpec
 
-from classiq.interface.generator.expressions.qmod_struct_instance import (
+from classiq.interface.generator.expressions.proxies.classical.qmod_struct_instance import (
     QmodStructInstance,
 )
 from classiq.interface.source_reference import SourceReference
@@ -160,3 +161,39 @@ def suppress_return_value(func: Callable[Params, None]) -> Callable[Params, None
 
 
 Statements = Union[None, list[Union[None, "QVar"]], tuple[Union[None, "QVar"], ...]]
+
+
+def _eval_qnum(val: int, size: int, is_signed: bool, fraction_digits: int) -> float:
+    if val < 0 or val >= 2**size:
+        raise ValueError
+    if size == 1 and is_signed and fraction_digits == 1:
+        return -0.5 if val == 1 else 0
+    if is_signed and val & (1 << (size - 1)) > 0:
+        val ^= 1 << (size - 1)
+        val -= 1 << (size - 1)
+    return val * 2**-fraction_digits
+
+
+def qnum_values(size: int, is_signed: bool, fraction_digits: int) -> list[float]:
+    return [_eval_qnum(i, size, is_signed, fraction_digits) for i in range(2**size)]
+
+
+def qnum_attributes(max_size: int) -> list[tuple[int, bool, int]]:
+    return [(1, True, 1)] + [
+        (size, is_signed, fraction_digits)
+        for size in range(1, max_size + 1)
+        for is_signed in (False, True)
+        for fraction_digits in range(size - int(is_signed) + 1)
+    ]
+
+
+_VAR_NAME_COUNTER: Counter[str] = Counter()
+
+
+def get_temp_var_name(var_name: str = "temp") -> str:
+    n = _VAR_NAME_COUNTER[var_name]
+    _VAR_NAME_COUNTER[var_name] += 1
+    return f"{var_name}_{n}"
+
+
+RealFunction = Callable[Params, float]

{classiq-0.69.0.dist-info → classiq-0.70.0.dist-info}/METADATA

@@ -1,26 +1,25 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.3
 Name: classiq
-Version: 0.69.0
+Version: 0.70.0
 Summary: Classiq's Python SDK for quantum computing
-Home-page: https://classiq.io
 License: Proprietary
 Keywords: quantum computing,quantum circuits,quantum algorithms,QAD,QDL
 Author: Classiq Technologies
 Author-email: support@classiq.io
-Requires-Python: >=3.9,<3.13
+Requires-Python: >=3.9, <3.13
 Classifier: Development Status :: 4 - Beta
+Classifier: License :: Other/Proprietary License
 Classifier: Intended Audience :: Developers
 Classifier: Intended Audience :: Education
 Classifier: Intended Audience :: Science/Research
 Classifier: License :: Other/Proprietary License
 Classifier: Natural Language :: English
 Classifier: Operating System :: OS Independent
-Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
 Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
-Classifier: Programming Language :: Python :: 3 :: Only
 Classifier: Topic :: Scientific/Engineering
 Classifier: Topic :: Software Development
 Classifier: Topic :: Software Development :: Code Generators
@@ -33,12 +32,12 @@ Requires-Dist: ConfigArgParse (>=1.5.3,<2.0.0)
 Requires-Dist: Pyomo (>=6.5,<6.6)
 Requires-Dist: black (>=24.0,<25.0)
 Requires-Dist: httpx (>=0.23.0,<1)
-Requires-Dist: ipywidgets (>=7.7.1,<8.0.0) ; extra == "analyzer-sdk"
-Requires-Dist: jupyterlab (>=4.2.5,<5.0.0) ; extra == "analyzer-sdk"
+Requires-Dist: ipywidgets ; extra == "analyzer-sdk"
+Requires-Dist: jupyterlab ; extra == "analyzer-sdk"
 Requires-Dist: keyring (>=23.5.0,<24.0.0)
 Requires-Dist: matplotlib (>=3.4.3,<4.0.0)
 Requires-Dist: networkx (>=2.5.1,<3.0.0)
-Requires-Dist: notebook (>=7.2.2,<8.0.0) ; extra == "analyzer-sdk"
+Requires-Dist: notebook ; extra == "analyzer-sdk"
 Requires-Dist: numexpr (>=2.7.3,<3.0.0)
 Requires-Dist: numpy (>=1.20.1,<2.0.0) ; python_version < "3.12"
 Requires-Dist: numpy (>=1.26.0,<2.0.0) ; python_version >= "3.12"
@@ -51,10 +50,9 @@ Requires-Dist: scipy (>=1.10.0,<2.0.0) ; python_version < "3.12"
 Requires-Dist: scipy (>=1.11.0,<2.0.0) ; python_version >= "3.12"
 Requires-Dist: sympy (>=1.13.0,<2.0.0)
 Requires-Dist: tabulate (>=0.8.9,<1)
-Requires-Dist: torch (>=2.0,<3.0) ; extra == "qml"
-Requires-Dist: torchvision (>=0.15,<1.0) ; extra == "qml"
+Requires-Dist: torch ; extra == "qml"
+Requires-Dist: torchvision ; extra == "qml"
 Requires-Dist: tqdm (>=4.67.1,<5.0.0)
-Project-URL: Documentation, https://docs.classiq.io/
 Description-Content-Type: text/markdown
 
 <p align="center">