docs: def calculate_sun_from_date_time(self, datetime, is_solar_time=False):
          """Get Sun for an hour of the year.
  
          This code is originally written by Trygve Wastvedt \
           (Trygve.Wastvedt@gmail.com)
          based on (NOAA) and modified by Chris Mackey and Mostapha Roudsari
  
          Args:
              datetime: Ladybug datetime
              is_solar_time: A boolean to indicate if the input hour is solar time.
                  (Default: False)
  
          Returns:
              A sun object for this particular time
          """
          # TODO(mostapha): This should be more generic and based on a method
          if datetime.year != 2016 and self.is_leap_year:
              datetime = DateTime(datetime.month, datetime.day, datetime.hour,
                                  datetime.minute, True)
  
          sol_dec, eq_of_time = self._calculate_solar_geometry(datetime)
  
          hour = datetime.float_hour
  
          is_daylight_saving = self.is_daylight_saving_hour(datetime.hoy)
  
          hour = hour + 1 if self.is_daylight_saving_hour(datetime.hoy) else hour
  
          # minutes
          sol_time = self._calculate_solar_time(hour, eq_of_time, is_solar_time) * 60
  
          # degrees
          if sol_time / 4 < 0:
              hour_angle = sol_time / 4 + 180
          else:
              hour_angle = sol_time / 4 - 180
  
          # Degrees
          zenith = math.degrees(math.acos
                                (math.sin(self._latitude) *
                                 math.sin(math.radians(sol_dec)) +
                                 math.cos(self._latitude) *
                                 math.cos(math.radians(sol_dec)) *
                                 math.cos(math.radians(hour_angle))))
  
          altitude = 90 - zenith
  
          # Approx Atmospheric Refraction
          if altitude > 85:
              atmos_refraction = 0
          else:
              if altitude > 5:
                  atmos_refraction = 58.1 / math.tan(math.radians(altitude))
  
                  - 0.07 / (math.tan(math.radians(altitude)))**3
                  + 0.000086 / (math.tan(math.radians(altitude)))**5
              else:
                  if altitude > -0.575:
                      atmos_refraction = 1735
  
                      + altitude * (-518.2 + altitude *
                                    (103.4 + altitude *
                                     (-12.79 + altitude * 0.711)))
                  else:
  
                      atmos_refraction = -20.772 / math.tan(
                          math.radians(altitude))
  
          atmos_refraction /= 3600
  
          altitude += atmos_refraction
  
          # Degrees
          if hour_angle > 0:
              azimuth = (math.degrees(
                  math.acos(
                      (
                          (math.sin(self._latitude) *
                           math.cos(math.radians(zenith))) -
                          math.sin(math.radians(sol_dec))) /
                      (math.cos(self._latitude) *
                       math.sin(math.radians(zenith)))
                  )
              ) + 180) % 360
          else:
              azimuth = (540 - math.degrees(math.acos((
                  (math.sin(self._latitude) *
                   math.cos(math.radians(zenith))) -
                  math.sin(math.radians(sol_dec))) /
                  (math.cos(self._latitude) *
                   math.sin(math.radians(zenith))))
              )) % 360
  
          altitude = math.radians(altitude)
          azimuth = math.radians(azimuth)
          # create the sun for this hour
          return Sun(datetime, altitude, azimuth, is_solar_time, is_daylight_saving,
                     self.north_angle)