docs: def _get_utc_sun_time_deg(self, deg):
          """
          Return the times in minutes from 00:00 (utc) for a given sun altitude.
  
          This is done for a given sun altitude in sunrise `deg` degrees
          This function only works for altitudes sun really is.
          If the sun never gets to this altitude, the returned sunset and sunrise
          values will be negative. This can happen in low altitude when latitude
          is nearing the poles in winter times, the sun never goes very high in
          the sky there.
  
          Algorithm from
          http://www.srrb.noaa.gov/highlights/sunrise/calcdetails.html
          The low accuracy solar position equations are used.
          These routines are based on Jean Meeus's book Astronomical Algorithms.
          """
          gama = 0        # location of sun in yearly cycle in radians
          eqtime = 0      # difference betwen sun noon and clock noon
          decl = 0        # sun declanation
          hour_angle = 0  # solar hour angle
          sunrise_angle = math.pi * deg / 180.0  # sun angle at sunrise/set
  
          # get the day of year
          day_of_year = self.gday_of_year()
  
          # get radians of sun orbit around earth =)
          gama = 2.0 * math.pi * ((day_of_year - 1) / 365.0)
  
          # get the diff betwen suns clock and wall clock in minutes
          eqtime = 229.18 * (0.000075 + 0.001868 * math.cos(gama) -
                             0.032077 * math.sin(gama) -
                             0.014615 * math.cos(2.0 * gama) -
                             0.040849 * math.sin(2.0 * gama))
  
          # calculate suns declanation at the equater in radians
          decl = (0.006918 - 0.399912 * math.cos(gama) +
                  0.070257 * math.sin(gama) -
                  0.006758 * math.cos(2.0 * gama) +
                  0.000907 * math.sin(2.0 * gama) -
                  0.002697 * math.cos(3.0 * gama) +
                  0.00148 * math.sin(3.0 * gama))
  
          # we use radians, ratio is 2pi/360
          latitude = math.pi * self.location.latitude / 180.0
  
          # the sun real time diff from noon at sunset/rise in radians
          try:
              hour_angle = (math.acos(
                  math.cos(sunrise_angle) /
                  (math.cos(latitude) * math.cos(decl)) -
                  math.tan(latitude) * math.tan(decl)))
          # check for too high altitudes and return negative values
          except ValueError:
              return -720, -720
  
          # we use minutes, ratio is 1440min/2pi
          hour_angle = 720.0 * hour_angle / math.pi
  
          # get sunset/rise times in utc wall clock in minutes from 00:00 time
          # sunrise / sunset
          longitude = self.location.longitude
          return int(720.0 - 4.0 * longitude - hour_angle - eqtime), \
              int(720.0 - 4.0 * longitude + hour_angle - eqtime)