🎨 Rename Python classes to not violate N801 (#523)

## Description

This PR renames all Python classes to not violate
[N801](https://docs.astral.sh/ruff/rules/invalid-class-name/).

## Checklist:

- [x] The pull request only contains commits that are focused and
relevant to this change.
- [x] ~I have added appropriate tests that cover the new/changed
functionality.~
- [x] ~I have updated the documentation to reflect these changes.~
- [x] The changes follow the project's style guidelines and introduce no
new warnings.
- [x] The changes are fully tested and pass the CI checks.
- [x] I have reviewed my own code changes.

Author: denialhaag

bindings/bindings.cpp

@@ -184,27 +184,27 @@ NB_MODULE(MQT_SYREC_MODULE_NAME, m) {
 
     m.doc() = "Python interface for the SyReC programming language for the synthesis of reversible circuits";
 
-    nb::class_<QubitInliningStack::QubitInliningStackEntry>(m, "qubit_inlining_stack_entry")
+    nb::class_<QubitInliningStack::QubitInliningStackEntry>(m, "QubitInliningStackEntry")
             .def(nb::init<>(), "Constructs an empty qubit inlining stack entry")
             .def_prop_ro("line_number_of_call_of_target_module", [](const QubitInliningStack::QubitInliningStackEntry& stackEntry) { return stackEntry.lineNumberOfCallOfTargetModule; }, "Returns the line number in the source file in which the call statement variant was defined")
             .def_prop_ro("is_target_module_accessed_via_call_stmt", [](const QubitInliningStack::QubitInliningStackEntry& stackEntry) { return stackEntry.isTargetModuleAccessedViaCallStmt; }, "Returns whether the target module was called using a CallStatement")
             .def_prop_ro("stringified_signature_of_called_module", &QubitInliningStack::QubitInliningStackEntry::stringifySignatureOfCalledModule, "Returns the stringified target module signature");
 
-    nb::class_<QubitInliningStack>(m, "qubit_inlining_stack")
+    nb::class_<QubitInliningStack>(m, "QubitInliningStack")
             .def(nb::init<>(), "Constructs an empty qubit inlining stack")
             .def("size", &QubitInliningStack::size, "Get the number of stack entries")
             .def("__getitem__", &QubitInliningStack::getStackEntryAt, "idx"_a, nb::rv_policy::reference_internal);
 
-    nb::class_<AnnotatableQuantumComputation::InlinedQubitInformation>(m, "inlined_qubit_information")
+    nb::class_<AnnotatableQuantumComputation::InlinedQubitInformation>(m, "InlinedQubitInformation")
             .def(nb::init<>(), "Constructs an empty inlined qubit information container")
             .def_prop_ro("user_declared_qubit_label", [](const AnnotatableQuantumComputation::InlinedQubitInformation& inlinedQubitInfo) { return inlinedQubitInfo.userDeclaredQubitLabel; }, "Get the label of the qubit as defined by the user in the SyReC program")
             .def_prop_ro("inline_stack", [](const AnnotatableQuantumComputation::InlinedQubitInformation& inlinedQubitInfo) { return inlinedQubitInfo.inlineStack; }, "Get the inline stack associated with the qubit");
 
-    nb::enum_<AnnotatableQuantumComputation::QubitLabelType>(m, "qubit_label_type")
+    nb::enum_<AnnotatableQuantumComputation::QubitLabelType>(m, "QubitLabelType")
             .value("internal", AnnotatableQuantumComputation::QubitLabelType::Internal, "Generate the qubit label using the internal qubit identifier (only available for ancillary qubits and local SyReC module variables)")
             .value("user_declared", AnnotatableQuantumComputation::QubitLabelType::UserDeclared, "Generate the qubit label using the user declared variable identifier (only available for the qubits of the variables of a SyReC program [ancillary qubits are not associated with a variable and thus have no user declared label])");
 
-    nb::class_<AnnotatableQuantumComputation, qc::QuantumComputation>(m, "annotatable_quantum_computation")
+    nb::class_<AnnotatableQuantumComputation, qc::QuantumComputation>(m, "AnnotatableQuantumComputation")
             .def(nb::init<>(), "Constructs an annotatable quantum computation")
             .def(nb::init<bool>(), "generate_quantum_operation_annotations"_a, "Constructs an annotatable quantum computation while also specifying whether quantum operation annotations can be generated")
             .def("get_qubit_label", &AnnotatableQuantumComputation::getQubitLabel, "qubit"_a, "qubit_label_type"_a, "Get either the internal or user-declared label of a qubit as a stringified SyReC variable access based on its location in the quantum register storing the qubit and, optionally, the layout of the SyReC variable stored in the register.")
@@ -213,7 +213,7 @@ NB_MODULE(MQT_SYREC_MODULE_NAME, m) {
             .def("get_annotations_of_quantum_operation", &AnnotatableQuantumComputation::getAnnotationsOfQuantumOperation, "quantum_operation_index_in_quantum_operation"_a, "Get the annotations of a specific quantum operation in the quantum computation")
             .def("get_inlined_qubit_information", &AnnotatableQuantumComputation::getInlinedQubitInformation, "qubit"_a, "Get the inlined information of a qubit");
 
-    nb::class_<NBitValuesContainer>(m, "n_bit_values_container")
+    nb::class_<NBitValuesContainer>(m, "NBitValuesContainer")
             .def(nb::init<>(), "Constructs an empty container of size zero.")
             .def(nb::init<std::size_t>(), "n"_a, "Constructs a zero-initialized container of size n.")
             .def(nb::init<std::size_t, uint64_t>(), "n"_a, "initial_line_values"_a, "Constructs a container of size n from an integer initial_line_values")
@@ -227,15 +227,15 @@ NB_MODULE(MQT_SYREC_MODULE_NAME, m) {
             .def("flip", &NBitValuesContainer::flip, "n"_a, "Flip the value of the bit at position n")
             .def("__str__", [](const NBitValuesContainer& container) { return container.stringify(); }, "Returns a string containing the stringified values of the stored bits.");
 
-    nb::class_<Statistics>(m, "statistics")
+    nb::class_<Statistics>(m, "Statistics")
             .def(nb::init<>(), "Constructs an object to record collected statistics.")
             .def_rw("runtime_in_milliseconds", &Statistics::runtimeInMilliseconds, "The recorded runtime in milliseconds");
 
-    nb::enum_<utils::IntegerConstantTruncationOperation>(m, "integer_constant_truncation_operation")
+    nb::enum_<utils::IntegerConstantTruncationOperation>(m, "IntegerConstantTruncationOperation")
             .value("modulo", utils::IntegerConstantTruncationOperation::Modulo, "Use the modulo operation for the truncation of constant values")
             .value("bitwise_and", utils::IntegerConstantTruncationOperation::BitwiseAnd, "Use the bitwise AND operation for the truncation of constant values");
 
-    nb::class_<ConfigurableOptions>(m, "configurable_options")
+    nb::class_<ConfigurableOptions>(m, "ConfigurableOptions")
             .def(nb::init<>(), "Constructs a configurable options object.")
             .def_rw("default_bitwidth", &ConfigurableOptions::defaultBitwidth, "Defines the default variable bitwidth used by the SyReC parser for variables whose bitwidth specification was omitted")
             .def_rw("integer_constant_truncation_operation", &ConfigurableOptions::integerConstantTruncationOperation, "Defines the operation used by the SyReC parser for the truncation of integer constant values. For further details we refer to the semantics of the SyReC language")
@@ -244,7 +244,7 @@ NB_MODULE(MQT_SYREC_MODULE_NAME, m) {
             .def_rw("generate_inlined_qubit_debug_information", &ConfigurableOptions::generatedInlinedQubitDebugInformation, "Should debug information for the qubits associated with the local variables of a SyReC module be generated")
             .def_rw("generate_quantum_operation_annotations", &ConfigurableOptions::generateQuantumOperationAnnotations, "Should the optional quantum operation annotations be generated during the synthesis of a SyReC program, disabled by default");
 
-    nb::class_<Program>(m, "program")
+    nb::class_<Program>(m, "Program")
             .def(nb::init<>(), "Constructs SyReC program object.")
             .def("read", &Program::read, "filename"_a, "configurable_options"_a = ConfigurableOptions(), "Read and process a SyReC program from a file.")
             .def("read_from_string", &Program::readFromString, "stringified_program"_a, "configurable_options"_a = ConfigurableOptions(), "Process an already stringified SyReC program.");

pyproject.toml

@@ -1,6 +1,6 @@
 [build-system]
 requires = [
-    "nanobind>=2.10.2",
+    "nanobind==2.10.2",
     "scikit-build-core>=0.11.6",
     "setuptools-scm>=9.2.2",
     "mqt.core~=3.4.0",
@@ -229,7 +229,7 @@ known-first-party = ["mqt.syrec"]
 "docs/**" = ["T20"]
 "python/mqt/syrec/syrec_editor.py" = ["T20"]
 "noxfile.py" = ["T20", "TID251"]
-"*.pyi" = ["D418", "E501", "N801", "PYI021"]
+"*.pyi" = ["D418", "E501", "PYI021"]
 "*.ipynb" = [
     "D",    # pydocstyle
     "E402", # Allow imports to appear anywhere in Jupyter notebooks
@@ -326,7 +326,7 @@ mqt-syrec = { workspace = true }
 
 [dependency-groups]
 build = [
-    "nanobind>=2.10.2",
+    "nanobind==2.10.2",
     "scikit-build-core>=0.11.6",
     "setuptools-scm>=9.2.2",
     "mqt.core~=3.4.0",

python/mqt/syrec/__init__.py

@@ -33,34 +33,34 @@ def _dll_patch() -> None:
 
 from ._version import version as __version__
 from .pysyrec import (
-    annotatable_quantum_computation,
-    configurable_options,
+    AnnotatableQuantumComputation,
+    ConfigurableOptions,
+    InlinedQubitInformation,
+    IntegerConstantTruncationOperation,
+    NBitValuesContainer,
+    Program,
+    QubitInliningStack,
+    QubitInliningStackEntry,
+    QubitLabelType,
+    Statistics,
     cost_aware_synthesis,
-    inlined_qubit_information,
-    integer_constant_truncation_operation,
     line_aware_synthesis,
-    n_bit_values_container,
-    program,
-    qubit_inlining_stack,
-    qubit_inlining_stack_entry,
-    qubit_label_type,
     simple_simulation,
-    statistics,
 )
 
 __all__ = [
+    "AnnotatableQuantumComputation",
+    "ConfigurableOptions",
+    "InlinedQubitInformation",
+    "IntegerConstantTruncationOperation",
+    "NBitValuesContainer",
+    "Program",
+    "QubitInliningStack",
+    "QubitInliningStackEntry",
+    "QubitLabelType",
+    "Statistics",
     "__version__",
-    "annotatable_quantum_computation",
-    "configurable_options",
     "cost_aware_synthesis",
-    "inlined_qubit_information",
-    "integer_constant_truncation_operation",
     "line_aware_synthesis",
-    "n_bit_values_container",
-    "program",
-    "qubit_inlining_stack",
-    "qubit_inlining_stack_entry",
-    "qubit_label_type",
     "simple_simulation",
-    "statistics",
 ]

python/mqt/syrec/pysyrec.pyi

@@ -11,7 +11,7 @@ from typing import overload
 
 import mqt.core.ir
 
-class qubit_inlining_stack_entry:
+class QubitInliningStackEntry:
     def __init__(self) -> None:
         """Constructs an empty qubit inlining stack entry"""
 
@@ -29,16 +29,16 @@ class qubit_inlining_stack_entry:
     def stringified_signature_of_called_module(self) -> str | None:
         """Returns the stringified target module signature"""
 
-class qubit_inlining_stack:
+class QubitInliningStack:
     def __init__(self) -> None:
         """Constructs an empty qubit inlining stack"""
 
     def size(self) -> int:
         """Get the number of stack entries"""
 
-    def __getitem__(self, idx: int) -> qubit_inlining_stack_entry: ...
+    def __getitem__(self, idx: int) -> QubitInliningStackEntry: ...
 
-class inlined_qubit_information:
+class InlinedQubitInformation:
     def __init__(self) -> None:
         """Constructs an empty inlined qubit information container"""
 
@@ -47,10 +47,10 @@ class inlined_qubit_information:
         """Get the label of the qubit as defined by the user in the SyReC program"""
 
     @property
-    def inline_stack(self) -> qubit_inlining_stack | None:
+    def inline_stack(self) -> QubitInliningStack | None:
         """Get the inline stack associated with the qubit"""
 
-class qubit_label_type(enum.Enum):
+class QubitLabelType(enum.Enum):
     internal = 0
     """
     Generate the qubit label using the internal qubit identifier (only available for ancillary qubits and local SyReC module variables)
@@ -61,7 +61,7 @@ class qubit_label_type(enum.Enum):
     Generate the qubit label using the user declared variable identifier (only available for the qubits of the variables of a SyReC program [ancillary qubits are not associated with a variable and thus have no user declared label])
     """
 
-class annotatable_quantum_computation(mqt.core.ir.QuantumComputation):
+class AnnotatableQuantumComputation(mqt.core.ir.QuantumComputation):
     @overload
     def __init__(self) -> None:
         """Constructs an annotatable quantum computation"""
@@ -72,7 +72,7 @@ class annotatable_quantum_computation(mqt.core.ir.QuantumComputation):
         Constructs an annotatable quantum computation while also specifying whether quantum operation annotations can be generated
         """
 
-    def get_qubit_label(self, qubit: int, qubit_label_type: qubit_label_type) -> str | None:
+    def get_qubit_label(self, qubit: int, qubit_label_type: QubitLabelType) -> str | None:
         """
         Get either the internal or user-declared label of a qubit as a stringified SyReC variable access based on its location in the quantum register storing the qubit and, optionally, the layout of the SyReC variable stored in the register.
         """
@@ -88,10 +88,10 @@ class annotatable_quantum_computation(mqt.core.ir.QuantumComputation):
         Get the annotations of a specific quantum operation in the quantum computation
         """
 
-    def get_inlined_qubit_information(self, qubit: int) -> inlined_qubit_information | None:
+    def get_inlined_qubit_information(self, qubit: int) -> InlinedQubitInformation | None:
         """Get the inlined information of a qubit"""
 
-class n_bit_values_container:
+class NBitValuesContainer:
     @overload
     def __init__(self) -> None:
         """Constructs an empty container of size zero."""
@@ -128,7 +128,7 @@ class n_bit_values_container:
     def flip(self, n: int) -> bool:
         """Flip the value of the bit at position n"""
 
-class statistics:
+class Statistics:
     def __init__(self) -> None:
         """Constructs an object to record collected statistics."""
 
@@ -139,14 +139,14 @@ class statistics:
     @runtime_in_milliseconds.setter
     def runtime_in_milliseconds(self, arg: float, /) -> None: ...
 
-class integer_constant_truncation_operation(enum.Enum):
+class IntegerConstantTruncationOperation(enum.Enum):
     modulo = 0
     """Use the modulo operation for the truncation of constant values"""
 
     bitwise_and = 1
     """Use the bitwise AND operation for the truncation of constant values"""
 
-class configurable_options:
+class ConfigurableOptions:
     def __init__(self) -> None:
         """Constructs a configurable options object."""
 
@@ -159,13 +159,13 @@ class configurable_options:
     @default_bitwidth.setter
     def default_bitwidth(self, arg: int, /) -> None: ...
     @property
-    def integer_constant_truncation_operation(self) -> integer_constant_truncation_operation:
+    def integer_constant_truncation_operation(self) -> IntegerConstantTruncationOperation:
         """
         Defines the operation used by the SyReC parser for the truncation of integer constant values. For further details we refer to the semantics of the SyReC language
         """
 
     @integer_constant_truncation_operation.setter
-    def integer_constant_truncation_operation(self, arg: integer_constant_truncation_operation, /) -> None: ...
+    def integer_constant_truncation_operation(self, arg: IntegerConstantTruncationOperation, /) -> None: ...
     @property
     def allow_access_on_assigned_to_variable_parts_in_dimension_access_of_variable_access(self) -> bool:
         """
@@ -201,36 +201,36 @@ class configurable_options:
     @generate_quantum_operation_annotations.setter
     def generate_quantum_operation_annotations(self, arg: bool, /) -> None: ...
 
-class program:
+class Program:
     def __init__(self) -> None:
         """Constructs SyReC program object."""
 
-    def read(self, filename: str, configurable_options: configurable_options = ...) -> str:
+    def read(self, filename: str, configurable_options: ConfigurableOptions = ...) -> str:
         """Read and process a SyReC program from a file."""
 
-    def read_from_string(self, stringified_program: str, configurable_options: configurable_options = ...) -> str:
+    def read_from_string(self, stringified_program: str, configurable_options: ConfigurableOptions = ...) -> str:
         """Process an already stringified SyReC program."""
 
 def cost_aware_synthesis(
-    annotated_quantum_computation: annotatable_quantum_computation,
-    program: program,
-    configurable_options: configurable_options = ...,
-    optional_recorded_statistics: statistics | None = None,
+    annotated_quantum_computation: AnnotatableQuantumComputation,
+    program: Program,
+    configurable_options: ConfigurableOptions = ...,
+    optional_recorded_statistics: Statistics | None = None,
 ) -> bool:
     """Cost-aware synthesis of the SyReC program."""
 
 def line_aware_synthesis(
-    annotated_quantum_computation: annotatable_quantum_computation,
-    program: program,
-    configurable_options: configurable_options = ...,
-    optional_recorded_statistics: statistics | None = None,
+    annotated_quantum_computation: AnnotatableQuantumComputation,
+    program: Program,
+    configurable_options: ConfigurableOptions = ...,
+    optional_recorded_statistics: Statistics | None = None,
 ) -> bool:
     """Line-aware synthesis of the SyReC program."""
 
 def simple_simulation(
-    output: n_bit_values_container,
+    output: NBitValuesContainer,
     quantum_computation: mqt.core.ir.QuantumComputation,
-    input_: n_bit_values_container,
-    optional_recorded_statistics: statistics | None = None,
+    input_: NBitValuesContainer,
+    optional_recorded_statistics: Statistics | None = None,
 ) -> None:
     """Simulation of a synthesized SyReC program"""