luna-quantum 1.0.1rc9__cp312-cp312-manylinux_2_34_x86_64.whl → 1.0.1rc11__cp312-cp312-manylinux_2_34_x86_64.whl

luna_quantum/__init__.py

@@ -1,3 +1,4 @@
+from luna_quantum._core import __luna_quantum_version__
 from luna_quantum.aqm_overwrites.model import Model
 from luna_quantum.client.controllers import LunaQ, LunaSolve
 from luna_quantum.factories.luna_solve_client_factory import LunaSolveClientFactory
@@ -19,9 +20,9 @@ from luna_quantum.solve.usecases import (
     SolveJobFetchUpdatesUseCase,
     SolveJobGetResultUseCase,
 )
+from luna_quantum.util.debug_info import debug_info
 from luna_quantum.util.log_utils import Logging
 
-from . import utils
 from ._core import (
     Bounds,
     Comparator,
@@ -49,10 +50,13 @@ from ._core import (
     Variable,
     Vtype,
     errors,
+    transformations,
     translator,
+    utils,
 )
 from .utils import quicksum
 
+__version__ = __luna_quantum_version__
 UseCaseFactory.set_model_fetch_class(ModelFetchMetadataUseCase)
 UseCaseFactory.set_model_delete_class(ModelDeleteUseCase)
 UseCaseFactory.set_model_get_solution_class(ModelGetSolutionUseCase)
@@ -100,11 +104,14 @@ __all__ = [
     "UseCaseFactory",
     "Variable",
     "Vtype",
+    "__version__",
     "algorithms",
     "backends",
     "constants",
+    "debug_info",
     "errors",
     "quicksum",
+    "transformations",
     "translator",
     "utils",
 ]

luna_quantum/__init__.pyi

@@ -1,4 +1,3 @@
-from . import utils
 from ._core import (
     Bounds,
     Comparator,
@@ -27,14 +26,19 @@ from ._core import (
     Vtype,
     errors,
     translator,
+    utils,
+    transformations,
 )
 from .utils import quicksum
+from luna_quantum._core import __luna_quantum_version__
 from luna_quantum.aqm_overwrites.model import Model
 from luna_quantum.client.controllers import LunaQ, LunaSolve
 from luna_quantum.solve import DefaultToken
 from luna_quantum.solve.parameters import algorithms, backends, constants
+from luna_quantum.util.debug_info import debug_info
 from luna_quantum.util.log_utils import Logging
 
+__version__ = __luna_quantum_version__
 __all__ = [
     "Bounds",
     "Comparator",
@@ -66,11 +70,14 @@ __all__ = [
     "Unbounded",
     "Variable",
     "Vtype",
+    "__version__",
     "algorithms",
     "backends",
     "constants",
+    "debug_info",
     "errors",
     "quicksum",
+    "transformations",
     "translator",
     "utils",
 ]

luna_quantum/_core.pyi

@@ -3,7 +3,7 @@ from enum import Enum
 from types import TracebackType
 from typing import Literal, Self, overload
 from numpy.typing import NDArray
-from . import errors, translator
+from . import errors, transformations, translator, utils
 from luna_quantum.client.interfaces.services.luna_solve_i import ILunaSolve
 from luna_quantum.solve.domain.model_metadata import ModelMetadata
 from luna_quantum.solve.domain.solve_job import SolveJob
@@ -3656,6 +3656,9 @@ class Constraints:
         """
         ...
 
+__version__: str
+__aq_model_version__: str
+__luna_quantum_version__: str
 __all__ = [
     "Bounds",
     "Comparator",
@@ -3677,6 +3680,11 @@ __all__ = [
     "Timing",
     "Variable",
     "Vtype",
+    "__aq_model_version__",
+    "__luna_quantum_version__",
+    "__version__",
     "errors",
+    "transformations",
     "translator",
+    "utils",
 ]

luna_quantum/errors.pyi

@@ -226,7 +226,18 @@ class DuplicateConstraintNameError(Exception):
 
     def __str__(self, /) -> str: ...
 
+class CompilationError(RuntimeError):
+    """Raised when an error occured during compilation of a model in the PassManager."""
+
+    def __str__(self, /) -> str: ...
+
+class StartCannotBeInferredError(TypeError):
+    """To be raised when the start value in the quicksum cannot be inferred."""
+
+    def __str__(self, /) -> str: ...
+
 __all__ = [
+    "ComputationError",
     "ComputationError",
     "DecodeError",
     "DifferentEnvsError",

luna_quantum/transformations.py

@@ -0,0 +1,18 @@
+"""Transformations collection.
+
+The `transformations` module provides a collection of transformations for converting
+between various representations of optimization problems and their solutions.
+
+Transformations generally convert between different representations of an optimization
+model. For example, changing the Sense of a model.
+
+Each transformation encapsulates the logic needed for transforming a model to a desired
+output model with changed properties and the logic to convert a solution of the output
+model back to a solution representation matching the input model.
+
+In addition to the predefined transformations contained in this module.
+One can implement their own transformations by implementing the `TransformationPass`
+and `AnalysisPass` abstract classes. See the examples for further details.
+"""
+
+from ._core.transformations import *  # type: ignore[reportMissingImports] # noqa: F403

luna_quantum/transformations.pyi

@@ -0,0 +1,228 @@
+from abc import abstractmethod
+from enum import Enum
+from typing import Any, Literal, overload
+
+from aqmodels import Model, Sense, Solution, Timing
+
+class BasePass:
+    @property
+    def name(self) -> str:
+        """Get the name of this pass."""
+        ...
+    @property
+    def requires(self) -> list[str]:
+        """Get a list of required passes that need to be run before this pass."""
+        ...
+
+class TransformationPass(BasePass):
+    @property
+    @abstractmethod
+    def name(self) -> str:
+        """Get the name of this pass."""
+        ...
+    @property
+    def requires(self) -> list[str]:
+        """Get a list of required passes that need to be run before this pass."""
+        ...
+    @property
+    def invalidates(self) -> list[str]:
+        """Get a list of passes that are invalidated by this pass."""
+        ...
+    @abstractmethod
+    def run(self, model: Model, cache: AnalysisCache) -> tuple[Model, ActionType]:
+        """Run/Execute this transformation pass."""
+        ...
+    @abstractmethod
+    def backwards(self, solution: Solution, cache: AnalysisCache) -> Solution:
+        """Convert a solution back to fit this pass' input.
+
+        Convert a solution from a representation fitting this pass' output to
+        a solution representation fitting this pass' input.
+        """
+        ...
+
+class AnalysisCache:
+    @overload
+    def __getitem__(  # type: ignore[reportOverlappingOverload]
+        self, key: Literal["max-bias"]
+    ) -> MaxBias: ...
+    @overload
+    def __getitem__(self, key: str) -> dict[Any, Any]: ...
+    def __getitem__(self, key: str) -> Any:
+        """Get the analysis result for a specific analysis pass."""
+        ...
+
+class AnalysisPass(BasePass):
+    @property
+    @abstractmethod
+    def name(self) -> str:
+        """Get the name of this pass."""
+        ...
+    @property
+    def requires(self) -> list[str]:
+        """Get a list of required passes that need to be run before this pass."""
+        ...
+    @abstractmethod
+    def run(self, model: Model, cache: AnalysisCache) -> float:
+        """Run/Execute this analysis pass."""
+        ...
+
+class ActionType(Enum):
+    DidTransform = ...
+    """Indicate that the pass did transform the model."""
+    DidAnalysis = ...
+    """Indicate that the pass did analyse the model."""
+    Nothing = ...
+    """Indicate that the pass did NOT do anything."""
+
+class ChangeSensePass(BasePass):
+    """A transformation pass to change the model's Sense to a target Sense."""
+
+    def __init__(self, sense: Sense) -> None:
+        """Transform the model's Sense to a target Sense.
+
+        Parameters
+        ----------
+        sense : Sense
+            The target sense of the model after calling the `run` method on it.
+        """
+        ...
+    @property
+    def sense(self) -> Sense:
+        """Get the specified target sense of this pass."""
+        ...
+
+class MaxBias:
+    """An analysis pass result storing the max bias (coefficient) of a model."""
+
+    @property
+    def val(self) -> float:
+        """Get the value of the maxium bias."""
+        ...
+
+class MaxBiasAnalysis(BasePass):
+    """An analysis pass computing the maximum bias contained in the model."""
+
+    def __init__(self) -> None: ...
+
+class LogElement:
+    """An element of the execution log of an intermediate representation (IR)."""
+
+    @property
+    def pass_name(self) -> str:
+        """The name of the pass."""
+        ...
+
+    @property
+    def timing(self) -> Timing:
+        """Timing information for this log element."""
+        ...
+
+    @property
+    def kind(self) -> ActionType | None:
+        """Transformation type information for this log element, if available."""
+        ...
+
+class IR:
+    """The intermediate representation (IR) of a model after transformation.
+
+    The IR contains the resulting model after transformation (`ir.model`) as well
+    as the analysis cache (`ir.cache`) and an execution log (`ir.execution_log`).
+    """
+
+    @property
+    def model(self) -> Model:
+        """Get the model stored in the IR."""
+        ...
+
+    @property
+    def cache(self) -> AnalysisCache:
+        """Get the analysis cache stored the IR."""
+        ...
+
+    @property
+    def execution_log(self) -> list[LogElement]:
+        """Get the analysis cache stored the IR."""
+        ...
+
+class PassManager:
+    """Manage and execute a sequence of passes on a model.
+
+    The PassManager implements a compiler-style pass pattern, enabling both
+    general-purpose and algorithm-specific manipulations of optimization
+    models. Each pass is an atomic operation (for example, ChangeSensePass)
+    that transforms the model or its intermediate representation (IR). The
+    PassManager runs each pass in order and produces a rich IR that records
+    the transformations applied and supports back-transformations.
+    """
+
+    def __init__(
+        self, passes: list[BasePass | TransformationPass | AnalysisPass]
+    ) -> None:
+        """Manage and execute a sequence of passes on a model.
+
+        The PassManager implements a compiler-style pass pattern, enabling both
+        general-purpose and algorithm-specific manipulations of optimization
+        models. Each pass is an atomic operation (for example, ChangeSensePass)
+        that transforms the model or its intermediate representation (IR). The
+        PassManager runs each pass in order and produces a rich IR that records
+        the transformations applied and supports back-transformations.
+
+        Parameters
+        ----------
+        passes : list[TransformationPass | AnalysisPass]
+            An ordered sequence of Pass instances to apply. Each Pass must conform to
+            the `TransformationPass` or `AnalysisPass` interface.
+        """
+        ...
+
+    def run(self, model: Model) -> IR:
+        """Apply all configures passes.
+
+        Apply all configured passes to the given model and return the
+        resulting intermediate representation.
+
+        Parameters
+        ----------
+        model : Model
+            The model to be transformed.
+
+        Returns
+        -------
+        IR
+            The intermediate representation of the model after transformation.
+        """
+        ...
+
+    def backwards(self, solution: Solution, ir: IR) -> Solution:
+        """Apply the back transformation to the given solution.
+
+        Parameters
+        ----------
+        solution : Solution
+            The solution to transform back to a representation fitting the original
+            (input) model of this `PassManager`.
+        ir : IR
+            The intermediate representation (IR) resulted from the `run` call.
+
+        Returns
+        -------
+        Solution
+            A solution object representing a solution to the original problem passed
+            to this `PassManager`'s run method.
+        """
+        ...
+
+__all__ = [
+    "IR",
+    "ActionType",
+    "AnalysisCache",
+    "AnalysisPass",
+    "BasePass",
+    "ChangeSensePass",
+    "LogElement",
+    "MaxBias",
+    "MaxBiasAnalysis",
+    "PassManager",
+    "TransformationPass",
+]

luna_quantum/translator.pyi

@@ -353,8 +353,8 @@ class NumpyTranslator:
         *,
         env: Environment | None = ...,
     ) -> Solution:
-        """
-        Convert a solution in the format of numpy arrays to our solution format.
+        """Convert a solution in the format of numpy arrays to our solution format.
+
         Note that the optimization sense is always assumed to be minimization.
 
         Parameters

luna_quantum/util/debug_info.py

@@ -0,0 +1,52 @@
+import platform
+import sys
+from logging import Logger
+
+from rich import box
+from rich.table import Table
+
+from luna_quantum._core import __aq_model_version__, __luna_quantum_version__
+from luna_quantum.util.log_utils import Logging
+
+_logger: Logger = Logging.get_logger(__name__)
+_pkg_list: list[str] = ["numpy", "pydantic"]
+
+
+def debug_info() -> None:
+    """Print debug information."""
+    python_version = (
+        f"{sys.version_info.major}.{sys.version_info.minor}.{sys.version_info.micro}"
+    )
+    os_info = f"{platform.system()} {platform.release()}"
+
+    # Get additional system information
+    architecture = platform.machine()
+    python_implementation = platform.python_implementation()
+
+    table = Table(
+        title="Luna Debug Information",
+        title_justify="left",
+        caption="System and environment details for troubleshooting",
+        box=box.MARKDOWN,
+    )
+    table.add_column("Property", style="cyan", no_wrap=True)
+    table.add_column("Version", style="green", no_wrap=True)
+
+    # Add rows to the table
+    table.add_row("Luna Quantum", f"{__luna_quantum_version__}")
+    table.add_row("AqModel", f"{__aq_model_version__}")
+    table.add_row("Python", f"{python_version}")
+    table.add_row("Python Implementation", f"{python_implementation}")
+    table.add_row("Operating System", f"{os_info}")
+    table.add_row("Architecture", f"{architecture}")
+
+    for package in _pkg_list:
+        try:
+            module = __import__(package)
+            version = getattr(module, "__version__", "pkg found, version unknown")
+            table.add_row(package, version)
+        except ImportError:
+            table.add_row(package, "pkg not found")
+
+    # Print the table to console
+    Logging.get_console().print(table)

luna_quantum/util/log_utils.py

@@ -56,6 +56,20 @@ class Logging:
         """
         return Logging._log_level
 
+    @staticmethod
+    def get_console() -> Console:
+        """Return a Rich console instance for use in logging."""
+        custom_theme = Theme(
+            {
+                "logging.level.debug": "bright_blue",
+                "logging.level.info": "bright_green",
+                "logging.level.warning": "bold bright_yellow",
+                "logging.level.error": "bold bright_red",
+                "logging.level.critical": "bold bright_magenta",
+            }
+        )
+        return Console(theme=custom_theme)
+
     @staticmethod
     def get_logger(name: str) -> logging.Logger:
         """Get a logger with the specified name and set up a RichHandler for it.
@@ -77,18 +91,8 @@ class Logging:
         if logger.hasHandlers():
             return logger
 
-        custom_theme = Theme(
-            {
-                "logging.level.debug": "bright_blue",
-                "logging.level.info": "bright_green",
-                "logging.level.warning": "bold bright_yellow",
-                "logging.level.error": "bold bright_red",
-                "logging.level.critical": "bold bright_magenta",
-            }
-        )
-        console = Console(theme=custom_theme)
         handler = RichHandler(
-            console=console,
+            console=Logging.get_console(),
             rich_tracebacks=True,
             show_time=True,
             show_level=True,

luna_quantum/utils.py

@@ -1,72 +1,3 @@
 """Utility module containing convenience functions."""
 
-from collections.abc import Iterable
-
-from ._core import Expression, Variable
-
-
-class InvalidStartTypeError(TypeError):
-    """To be raised when an invalid start type is specified in quicksum."""
-
-    def __init__(self, actual: type) -> None:
-        super().__init__(f"start must be of type `Expression`, is '{actual}'")
-
-
-class StartCannotBeInferredError(TypeError):
-    """To be raised when the start value in the quicksum cannot be inferred."""
-
-    def __init__(self) -> None:
-        super().__init__(
-            "iterable must contain at least one Expression or Variable, "
-            "or 'start' needs to be set."
-        )
-
-
-def quicksum(
-    iterable: Iterable[Expression | Variable | int | float],
-    /,
-    start: Expression | None = None,
-) -> Expression:
-    """Sum over an Iterable of Expression, Variable, int or float values.
-
-    Create an Expression based on an iterable of Expression, Variable, int or float
-    elements. Note that either the `iterable` must contain at least one `Expression`
-    or `Variable` or the start parameter is set.
-
-    Parameters
-    ----------
-    iterable : Iterable[Expression | Variable | int | float]
-        The iterable of elements to sum up.
-    start : Expression | None, optional
-        The starting value for the summation.
-
-    Returns
-    -------
-    Expression
-        The expression created based on the sum of the iterable elements.
-
-    Raises
-    ------
-    TypeError (InvalidStartTypeError | StartCannotBeInferredError)
-        If the `iterable` does not contain any Expression or Variable.
-        If the `start` is not of type Expression.
-    """
-    items = list(iterable)
-    if start is None:
-        for item in items:
-            if isinstance(item, Expression | Variable):
-                start = Expression(env=item._environment)  # noqa: SLF001
-                break
-
-    if start is None:
-        raise StartCannotBeInferredError
-
-    if not isinstance(start, Expression):
-        raise InvalidStartTypeError(type(start))
-
-    _start: Expression = start
-
-    for item in items:
-        _start += item
-
-    return _start
+from ._core.utils import *  # type: ignore[reportMissingImports] # noqa: F403

luna_quantum/utils.pyi

@@ -1,8 +1,38 @@
-from collections.abc import Iterable
+from collections.abc import Generator, Iterable
 from typing import overload
 
 from aqmodels import Expression, Variable
 
+@overload
+def quicksum(iterable: Generator[Expression], /) -> Expression: ...
+@overload
+def quicksum(iterable: Generator[Variable], /) -> Expression: ...
+@overload
+def quicksum(iterable: Generator[int], /) -> Expression: ...
+@overload
+def quicksum(iterable: Generator[float], /) -> Expression: ...
+@overload
+def quicksum(
+    iterable: Generator[Expression], /, start: Expression | None = None
+) -> Expression: ...
+@overload
+def quicksum(
+    iterable: Generator[Variable], /, start: Expression | None = None
+) -> Expression: ...
+@overload
+def quicksum(
+    iterable: Generator[int], /, start: Expression | None = None
+) -> Expression: ...
+@overload
+def quicksum(
+    iterable: Generator[float], /, start: Expression | None = None
+) -> Expression: ...
+@overload
+def quicksum(
+    iterable: Generator[Expression | Variable | float | int],
+    /,
+    start: Expression | None = None,
+) -> Expression: ...
 @overload
 def quicksum(iterable: Iterable[Expression], /) -> Expression: ...
 @overload
@@ -33,3 +63,5 @@ def quicksum(
     /,
     start: Expression | None = None,
 ) -> Expression: ...
+
+__all__ = ["quicksum"]

{luna_quantum-1.0.1rc9.dist-info → luna_quantum-1.0.1rc11.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: luna-quantum
-Version: 1.0.1rc9
+Version: 1.0.1rc11
 Classifier: Programming Language :: Python :: 3
 Classifier: License :: OSI Approved :: Apache Software License
 Classifier: Operating System :: OS Independent

{luna_quantum-1.0.1rc9.dist-info → luna_quantum-1.0.1rc11.dist-info}/RECORD

@@ -1,11 +1,11 @@
-luna_quantum-1.0.1rc9.dist-info/METADATA,sha256=uHoM0GXehFAsXPhfxencb6iQxRKwEIfpIZo4nbQ_jJ0,1533
-luna_quantum-1.0.1rc9.dist-info/WHEEL,sha256=IPzRd0nigP4r3GK-lmtM2DKCRPiRfyNhNj4tmNbAOTQ,108
-luna_quantum-1.0.1rc9.dist-info/licenses/LICENSE,sha256=psuoW8kuDP96RQsdhzwOqi6fyWv0ct8CR6Jr7He_P_k,10173
-luna_quantum-1.0.1rc9.dist-info/licenses/NOTICE,sha256=noPOS8eDj5XoyRO8ZrCxIOh5fSjk0RildIrrqxQlepY,588
-luna_quantum/__init__.py,sha256=5pcXLImiAMVprC9E0ZldR4RLdosfjAJKw_BL0yVhLGk,2951
-luna_quantum/__init__.pyi,sha256=MFONTFS-LApPKepjz5eqDAc1wCT3bL2nGFp0a-zQ3wQ,1389
-luna_quantum/_core.cpython-312-x86_64-linux-gnu.so,sha256=4IpCILMnzyP3omStWvaVeYEPyf_sRTgyJM__b5O9_u0,4906928
-luna_quantum/_core.pyi,sha256=n8eYwMl0pNc2oGZhums4izlV-5Ozq35tiMPYutMG08A,104006
+luna_quantum-1.0.1rc11.dist-info/METADATA,sha256=YeePymeIaVbbJNlFVjDMC4jpNm0HbrZrJVzo4z8IiyE,1534
+luna_quantum-1.0.1rc11.dist-info/WHEEL,sha256=IPzRd0nigP4r3GK-lmtM2DKCRPiRfyNhNj4tmNbAOTQ,108
+luna_quantum-1.0.1rc11.dist-info/licenses/LICENSE,sha256=psuoW8kuDP96RQsdhzwOqi6fyWv0ct8CR6Jr7He_P_k,10173
+luna_quantum-1.0.1rc11.dist-info/licenses/NOTICE,sha256=noPOS8eDj5XoyRO8ZrCxIOh5fSjk0RildIrrqxQlepY,588
+luna_quantum/__init__.py,sha256=VVqJBFKl8ET7gJmebXVnTsD33sIFfhxKm7_eB12YVkU,3170
+luna_quantum/__init__.pyi,sha256=dG3-NeEI8ApxHUcVq-Ov9Pa9D3Px_5yWUWkxhLsfL80,1608
+luna_quantum/_core.cpython-312-x86_64-linux-gnu.so,sha256=C27-wWJBTWMS37o9r5YMOXQ-t7iZXro_xy0bodL6kuM,5071600
+luna_quantum/_core.pyi,sha256=HZ5peRajRbEfYerxhHR1XfFcNVcjAGuyrlHv8yfXiiw,104218
 luna_quantum/algorithms/__init__.py,sha256=IX9ZpzY3Do3mTgKqto5vAWwdYrZrM-RemYSf64yxefg,69
 luna_quantum/aqm_overwrites/__init__.py,sha256=rteObr5JHDnTnRime0Euq9Qy2iDIp6VMpFNHTGVNBe0,46
 luna_quantum/aqm_overwrites/model.py,sha256=La5mh-aS2LNLaQFp_B1EnhrKUXVRRmIqGnIvX66uc8Y,6099
@@ -81,7 +81,7 @@ luna_quantum/client/schemas/wrappers/datetime_wrapper.py,sha256=8K2jexTarxGCgD1u
 luna_quantum/client/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 luna_quantum/client/utils/qpu_token_utils.py,sha256=xeWIKcBwXGSQ0INfUY3NMTu6H90T03jkT85yHs2QXmk,4768
 luna_quantum/errors.py,sha256=yjeXB3i07LlTuuJ18IKgwsC5wmtJElN8cDwlg3JkcEs,1424
-luna_quantum/errors.pyi,sha256=mHTkTauIanZc3qtuHE7QkPhjpQDFHzJtd1Fe6X63D-M,8391
+luna_quantum/errors.pyi,sha256=sB9AKnafl1-duUZQPJNGDGBqE41QFhk1BX1jgBkqW6A,8745
 luna_quantum/exceptions/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 luna_quantum/exceptions/base_luna_quantum_error.py,sha256=qC712QkF04FiY_qwQ5HlIYVhg5P6WzXJ_chJDVTpWXI,89
 luna_quantum/exceptions/patch_class_field_exists_error.py,sha256=3TGKb-MNyjwntrJkbRaBKEvlsj68ROTwCltDt6Zg7Gg,398
@@ -242,14 +242,17 @@ luna_quantum/solve/usecases/solve_job_create_usecase.py,sha256=IcKN2VWTGw3J3Wgnt
 luna_quantum/solve/usecases/solve_job_delete_usecase.py,sha256=hUOLeFLU9NCggWMGuIJG7WYShQjP4H_iZJnPvBJgTpA,1128
 luna_quantum/solve/usecases/solve_job_fetch_updates_usecase.py,sha256=W-Z6Q7IuyodjZmFKEsJGaa9V2fnGMPWj9FRN9gEdPNc,1686
 luna_quantum/solve/usecases/solve_job_get_result_usecase.py,sha256=dk6LSjInOfH5d7LlbUmawnqytKig_vFTCKTDK5KlDlI,3541
+luna_quantum/transformations.py,sha256=AZtGBaJ0PTWsr4mpONoJq5BpNOXPcM85CnWDhPgXx_I,902
+luna_quantum/transformations.pyi,sha256=frrVFeHTRp23iEsQlLAQfDWkVh5GNUdywRE2PLI9Dsk,7031
 luna_quantum/translator.py,sha256=xi5eiIRNv8ATz69GYpUY5kbEIUmQEtK6_dF5t2Mwpec,1134
-luna_quantum/translator.pyi,sha256=q-SyAEoCMK8F8MPx3FicThRSLKLxCLzEg3wRSf-CGeY,26337
+luna_quantum/translator.pyi,sha256=1kQyDBUWKV6vTyydC_f2K1aQzbW6_8sdcpgxCZJVaM4,26329
 luna_quantum/util/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 luna_quantum/util/active_waiting.py,sha256=MkLL7UEtWh8jU1Zwd9rYqfcReYPGB7FJLUjQe2v9_Tg,3029
 luna_quantum/util/class_patcher.py,sha256=-vD_7Auh1dQTOJXOKv-4sTQ5EzH3n6I0EsHDFQ_ZPOY,5456
-luna_quantum/util/log_utils.py,sha256=LDoY9UAf7gpPAY8UfKoYdG4jXdJpUDJOVWW2ziY3Lt4,4789
+luna_quantum/util/debug_info.py,sha256=UjMcmX5waYEEH51cK8REUOdjpNX0D6HWSR0ns7yQp54,1755
+luna_quantum/util/log_utils.py,sha256=M8Gbt0Pb2CsQsG3fGyuKeT-rl264laEGGXcPCGfBhaQ,4918
 luna_quantum/util/pretty_base.py,sha256=Vv3dYpMsydOPYFOm-0lCCuJIe-62oYkI64Zy_bahl3s,2115
 luna_quantum/util/pydantic_utils.py,sha256=nhl_SdLJVAizrtLVHvnbco84g8CdBVdVxN_jlXiv82w,1263
-luna_quantum/utils.py,sha256=DEgZ7M1UK4GHSOUBJkaserrzvc0P4ctBI790nn5nPes,2158
-luna_quantum/utils.pyi,sha256=awLn13VVSNz2OumA7kHBnP4ERwielcV3X8VIrmut4Yk,1003
-luna_quantum-1.0.1rc9.dist-info/RECORD,,
+luna_quantum/utils.py,sha256=pBOkGXNJXlOzxAwTJv8nCj32Q6WNeh3t6Ka3lmTgy9c,134
+luna_quantum/utils.pyi,sha256=afjDJhGiM9KmN2zqVkd6agP8JAsbwUxJBW9tEyiFrdY,1941
+luna_quantum-1.0.1rc11.dist-info/RECORD,,