compiler_container
==================

.. py:module:: quantify_scheduler.backends.qblox.compiler_container 

.. autoapi-nested-parse::

   Contains the compiler container class.



Module Contents
---------------

Classes
~~~~~~~

.. autoapisummary::

   quantify_scheduler.backends.qblox.compiler_container.CompilerContainer




.. py:class:: CompilerContainer(schedule: quantify_scheduler.Schedule)


   Container class that holds all the compiler objects for the individual instruments.

   This class serves to allow all the possible compilation steps that involve multiple
   devices at the same time, such as calculating the modulation frequency for a device
   with a separate local oscillator from a clock that is defined at the schedule level.

   It is recommended to construct this object using the ``from_hardware_cfg`` factory
   method.


   :param schedule: The schedule to be compiled.

   .. py:property:: instrument_compilers
      :type: dict[str, quantify_scheduler.backends.qblox.compiler_abc.InstrumentCompiler]

      The compilers for the individual instruments.

   .. py:attribute:: total_play_time

      The total duration of the schedule in absolute time this class will be
      compiling.

   .. py:attribute:: resources

      The resources attribute of the schedule. Used for getting the information
      from the clocks.

   .. py:attribute:: clusters
      :type: dict[str, quantify_scheduler.backends.qblox.instrument_compilers.ClusterCompiler]

      Cluster compiler instances managed by this container instance.

   .. py:attribute:: local_oscillators
      :type: dict[str, quantify_scheduler.backends.qblox.instrument_compilers.LocalOscillatorCompiler]

      Local oscillator compiler instances managed by this container instance.

   .. py:method:: prepare()

      Prepares all the instrument compilers contained in the class,
      by running their respective :code:`prepare` methods.


   .. py:method:: compile(debug_mode: bool, repetitions: int) -> dict[str, Any]

      Performs the compilation for all the individual instruments.

      :param debug_mode: Debug mode can modify the compilation process,
                         so that debugging of the compilation process is easier.
      :param repetitions: Amount of times to perform execution of the schedule.

      :returns: Dictionary containing all the compiled programs for each instrument. The key
                refers to the name of the instrument that the program belongs to.


   .. py:method:: _add_cluster(name: str, instrument_cfg: dict[str, Any], latency_corrections: dict[str, float] | None = None, distortion_corrections: dict[int, Any] | None = None) -> None


   .. py:method:: _add_local_oscillator(name: str, instrument_cfg: dict[str, Any]) -> None


   .. py:method:: from_hardware_cfg(schedule: quantify_scheduler.Schedule, hardware_cfg: dict) -> CompilerContainer
      :classmethod:

      Factory method for the CompilerContainer. This is the preferred way to use the
      CompilerContainer class.

      :param schedule: The schedule to pass to the constructor.
      :param hardware_cfg: The hardware config.