text: """ Dimmer controller LimitlessLED group. """
  
  import time
  
  from limitlessled import util
  from limitlessled.group import Group, rate
  from limitlessled.util import steps
  
  DIMMER = 'dimmer'
  
  
  class DimmerGroup(Group):
      """ Dimmer LimitlessLED group. """
  
      def __init__(self, bridge, number, name):
          """ Initialize dimmer group.
  
          Brightness must be initialized
          to some value.
  
          :param bridge: Associated bridge.
          :param number: Group number (1-4).
          :param name: Group name.
          """
          super().__init__(bridge, number, name, DIMMER)
  
      @property
      def brightness(self):
          """ Brightness property.
  
          :returns: Brightness.
          """
          return self._brightness
  
      @brightness.setter
      def brightness(self, brightness):
          """ Set the brightness.
  
          :param brightness: Value to set (0.0-1.0).
          """
          try:
              cmd = self.command_set.brightness(brightness)
              self.send(cmd)
              self._brightness = brightness
          except AttributeError:
              self._setter('_brightness', brightness,
                           self._dimmest, self._brightest,
                           self._to_brightness)
  
      def transition(self, duration, brightness=None):
          """ Transition wrapper.
  
          Short-circuit transition if necessary.
  
          :param duration: Duration of transition.
          :param brightness: Transition to this brightness.
          """
          if duration == 0:
              if brightness is not None:
                  self.brightness = brightness
              return
          if brightness != self.brightness:
              self._transition(duration, brightness)
  
      @rate(reps=1)
      def _transition(self, duration, brightness):
          """ Complete a transition.
  
          :param duration: Duration of transition.
          :param brightness: Transition to this brightness.
          """
          # Set initial value.
          b_start = self.brightness
          # Compute ideal step amount.
          b_steps = 0
          if brightness is not None:
              b_steps = steps(self.brightness, brightness,
                              self.command_set.brightness_steps)
          # Compute ideal step amount (at least one).
          # Calculate wait.
          wait = self._wait(duration, b_steps, b_steps)
          # Scale down steps if no wait time.
          if wait == 0:
              b_steps = self._scale_steps(duration, b_steps,
                                                   b_steps)
          # Perform transition.
          for i in range(b_steps):
              # Brightness.
              if b_steps > 0:
                  self.brightness = util.transition(i, b_steps,
                                                    b_start, brightness)
              time.sleep(wait)
  
      def _setter(self, attr, value, bottom, top, to_step):
          """ Set a value.
  
          :param attr: Attribute to set.
          :param value: Value to use.
          :param bottom: Get to bottom value.
          :param top: Get to top value.
          :param to_step: Get to intermediary value.
          """
          if value < 0 or value > 1:
              raise ValueError("out of range")
          if value == 0.0:
              bottom()
          elif value == 1.0:
              top()
          else:
              to_step(value)
          setattr(self, attr, value)
  
      def _to_brightness(self, brightness):
          """ Step to a given brightness.
  
          :param brightness: Get to this brightness.
          """
          self._to_value(self._brightness, brightness,
                         self.command_set.brightness_steps,
                         self._dimmer, self._brighter)
  
      @rate(reps=1)
      def _to_value(self, current, target, max_steps, step_down, step_up):
          """ Step to a value
  
          :param current: Current value.
          :param target: Target value.
          :param max_steps: Maximum number of steps.
          :param step_down: Down function.
          :param step_up: Up function.
          """
          for _ in range(steps(current, target, max_steps)):
              if (current - target) > 0:
                  step_down()
              else:
                  step_up()
  
      @rate(wait=0.025, reps=2)
      def _brightest(self):
          """ Group as bright as possible. """
          for _ in range(steps(self.brightness, 1.0,
                               self.command_set.brightness_steps)):
              self._brighter()
  
      @rate(wait=0.025, reps=2)
      def _dimmest(self):
          """ Group brightness as dim as possible. """
          for _ in range(steps(self.brightness, 0.0,
                               self.command_set.brightness_steps)):
              self._dimmer()
  
      def _brighter(self):
          """ One step brighter. """
          self.send(self.command_set.brighter())
  
      def _dimmer(self):
          """ One step dimmer. """
          self.send(self.command_set.dimmer())
  