classiq 0.83.0__py3-none-any.whl → 0.85.0__py3-none-any.whl

classiq/qmod/python_classical_type.py

@@ -31,7 +31,9 @@ CARRAY_ERROR_MESSAGE = (
 
 
 class PythonClassicalType:
-    def convert(self, py_type: type) -> Optional[ConcreteClassicalType]:
+    def convert(
+        self, py_type: type, nested: bool = False
+    ) -> Optional[ConcreteClassicalType]:
         if py_type is int:
             return Integer().set_generative()
         elif py_type is CInt:
@@ -45,16 +47,18 @@ class PythonClassicalType:
         elif py_type is CBool:
             return Bool()
         elif get_origin(py_type) is list:
-            element_type = self.convert(get_args(py_type)[0])
+            element_type = self.convert(get_args(py_type)[0], nested=True)
             if element_type is not None:
                 return ClassicalArray(element_type=element_type).set_generative()
         elif get_origin(py_type) is CArray:
             array_args = version_portable_get_args(py_type)
             if len(array_args) == 1:
-                return ClassicalArray(element_type=self.convert(array_args[0]))
+                return ClassicalArray(
+                    element_type=self.convert(array_args[0], nested=True)
+                )
             elif len(array_args) == 2:
                 return ClassicalArray(
-                    element_type=self.convert(array_args[0]),
+                    element_type=self.convert(array_args[0], nested=True),
                     length=Expression(expr=get_type_hint_expr(array_args[1])),
                 )
             raise ClassiqValueError(CARRAY_ERROR_MESSAGE)
@@ -62,7 +66,10 @@ class PythonClassicalType:
             return self.register_struct(py_type)
         elif inspect.isclass(py_type) and isinstance(py_type, EnumMeta):
             self.register_enum(py_type)
-            return Enum(name=py_type.__name__).set_generative()
+            enum_type = Enum(name=py_type.__name__)
+            if not nested:
+                enum_type.set_generative()
+            return enum_type
         elif py_type in (CArray, list):
             raise ClassiqValueError(CARRAY_ERROR_MESSAGE)
         return None

classiq/qmod/qfunc.py

@@ -1,7 +1,6 @@
-import warnings
 from typing import Callable, Literal, Optional, Union, overload
 
-from classiq.interface.exceptions import ClassiqDeprecationWarning, ClassiqInternalError
+from classiq.interface.exceptions import ClassiqInternalError
 
 from classiq.qmod.global_declarative_switch import get_global_declarative_switch
 from classiq.qmod.quantum_callable import QCallable
@@ -57,23 +56,7 @@ def qfunc(
     synthesize_separately: bool = False,
     unchecked: Optional[list[str]] = None,
 ) -> Union[Callable[[Callable], QCallable], QCallable]:
-    if generative is True:
-        warnings.warn(
-            "The use of `generative=True` is no longer required. Note that the "
-            "treatment of parameters of Qmod types will change from Python value to "
-            "symbolic in a near release. Change Qmod types to the corresponding Python "
-            "built-in types in order to use the parameters in Python expression "
-            "contexts.\n"
-            "Recommended changes:\n"
-            "@qfunc(generative=True) -> @qfunc\n"
-            "CInt->int\n"
-            "CReal->float\n"
-            "CArray->list\n\n"
-            "For more information see https://docs.classiq.io/latest/qmod-reference/language-reference/generative-descriptions/",
-            ClassiqDeprecationWarning,
-            stacklevel=2,
-        )
-    elif generative is None:
+    if generative is None:
         generative = True
     if get_global_declarative_switch():
         generative = False

classiq/qmod/qmod_constant.py

@@ -5,10 +5,7 @@ from typing import TYPE_CHECKING, Any, Optional, cast, get_origin
 from classiq.interface.exceptions import ClassiqError, ClassiqValueError
 from classiq.interface.generator.constant import Constant
 from classiq.interface.generator.expressions.expression import Expression
-from classiq.interface.generator.functions.classical_type import (
-    ClassicalArray,
-    ClassicalList,
-)
+from classiq.interface.generator.functions.classical_type import ClassicalArray
 
 from classiq.qmod.cparam import CArray, CParamScalar
 from classiq.qmod.declaration_inferrer import python_type_to_qmod
@@ -118,7 +115,7 @@ class QConstant(SymbolicExpr):
         if qmod_type is None:
             raise ClassiqError("Invalid QMOD type")
 
-        if not isinstance(qmod_type, (ClassicalList, ClassicalArray)):
+        if not isinstance(qmod_type, ClassicalArray):
             raise ClassiqError("Invalid subscript to non-list constant")
 
         return CParamList(

classiq/qmod/qmod_parameter.py

@@ -4,7 +4,6 @@ from classiq.interface.exceptions import ClassiqInternalError, ClassiqValueError
 from classiq.interface.generator.functions.classical_type import (
     Bool,
     ClassicalArray,
-    ClassicalList,
     ClassicalTuple,
     ClassicalType,
     Integer,
@@ -42,7 +41,7 @@ class CParamList(CParam):
     def __init__(
         self,
         expr: str,
-        list_type: Union[ClassicalList, ClassicalArray, ClassicalTuple],
+        list_type: Union[ClassicalArray, ClassicalTuple],
         qmodule: ModelStateContainer,
     ) -> None:
         super().__init__(expr)
@@ -149,7 +148,7 @@ def create_param(
         decl = ctype.classical_struct_decl
         ctype = Struct(name=ctype.name)
         ctype.set_classical_struct_decl(decl)
-    if isinstance(ctype, (ClassicalList, ClassicalArray, ClassicalTuple)):
+    if isinstance(ctype, (ClassicalArray, ClassicalTuple)):
         return CParamList(expr_str, ctype, qmodule=qmodule)
     elif isinstance(ctype, Struct):
         return CParamStruct(expr_str, ctype, qmodule=qmodule)
@@ -164,8 +163,6 @@ def get_qmod_type(ctype: ClassicalType) -> type:
         return CReal
     elif isinstance(ctype, Bool):
         return CBool
-    elif isinstance(ctype, ClassicalList):
-        return CArray[get_qmod_type(ctype.element_type)]  # type: ignore[misc]
     elif isinstance(ctype, ClassicalArray):
         if ctype.length is None:
             return CArray[get_qmod_type(ctype.element_type)]  # type: ignore[misc]

classiq/qmod/qmod_variable.py

@@ -34,19 +34,20 @@ from classiq.interface.generator.expressions.proxies.quantum.qmod_qarray_proxy i
     ILLEGAL_SLICE_MSG,
     ILLEGAL_SLICING_STEP_MSG,
 )
+from classiq.interface.generator.functions.concrete_types import ConcreteQuantumType
 from classiq.interface.generator.functions.port_declaration import (
     PortDeclarationDirection,
 )
 from classiq.interface.generator.functions.type_modifier import TypeModifier
-from classiq.interface.generator.functions.type_name import TypeName
+from classiq.interface.generator.functions.type_name import Struct, TypeName
 from classiq.interface.generator.types.qstruct_declaration import QStructDeclaration
+from classiq.interface.helpers.classproperty import classproperty
 from classiq.interface.model.handle_binding import (
     FieldHandleBinding,
     HandleBinding,
     SlicedHandleBinding,
     SubscriptHandleBinding,
 )
-from classiq.interface.model.port_declaration import AnonPortDeclaration
 from classiq.interface.model.quantum_expressions.amplitude_loading_operation import (
     AmplitudeLoadingOperation,
 )
@@ -73,7 +74,7 @@ from classiq.qmod.quantum_callable import QCallable
 from classiq.qmod.semantics.annotation.qstruct_annotator import QStructAnnotator
 from classiq.qmod.semantics.validation.types_validation import validate_qstruct
 from classiq.qmod.symbolic_expr import Symbolic, SymbolicExpr
-from classiq.qmod.symbolic_type import SymbolicTypes
+from classiq.qmod.symbolic_type import SYMBOLIC_TYPES, SymbolicTypes
 from classiq.qmod.utilities import (
     get_source_ref,
     unwrap_forward_ref,
@@ -103,9 +104,6 @@ def _infer_variable_name(name: Any, depth: int) -> Any:
     return name
 
 
-_SYMBOLIC_TYPES = tuple(get_origin(t) or t for t in get_args(SymbolicTypes))
-
-
 class QVar(Symbolic):
     CONSTRUCTOR_DEPTH: int = 1
 
@@ -136,7 +134,7 @@ class QVar(Symbolic):
         return self._base_handle
 
     @abc.abstractmethod
-    def get_qmod_type(self) -> QuantumType:
+    def get_qmod_type(self) -> ConcreteQuantumType:
         raise NotImplementedError()
 
     @classmethod
@@ -164,6 +162,14 @@ class QVar(Symbolic):
         return self.get_qmod_type().type_name
 
 
+class QmodExpressionCreator(Protocol):
+    """
+    A callable that creates a Qmod expression from the provided QVars.
+    """
+
+    def __call__(self, **kwargs: QVar) -> SymbolicExpr: ...
+
+
 _Q = TypeVar("_Q", bound=QVar)
 Output = Annotated[_Q, PortDeclarationDirection.Output]
 Input = Annotated[_Q, PortDeclarationDirection.Input]
@@ -221,7 +227,7 @@ class QScalar(QVar, SymbolicExpr):
         )
 
     def __ior__(self, other: Any) -> Self:
-        if not isinstance(other, _SYMBOLIC_TYPES):
+        if not isinstance(other, SYMBOLIC_TYPES):
             raise TypeError(
                 f"Invalid argument {other!r} for out-of-place arithmetic operation"
             )
@@ -232,7 +238,7 @@ class QScalar(QVar, SymbolicExpr):
         return self
 
     def __ixor__(self, other: Any) -> Self:
-        if not isinstance(other, _SYMBOLIC_TYPES):
+        if not isinstance(other, SYMBOLIC_TYPES):
             raise TypeError(
                 f"Invalid argument {other!r} for in-place arithmetic operation"
             )
@@ -243,7 +249,7 @@ class QScalar(QVar, SymbolicExpr):
         return self
 
     def __iadd__(self, other: Any) -> Self:
-        if not isinstance(other, _SYMBOLIC_TYPES):
+        if not isinstance(other, SYMBOLIC_TYPES):
             raise TypeError(
                 f"Invalid argument {other!r} for in-place arithmetic operation"
             )
@@ -254,7 +260,7 @@ class QScalar(QVar, SymbolicExpr):
         return self
 
     def __imul__(self, other: Any) -> Self:
-        if not isinstance(other, _SYMBOLIC_TYPES):
+        if not isinstance(other, SYMBOLIC_TYPES):
             raise TypeError(
                 f"Invalid argument {other!r} for out of ampltiude encoding operation"
             )
@@ -273,7 +279,7 @@ class QBit(QScalar):
     ) -> "QBit":
         return QBit(origin, _expr_str=expr_str)
 
-    def get_qmod_type(self) -> QuantumType:
+    def get_qmod_type(self) -> ConcreteQuantumType:
         return QuantumBit()
 
 
@@ -329,7 +335,7 @@ class QNum(Generic[_P], QScalar):
     ) -> "QNum":
         return QNum(origin, *_get_qnum_attributes(type_hint), _expr_str=expr_str)
 
-    def get_qmod_type(self) -> QuantumType:
+    def get_qmod_type(self) -> ConcreteQuantumType:
         return QuantumNumeric(
             size=self._size,
             is_signed=self._is_signed,
@@ -498,8 +504,15 @@ class QStruct(QVar):
             setattr(self, field_name, var)
         super().__init__(name, expr_str=_expr_str)
 
-    def get_qmod_type(self) -> QuantumType:
-        return TypeName(name=self._struct_name)
+    def get_qmod_type(self) -> ConcreteQuantumType:
+        classical_type = Struct(name=self._struct_name)
+        classical_type.set_fields(
+            {
+                field_name: field_var.get_qmod_type()
+                for field_name, field_var in self._fields.items()
+            }
+        )
+        return classical_type
 
     @classmethod
     def to_qvar(
@@ -529,9 +542,23 @@ class QStruct(QVar):
             _expr_str=expr_str,
         )
 
+    @classproperty
+    def num_qubits(cls) -> int:  # noqa: N805
+        """
+        The total number of qubits in this quantum struct.
+        Raises an error if the struct doesn't have a fixed size.
+        """
+        qvar = cls.to_qvar(HandleBinding(name="dummy"), type_hint=cls, expr_str=None)
+        quantum_type = qvar.get_qmod_type()
+        if not quantum_type.has_size_in_bits:
+            raise ClassiqValueError(
+                f"Could not infer the size of struct {qvar._struct_name!r}"
+            )
+        return quantum_type.size_in_bits
+
 
-def create_qvar_for_port_decl(port: AnonPortDeclaration, name: str) -> QVar:
-    return _create_qvar_for_qtype(port.quantum_type, HandleBinding(name=name))
+def create_qvar_from_quantum_type(quantum_type: ConcreteQuantumType, name: str) -> QVar:
+    return _create_qvar_for_qtype(quantum_type, HandleBinding(name=name))
 
 
 def _create_qvar_for_qtype(
@@ -689,17 +716,27 @@ def _get_quantum_bit_vector(type_hint: type[QArray]) -> QuantumBitvector:
     return QuantumBitvector(element_type=element_type, length=length_expr)
 
 
-def _get_quantum_struct(type_hint: type[QStruct]) -> TypeName:
-    _register_qstruct(type_hint, qmodule=QMODULE)
-    return TypeName(name=type_hint.__name__)
+def _get_quantum_struct(type_hint: type[QStruct]) -> Struct:
+    decl = _register_qstruct(type_hint, qmodule=QMODULE)
+    classical_type = Struct(name=type_hint.__name__)
+    if decl is not None:
+        classical_type.set_fields(
+            {
+                field_name: field_type.model_copy(deep=True)
+                for field_name, field_type in decl.fields.items()
+            }
+        )
+    return classical_type
 
 
 def _register_qstruct(
     type_hint: type[QStruct], *, qmodule: ModelStateContainer
-) -> None:
+) -> Optional[QStructDeclaration]:
     struct_name = type_hint.__name__
-    if type_hint is QStruct or struct_name in qmodule.qstruct_decls:
-        return
+    if type_hint is QStruct:
+        return None
+    if struct_name in qmodule.qstruct_decls:
+        return qmodule.qstruct_decls[struct_name]
 
     # temp assignment for recursive qstruct definitions
     qmodule.qstruct_decls[struct_name] = QStructDeclaration(name=struct_name)
@@ -714,6 +751,7 @@ def _register_qstruct(
     qmodule.qstruct_decls[struct_name] = struct_decl
     QStructAnnotator().visit(struct_decl)
     validate_qstruct(struct_decl)
+    return struct_decl
 
 
 def _validate_fields(type_hint: type[QStruct]) -> None:

classiq/qmod/quantum_expandable.py

@@ -68,7 +68,7 @@ from classiq.qmod.qmod_parameter import (
 )
 from classiq.qmod.qmod_variable import (
     QVar,
-    create_qvar_for_port_decl,
+    create_qvar_from_quantum_type,
 )
 from classiq.qmod.quantum_callable import QCallable, QExpandableInterface
 from classiq.qmod.symbolic_expr import SymbolicExpr
@@ -135,7 +135,7 @@ class QExpandable(QCallable, QExpandableInterface, ABC):
     ) -> None:
         self.append_statement_to_body(
             VariableDeclarationStatement(
-                name=name, quantum_type=qtype, source_ref=source_ref
+                name=name, qmod_type=qtype, source_ref=source_ref
             )
         )
 
@@ -163,7 +163,9 @@ class QExpandable(QCallable, QExpandableInterface, ABC):
                     create_param(actual_name, arg.classical_type, self._qmodule)
                 )
             elif isinstance(arg, AnonPortDeclaration):
-                result.append(create_qvar_for_port_decl(arg, actual_name))
+                result.append(
+                    create_qvar_from_quantum_type(arg.quantum_type, actual_name)
+                )
             else:
                 assert isinstance(arg, AnonQuantumOperandDeclaration)
                 result.append(QTerminalCallable(arg, idx))

classiq/qmod/quantum_function.py

@@ -1,12 +1,13 @@
 import ast
 import functools
+import warnings
 from abc import abstractmethod
 from dataclasses import is_dataclass
 from enum import EnumMeta
 from inspect import isclass
 from typing import Any, Callable, Optional, get_origin
 
-from classiq.interface.exceptions import ClassiqError
+from classiq.interface.exceptions import ClassiqDeprecationWarning, ClassiqError
 from classiq.interface.executor.execution_preferences import ExecutionPreferences
 from classiq.interface.generator.functions.port_declaration import (
     PortDeclarationDirection,
@@ -28,7 +29,7 @@ from classiq.qmod.declaration_inferrer import infer_func_decl, is_qvar
 from classiq.qmod.generative import set_frontend_interpreter
 from classiq.qmod.global_declarative_switch import get_global_declarative_switch
 from classiq.qmod.qmod_constant import QConstant
-from classiq.qmod.qmod_parameter import CArray
+from classiq.qmod.qmod_parameter import CArray, CParamList
 from classiq.qmod.quantum_callable import QCallable, QCallableList
 from classiq.qmod.quantum_expandable import QExpandable, QTerminalCallable
 from classiq.qmod.semantics.annotation.qstruct_annotator import QStructAnnotator
@@ -101,7 +102,12 @@ class QFunc(BaseQFunc):
     ) -> None:
         _validate_no_gen_params(py_callable.__annotations__)
         super().__init__(py_callable, compilation_metadata)
-        self.compilation_metadata: Optional[CompilationMetadata] = None
+        if compilation_metadata is not None and compilation_metadata.unchecked:
+            self.compilation_metadata: Optional[CompilationMetadata] = (
+                CompilationMetadata(unchecked=compilation_metadata.unchecked)
+            )
+        else:
+            self.compilation_metadata = None
 
     @property
     def func_decl(self) -> NamedParamsQuantumFunctionDeclaration:
@@ -213,6 +219,7 @@ class QFunc(BaseQFunc):
 
 
 class ExternalQFunc(QTerminalCallable):
+    FRAME_DEPTH = 2  # FIXME: Remove (CLS-2912)
     _decl: NamedParamsQuantumFunctionDeclaration
 
     def __init__(self, py_callable: Callable) -> None:
@@ -237,6 +244,44 @@ class ExternalQFunc(QTerminalCallable):
     def pure_decl(self) -> NamedParamsQuantumFunctionDeclaration:
         return self.func_decl
 
+    def __call__(self, *args: Any, **kwargs: Any) -> None:
+        if self._py_callable.__name__ == "parametric_suzuki_trotter":
+            warnings.warn(
+                (
+                    "Function 'parametric_suzuki_trotter' is deprecated and will no "
+                    "longer be supported starting on 21/7/2025 at the earliest. "
+                    "Instead, use 'multi_suzuki_trotter'."
+                ),
+                ClassiqDeprecationWarning,
+                stacklevel=2,
+            )
+        if self._py_callable.__name__ == "sparse_suzuki_trotter":
+            warnings.warn(
+                (
+                    "Function 'sparse_suzuki_trotter' is deprecated and will no "
+                    "longer be supported starting on 21/7/2025 at the earliest. "
+                    "Instead, use 'suzuki_trotter'."
+                ),
+                ClassiqDeprecationWarning,
+                stacklevel=2,
+            )
+        if (
+            self._py_callable.__name__ == "suzuki_trotter"
+            and len(args) > 0
+            and isinstance(args[0], (list, CParamList))
+        ):
+            warnings.warn(
+                (
+                    "Parameter type CArray[PauliTerm] to function 'suzuki_trotter' is "
+                    "deprecated and will no longer be supported starting on 21/7/2025 "
+                    "at the earliest. Instead, send a 'SparsePauliOp' (see "
+                    "https://docs.classiq.io/latest/qmod-reference/language-reference/classical-types/#hamiltonians)."
+                ),
+                ClassiqDeprecationWarning,
+                stacklevel=2,
+            )
+        super().__call__(*args, **kwargs)
+
 
 class GenerativeQFunc(BaseQFunc):
     FRAME_DEPTH = 3
@@ -261,7 +306,7 @@ class GenerativeQFunc(BaseQFunc):
 
     def __call__(self, *args: Any, **kwargs: Any) -> None:
         if get_global_declarative_switch():
-            return QFunc(self._py_callable)(*args, **kwargs)
+            return QFunc(self._py_callable, self.compilation_metadata)(*args, **kwargs)
         if self.func_decl.name not in self._qmodule.generative_functions:
             self._qmodule.generative_functions[self.func_decl.name] = self
             if self._func_decl is None:

classiq/qmod/semantics/annotation/qstruct_annotator.py

@@ -45,7 +45,7 @@ class QStructAnnotator(ModelVisitor):
             return
         self._visited.add(type_name)
         new_fields = {
-            field_name: field_type.model_copy()
+            field_name: field_type.model_copy(deep=True)
             for field_name, field_type in decl.variables.items()
         }
         self.visit(new_fields)

classiq/qmod/semantics/validation/main_validation.py

@@ -1,8 +1,5 @@
 from classiq.interface.exceptions import ClassiqExpansionError, ClassiqValueError
-from classiq.interface.generator.functions.classical_type import (
-    ClassicalArray,
-    ClassicalList,
-)
+from classiq.interface.generator.functions.classical_type import ClassicalArray
 from classiq.interface.generator.functions.concrete_types import ConcreteClassicalType
 from classiq.interface.generator.functions.port_declaration import (
     PortDeclarationDirection,
@@ -31,11 +28,6 @@ def _validate_main_param(param: PositionalArg) -> None:
 def _validate_main_classical_param_type(
     param: ConcreteClassicalType, param_name: str
 ) -> None:
-    if isinstance(param, ClassicalList):
-        raise ClassiqExpansionError(
-            f"Classical array parameter {param_name!r} of function 'main' must "
-            f"specify array length",
-        )
     if isinstance(param, ClassicalArray):
         if param.length is None:
             raise ClassiqExpansionError(

classiq/qmod/symbolic_type.py

@@ -1,5 +1,6 @@
-from typing import Union
+from typing import Union, get_args, get_origin
 
 from classiq.qmod.symbolic_expr import SymbolicExpr
 
 SymbolicTypes = Union[SymbolicExpr, int, float, bool, tuple["SymbolicTypes", ...]]
+SYMBOLIC_TYPES = tuple(get_origin(t) or t for t in get_args(SymbolicTypes))

classiq/qmod/utilities.py

@@ -31,8 +31,6 @@ from classiq.interface.source_reference import SourceReference
 if TYPE_CHECKING:
     from classiq.qmod.qmod_variable import QVar
 
-DEFAULT_DECIMAL_PRECISION = 4
-
 
 def mangle_keyword(name: str) -> str:
     if keyword.iskeyword(name):

classiq/qmod/write_qmod.py

@@ -2,12 +2,12 @@ import json
 from pathlib import Path
 from typing import Optional, Union
 
+from classiq.interface.constants import DEFAULT_DECIMAL_PRECISION
 from classiq.interface.model.model import Model, SerializedModel
 
 from classiq.qmod.global_declarative_switch import set_global_declarative_switch
 from classiq.qmod.native.pretty_printer import DSLPrettyPrinter
 from classiq.qmod.quantum_function import GenerativeQFunc, QFunc
-from classiq.qmod.utilities import DEFAULT_DECIMAL_PRECISION
 
 _QMOD_SUFFIX = "qmod"
 _SYNTHESIS_OPTIONS_SUFFIX = "synthesis_options.json"

{classiq-0.83.0.dist-info → classiq-0.85.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: classiq
-Version: 0.83.0
+Version: 0.85.0
 Summary: Classiq's Python SDK for quantum computing
 License: Proprietary
 Keywords: quantum computing,quantum circuits,quantum algorithms,QAD,QDL
@@ -27,6 +27,7 @@ Classifier: Topic :: Software Development :: Compilers
 Classifier: Topic :: Software Development :: Libraries :: Python Modules
 Classifier: Typing :: Typed
 Provides-Extra: analyzer-sdk
+Provides-Extra: chemistry
 Provides-Extra: qml
 Requires-Dist: ConfigArgParse (>=1.5.3,<2.0.0)
 Requires-Dist: Pyomo (>=6.5,<6.6)
@@ -41,6 +42,8 @@ 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"
+Requires-Dist: openfermion ; extra == "chemistry"
+Requires-Dist: openfermionpyscf ; extra == "chemistry"
 Requires-Dist: packaging (>=23.2,<24.0)
 Requires-Dist: pandas (>=1.4.0,<3.0.0)
 Requires-Dist: plotly (>=5.7.0,<6.0.0)