classiq 0.54.0__py3-none-any.whl → 0.56.0__py3-none-any.whl

classiq/qmod/builtins/operations.py

@@ -1,12 +1,16 @@
 import inspect
 import sys
+import warnings
 from collections.abc import Mapping
 from types import FrameType
 from typing import (
+    TYPE_CHECKING,
     Any,
     Callable,
     Final,
+    Optional,
     Union,
+    overload,
 )
 
 from classiq.interface.exceptions import ClassiqValueError
@@ -21,13 +25,16 @@ from classiq.interface.model.classical_parameter_declaration import (
     ClassicalParameterDeclaration,
 )
 from classiq.interface.model.control import Control
-from classiq.interface.model.inplace_binary_operation import (
-    BinaryOperation,
-    InplaceBinaryOperation,
-)
 from classiq.interface.model.invert import Invert
 from classiq.interface.model.phase_operation import PhaseOperation
 from classiq.interface.model.power import Power
+from classiq.interface.model.quantum_expressions.amplitude_loading_operation import (
+    AmplitudeLoadingOperation,
+)
+from classiq.interface.model.quantum_expressions.arithmetic_operation import (
+    ArithmeticOperation,
+    ArithmeticOperationKind,
+)
 from classiq.interface.model.quantum_function_call import QuantumFunctionCall
 from classiq.interface.model.quantum_function_declaration import (
     QuantumOperandDeclaration,
@@ -37,7 +44,7 @@ from classiq.interface.model.repeat import Repeat
 from classiq.interface.model.statement_block import StatementBlock
 from classiq.interface.model.within_apply_operation import WithinApply
 
-from classiq.qmod.qmod_variable import Input, Output, QArray, QBit, QNum, QVar
+from classiq.qmod.qmod_variable import Input, Output, QArray, QBit, QNum, QScalar, QVar
 from classiq.qmod.quantum_callable import QCallable
 from classiq.qmod.quantum_expandable import prepare_arg
 from classiq.qmod.symbolic_expr import SymbolicExpr
@@ -91,6 +98,7 @@ def if_(
 def control(
     ctrl: Union[SymbolicExpr, QBit, QArray[QBit]],
     stmt_block: Union[QCallable, Callable[[], None]],
+    else_block: Union[QCallable, Callable[[], None], None] = None,
 ) -> None:
     _validate_operand(stmt_block)
     assert QCallable.CURRENT_EXPANDABLE is not None
@@ -98,39 +106,164 @@ def control(
     control_stmt = Control(
         expression=Expression(expr=str(ctrl)),
         body=_operand_to_body(stmt_block, "stmt_block"),
+        else_block=_operand_to_body(else_block, "else_block") if else_block else None,
         source_ref=source_ref,
     )
     control_stmt.set_generative_block("body", stmt_block)
+    if else_block is not None:
+        control_stmt.set_generative_block("else_block", else_block)
     QCallable.CURRENT_EXPANDABLE.append_statement_to_body(control_stmt)
 
 
+def assign(expression: SymbolicExpr, target_var: QScalar) -> None:
+    """
+    Initialize a scalar quantum variable using an arithmetic expression.
+    If specified, the variable numeric properties (size, signedness, and fraction
+    digits) must match the expression properties.
+
+    Equivalent to `<target_var> |= <expression>`.
+
+    Args:
+        expression: A classical or quantum arithmetic expression
+        target_var: An uninitialized scalar quantum variable
+    """
+    assert QCallable.CURRENT_EXPANDABLE is not None
+    source_ref = get_source_ref(sys._getframe(1))
+    QCallable.CURRENT_EXPANDABLE.append_statement_to_body(
+        ArithmeticOperation(
+            expression=Expression(expr=str(expression)),
+            result_var=target_var.get_handle_binding(),
+            operation_kind=ArithmeticOperationKind.Assignment,
+            source_ref=source_ref,
+        )
+    )
+
+
+def assign_amplitude(expression: SymbolicExpr, target_var: QScalar) -> None:
+    """
+    Perform an amplitude-encoding assignment operation on a quantum variable and a
+    quantum expression.
+
+    Equivalent to `<target_var> *= <expression>`.
+
+    Args:
+        expression: A quantum arithmetic expression
+        target_var: A scalar quantum variable
+    """
+    assert QCallable.CURRENT_EXPANDABLE is not None
+    source_ref = get_source_ref(sys._getframe(1))
+    QCallable.CURRENT_EXPANDABLE.append_statement_to_body(
+        AmplitudeLoadingOperation(
+            expression=Expression(expr=str(expression)),
+            result_var=target_var.get_handle_binding(),
+            source_ref=source_ref,
+        )
+    )
+
+
+@overload
+def inplace_add(expression: SymbolicExpr, target_var: QScalar) -> None:
+    pass
+
+
+@overload
+def inplace_add(*, value: QNum, target: QNum) -> None:
+    pass
+
+
 def inplace_add(
-    value: QNum,
-    target: QNum,
+    expression: Optional[SymbolicExpr] = None,
+    target_var: Optional[QScalar] = None,
+    value: Optional[QNum] = None,
+    target: Optional[QNum] = None,
 ) -> None:
+    """
+    Add an arithmetic expression to a quantum variable.
+
+    Equivalent to `<target_var> += <expression>`.
+
+    Args:
+        expression: A classical or quantum arithmetic expression
+        target_var: A scalar quantum variable
+    """
     assert QCallable.CURRENT_EXPANDABLE is not None
+    if value is not None or target is not None:
+        warnings.warn(
+            "Parameters 'value' and 'target of function 'inplace_add' have "
+            "been renamed to 'expression' and 'target_var' respectively. Parameters "
+            "'value' and 'target' will no longer be supported starting on 02/12/24 at "
+            "the earliest.\nHint: Change `inplace_add(value=..., target=...)` to "
+            "`inplace_add(expression=..., target_var=...)` or `inplace_add(..., ...)`.",
+            category=DeprecationWarning,
+            stacklevel=2,
+        )
+    if value is not None:
+        expression = value
+    if target is not None:
+        target_var = target
+    if TYPE_CHECKING:
+        assert expression is not None
+        assert target_var is not None
     source_ref = get_source_ref(sys._getframe(1))
     QCallable.CURRENT_EXPANDABLE.append_statement_to_body(
-        InplaceBinaryOperation(
-            target=target.get_handle_binding(),
-            value=value.get_handle_binding(),
-            operation=BinaryOperation.Addition,
+        ArithmeticOperation(
+            expression=Expression(expr=str(expression)),
+            result_var=target_var.get_handle_binding(),
+            operation_kind=ArithmeticOperationKind.InplaceAdd,
             source_ref=source_ref,
         )
     )
 
 
+@overload
+def inplace_xor(expression: SymbolicExpr, target_var: QScalar) -> None:
+    pass
+
+
+@overload
+def inplace_xor(*, value: QNum, target: QNum) -> None:
+    pass
+
+
 def inplace_xor(
-    value: QNum,
-    target: QNum,
+    expression: Optional[SymbolicExpr] = None,
+    target_var: Optional[QScalar] = None,
+    value: Optional[QNum] = None,
+    target: Optional[QNum] = None,
 ) -> None:
+    """
+    Bitwise-XOR a quantum variable with an arithmetic expression.
+
+    Equivalent to `<target_var> ^= <expression>`.
+
+    Args:
+        expression: A classical or quantum arithmetic expression
+        target_var: A scalar quantum variable
+    """
     assert QCallable.CURRENT_EXPANDABLE is not None
+    if value is not None or target is not None:
+        warnings.warn(
+            "Parameters 'value' and 'target of function 'inplace_xor' have "
+            "been renamed to 'expression' and 'target_var' respectively. Parameters "
+            "'value' and 'target' will no longer be supported starting on 02/12/24 at "
+            "the earliest.\nHint: Change `inplace_xor(value=..., target=...)` to "
+            "`inplace_xor(expression=..., target_var=...)` or `inplace_xor(..., ...)`.",
+            category=DeprecationWarning,
+            stacklevel=2,
+        )
+    if value is not None:
+        expression = value
+    if target is not None:
+        target_var = target
+    if TYPE_CHECKING:
+        assert expression is not None
+        assert target_var is not None
     source_ref = get_source_ref(sys._getframe(1))
     QCallable.CURRENT_EXPANDABLE.append_statement_to_body(
-        InplaceBinaryOperation(
-            target=target.get_handle_binding(),
-            value=value.get_handle_binding(),
-            operation=BinaryOperation.Xor,
+        ArithmeticOperation(
+            expression=Expression(expr=str(expression)),
+            result_var=target_var.get_handle_binding(),
+            operation_kind=ArithmeticOperationKind.InplaceXor,
             source_ref=source_ref,
         )
     )
@@ -297,6 +430,8 @@ def _operand_to_body(
 
 
 __all__ = [
+    "assign",
+    "assign_amplitude",
     "bind",
     "control",
     "invert",

classiq/qmod/create_model_function.py

@@ -60,6 +60,7 @@ def create_model(
     user_gen_functions = {
         gen_func._py_callable.__name__ for gen_func in GEN_QFUNCS
     } - set(BUILTIN_FUNCTION_DECLARATIONS.keys())
+
     if len(user_gen_functions) > 0 and is_generative_expansion_enabled():
         model = _expand_generative_model(
             (
@@ -100,11 +101,17 @@ def _expand_generative_model(
     def _dummy() -> None:
         pass
 
+    functions_compilation_metadata = {
+        dec_func._py_callable.__name__: dec_func.compilation_metadata
+        for dec_func in DEC_QFUNCS
+        if dec_func.compilation_metadata is not None
+    }
     model = _dummy.create_model(
         constraints,
         execution_preferences,
         preferences,
         classical_execution_function,
+        functions_compilation_metadata,
     )
     generative_functions = _get_generative_functions(gen_main, preferences)
     model.functions = generative_functions
@@ -157,7 +164,8 @@ def _get_wrapper_main(gen_main: QFunc, preferences: Optional[Preferences]) -> Mo
 def _get_all_model_functions_as_generative_functions() -> list[GenerativeQFunc]:
 
     gen_functions = list(GEN_QFUNCS) + [
-        _get_gen_from_dec(dec_func) for dec_func in DEC_QFUNCS
+        GenerativeQFunc(dec_func._py_callable, dec_func.func_decl)
+        for dec_func in DEC_QFUNCS
     ]
     return [
         (
@@ -173,16 +181,6 @@ def _get_all_model_functions_as_generative_functions() -> list[GenerativeQFunc]:
     ]
 
 
-def _get_gen_from_dec(dec_func: QFunc) -> GenerativeQFunc:
-    synthesis_data = dec_func.synthesis_data
-    if synthesis_data is not None and synthesis_data.should_synthesize_separately:
-        raise ClassiqError(
-            """The model contains generative functions,
-            which cannot coexist with functions marked for separate synthesis"""
-        )
-    return GenerativeQFunc(dec_func._py_callable, dec_func.func_decl)
-
-
 def _interpret_generative_model(
     gen_model: Model, gen_functions: list[GenerativeQFunc]
 ) -> dict[str, NativeFunctionDefinition]:
@@ -192,7 +190,7 @@ def _interpret_generative_model(
     )
     interpreter = Interpreter(gen_model, gen_functions, is_frontend=True)
     set_frontend_interpreter(interpreter)
-    expand_model, _ = interpreter.expand()
+    expand_model = interpreter.expand()
     functions_dict = nameables_to_dict(expand_model.functions)
 
     # Inline _gen_main call in main

classiq/qmod/model_state_container.py

@@ -1,8 +1,11 @@
 from classiq.interface.generator.constant import Constant
+from classiq.interface.generator.types.compilation_metadata import CompilationMetadata
 from classiq.interface.generator.types.enum_declaration import EnumDeclaration
 from classiq.interface.generator.types.qstruct_declaration import QStructDeclaration
 from classiq.interface.generator.types.struct_declaration import StructDeclaration
-from classiq.interface.model.native_function_definition import NativeFunctionDefinition
+from classiq.interface.model.native_function_definition import (
+    NativeFunctionDefinition,
+)
 
 
 class ModelStateContainer:
@@ -11,6 +14,7 @@ class ModelStateContainer:
     qstruct_decls: dict[str, QStructDeclaration]
     native_defs: dict[str, NativeFunctionDefinition]
     constants: dict[str, Constant]
+    functions_compilation_metadata: dict[str, CompilationMetadata]
 
 
 QMODULE = ModelStateContainer()

classiq/qmod/native/pretty_printer.py

@@ -253,7 +253,12 @@ class DSLPrettyPrinter(Visitor):
     def visit_Control(self, op: Control) -> str:
         control = f"{self._indent}control ({self.visit(op.expression)}) {{\n"
         control += self._visit_body(op.body)
-        control += f"{self._indent}}}\n"
+        control += f"{self._indent}}}"
+        if op.else_block is not None:
+            control += " else {\n"
+            control += self._visit_body(op.else_block)
+            control += f"{self._indent}}}"
+        control += "\n"
         return control
 
     def visit_PhaseOperation(self, op: PhaseOperation) -> str:

classiq/qmod/pretty_print/pretty_printer.py

@@ -50,9 +50,6 @@ from classiq.interface.model.quantum_expressions.arithmetic_operation import (
     ArithmeticOperation,
     ArithmeticOperationKind,
 )
-from classiq.interface.model.quantum_expressions.quantum_expression import (
-    QuantumAssignmentOperation,
-)
 from classiq.interface.model.quantum_function_call import (
     OperandIdentifier,
     QuantumFunctionCall,
@@ -391,7 +388,10 @@ class PythonPrettyPrinter(Visitor):
 
     def visit_Control(self, op: Control) -> str:
         self._imports["control"] = 1
-        return f"{self._indent}control({self.visit(op.expression)}, {self._visit_body(op.body)})\n"
+        control_else = (
+            f", {self._visit_body(op.else_block)}" if op.else_block is not None else ""
+        )
+        return f"{self._indent}control({self.visit(op.expression)}, {self._visit_body(op.body)}{control_else})\n"
 
     def visit_PhaseOperation(self, op: PhaseOperation) -> str:
         self._imports["phase"] = 1
@@ -429,13 +429,16 @@ class PythonPrettyPrinter(Visitor):
         code = f"lambda{argument_string}: {'[' if len(body) > 1 else ''}\n"
         self._level += 1
         for i, statement in enumerate(body):
-            if isinstance(
-                statement, (QuantumAssignmentOperation, VariableDeclarationStatement)
-            ):
+            if isinstance(statement, VariableDeclarationStatement):
                 raise AssertionError(
-                    "pretty printing quantum assignment operations or variable declaration statements in quantum lambda function is unsupported."
+                    "pretty printing variable declaration statements in quantum lambda function is unsupported."
                 )
-            code += self.visit(statement)
+            if isinstance(statement, AmplitudeLoadingOperation):
+                code += self.visit_AmplitudeLoadingOperation(statement, in_lambda=True)
+            elif isinstance(statement, ArithmeticOperation):
+                code += self.visit_ArithmeticOperation(statement, in_lambda=True)
+            else:
+                code += self.visit(statement)
             if i < len(body) - 1:
                 code += ","
         self._level -= 1
@@ -469,18 +472,29 @@ class PythonPrettyPrinter(Visitor):
     def visit_FieldHandleBinding(self, var_ref: FieldHandleBinding) -> str:
         return f"{self.visit(var_ref.base_handle)}.{self.visit(var_ref.field)}"
 
-    def visit_ArithmeticOperation(self, arith_op: ArithmeticOperation) -> str:
+    def visit_ArithmeticOperation(
+        self, arith_op: ArithmeticOperation, in_lambda: bool = False
+    ) -> str:
         if arith_op.operation_kind == ArithmeticOperationKind.Assignment:
             op = "|="
+            func = "assign"
         elif arith_op.operation_kind == ArithmeticOperationKind.InplaceXor:
             op = "^="
+            func = "inplace_xor"
         else:
             op = "+="
+            func = "inplace_add"
+        if in_lambda:
+            self._imports[func] = 1
+            return f"{func}({self.visit(arith_op.expression)}, {self._indent}{self.visit(arith_op.result_var)})\n"
         return f"{self._indent}{self.visit(arith_op.result_var)} {op} {self.visit(arith_op.expression)}\n"
 
     def visit_AmplitudeLoadingOperation(
-        self, amplitude_loading_op: AmplitudeLoadingOperation
+        self, amplitude_loading_op: AmplitudeLoadingOperation, in_lambda: bool = False
     ) -> str:
+        if in_lambda:
+            self._imports["assign_amplitude"] = 1
+            return f"assign_amplitude({self.visit(amplitude_loading_op.expression)}, {self._indent}{self.visit(amplitude_loading_op.result_var)})\n"
         return f"{self._indent}{self.visit(amplitude_loading_op.result_var)} *= {self.visit(amplitude_loading_op.expression)}\n"
 
     def _print_bind_handles(self, handles: list[HandleBinding]) -> str:

classiq/qmod/qmod_constant.py

@@ -1,8 +1,8 @@
 import inspect
 from dataclasses import is_dataclass
-from typing import Any, Optional
+from typing import Any, Optional, cast, get_origin
 
-from classiq.interface.exceptions import ClassiqError
+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 (
@@ -10,7 +10,13 @@ from classiq.interface.generator.functions.classical_type import (
     ClassicalList,
 )
 
+from classiq.qmod.cparam import CArray, CParamScalar
 from classiq.qmod.declaration_inferrer import python_type_to_qmod
+from classiq.qmod.generative import (
+    get_frontend_interpreter,
+    interpret_expression,
+    is_generative_mode,
+)
 from classiq.qmod.model_state_container import ModelStateContainer
 from classiq.qmod.qmod_parameter import CParam, CParamList, CParamStruct
 from classiq.qmod.symbolic_expr import SymbolicExpr
@@ -49,7 +55,10 @@ class QConstant(SymbolicExpr):
         ):
             raise ClassiqError(f"Constant {self.name} is already defined in the model")
 
-        QConstant.CURRENT_QMODULE.constants[self.name] = self._get_constant_node()
+        constant = self._get_constant_node()
+        QConstant.CURRENT_QMODULE.constants[self.name] = constant
+        if is_generative_mode():
+            get_frontend_interpreter().add_constant(constant)
 
     def _get_constant_node(self) -> Constant:
         if isinstance(self._value, QConstant):
@@ -113,3 +122,22 @@ class QConstant(SymbolicExpr):
             qmod_type,
             QConstant.CURRENT_QMODULE,
         )[item]
+
+    def __len__(self) -> int:
+        raise ClassiqValueError(
+            "len(<const>) is not supported for classical constants - use <const>.len "
+            "instead"
+        )
+
+    @property
+    def len(self) -> int:
+        self.add_to_model()
+        if get_origin(self._py_type) != CArray:
+            raise ClassiqValueError(
+                f"Constant {self.name!r} of type {self._py_type.__name__!r} does not "
+                f"have a 'len' property"
+            )
+        len_expr = f"get_field({self.name}, 'len')"
+        if is_generative_mode():
+            return interpret_expression(len_expr)
+        return cast(int, CParamScalar(len_expr))

classiq/qmod/quantum_function.py

@@ -9,9 +9,9 @@ from classiq.interface.exceptions import ClassiqError
 from classiq.interface.executor.execution_preferences import ExecutionPreferences
 from classiq.interface.generator.model.constraints import Constraints
 from classiq.interface.generator.model.preferences.preferences import Preferences
+from classiq.interface.generator.types.compilation_metadata import CompilationMetadata
 from classiq.interface.model.model import Model
 from classiq.interface.model.native_function_definition import (
-    FunctionSynthesisData,
     NativeFunctionDefinition,
 )
 from classiq.interface.model.quantum_function_declaration import (
@@ -35,7 +35,7 @@ class QFunc(QExpandable):
         _validate_no_gen_params(py_callable.__annotations__)
         super().__init__(py_callable)
         functools.update_wrapper(self, py_callable)
-        self._synthesis_data: Optional[FunctionSynthesisData] = None
+        self.compilation_metadata: Optional[CompilationMetadata] = None
 
     @property
     def func_decl(self) -> NamedParamsQuantumFunctionDeclaration:
@@ -45,12 +45,19 @@ class QFunc(QExpandable):
         )
 
     @property
-    def synthesis_data(self) -> Optional[FunctionSynthesisData]:
-        return self._synthesis_data
-
-    @synthesis_data.setter
-    def synthesis_data(self, value: FunctionSynthesisData) -> None:
-        self._synthesis_data = value
+    def should_synthesize_separately(self) -> bool:
+        if self.compilation_metadata is None:
+            return False
+        return self.compilation_metadata.should_synthesize_separately
+
+    @should_synthesize_separately.setter
+    def should_synthesize_separately(self, value: bool) -> None:
+        if self.compilation_metadata is None:
+            self.compilation_metadata = CompilationMetadata(
+                should_synthesize_separately=value
+            )
+        else:
+            self.compilation_metadata.should_synthesize_separately = value
 
     def __call__(self, *args: Any, **kwargs: Any) -> None:
         super().__call__(*args, **kwargs)
@@ -62,12 +69,16 @@ class QFunc(QExpandable):
         execution_preferences: Optional[ExecutionPreferences] = None,
         preferences: Optional[Preferences] = None,
         classical_execution_function: Optional[CFunc] = None,
+        functions_compilation_metadata: Optional[dict[str, CompilationMetadata]] = None,
     ) -> Model:
+        if functions_compilation_metadata is None:
+            functions_compilation_metadata = dict()
         self._qmodule.enum_decls = dict()
         self._qmodule.type_decls = dict()
         self._qmodule.qstruct_decls = dict()
         self._qmodule.native_defs = dict()
         self._qmodule.constants = dict()
+        self._qmodule.functions_compilation_metadata = functions_compilation_metadata
         QConstant.set_current_model(self._qmodule)
         self.expand()
         model_extra_settings: list[tuple[str, Any]] = [
@@ -86,6 +97,7 @@ class QFunc(QExpandable):
             enums=list(self._qmodule.enum_decls.values()),
             types=list(self._qmodule.type_decls.values()),
             qstructs=list(self._qmodule.qstruct_decls.values()),
+            functions_compilation_metadata=self._qmodule.functions_compilation_metadata,
             **{key: value for key, value in model_extra_settings if value},
         )
 
@@ -94,18 +106,12 @@ class QFunc(QExpandable):
             return
         super().expand()
         self._qmodule.native_defs[self.func_decl.name] = NativeFunctionDefinition(
-            **{
-                **self.func_decl.model_dump(),
-                **{
-                    "body": self.body,
-                    "synthesis_data": (
-                        self.synthesis_data
-                        if self.synthesis_data is not None
-                        else FunctionSynthesisData()
-                    ),
-                },
-            },
+            **{**self.func_decl.model_dump(), **{"body": self.body}}
         )
+        if self.compilation_metadata is not None:
+            self._qmodule.functions_compilation_metadata[self.func_decl.name] = (
+                self.compilation_metadata
+            )
 
     def _add_constants_from_classical_code(
         self, classical_execution_function: CFunc

classiq/qmod/synthesize_separately.py

@@ -1,14 +1,13 @@
 from typing import Union
 
 from classiq.interface.exceptions import ClassiqError
-from classiq.interface.model.native_function_definition import FunctionSynthesisData
 
 from classiq.qmod.quantum_function import ExternalQFunc, GenerativeQFunc, QFunc
 
 
 def synthesize_separately(qfunc: Union[QFunc, GenerativeQFunc, ExternalQFunc]) -> QFunc:
     if isinstance(qfunc, QFunc):
-        qfunc.synthesis_data = FunctionSynthesisData(should_synthesize_separately=True)
+        qfunc.should_synthesize_separately = True
         return qfunc
     if isinstance(qfunc, GenerativeQFunc):
         raise ClassiqError("Generative functions can not be synthesized separately")

{classiq-0.54.0.dist-info → classiq-0.56.0.dist-info}/METADATA

@@ -1,13 +1,13 @@
 Metadata-Version: 2.1
 Name: classiq
-Version: 0.54.0
+Version: 0.56.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.8,<3.13
+Requires-Python: >=3.9,<3.13
 Classifier: Development Status :: 4 - Beta
 Classifier: Intended Audience :: Developers
 Classifier: Intended Audience :: Education
@@ -16,7 +16,6 @@ Classifier: License :: Other/Proprietary License
 Classifier: Natural Language :: English
 Classifier: Operating System :: OS Independent
 Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.8
 Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11