docs: def _calculate_solar_geometry(self, datetime):
          """Calculate Solar geometry for an hour of the year.
  
          Attributes:
              datetime: A Ladybug datetime
  
          Returns:
              Solar declination: Solar declination in radians
              eq_of_time: Equation of time as minutes
          """
          month = datetime.month
          day = datetime.day
          hour = datetime.hour
          minute = datetime.minute
          year = 2016 if self.is_leap_year else 2017
  
          def find_fraction_of_24(hour, minute):
              """
              This function calculates the fraction of the 24 hour
              the provided time represents
              1440 is total the number of minutes in a 24 hour cycle.
              args
                  hour: Integer. Hour between 0 - 23
                  minute: Integer. Minute between 0 - 59
              return: Float.
                  The fraction of the 24 hours the provided time represents
              """
              return round((minute + hour * 60) / 1440.0, 2)
  
          def days_from_010119(year, month, day):
              """
              This function calculates the number of days from 01-01-1900 \
              to the provided date
              args :
                  year: Integer. The year in the date
                  month: Integer. The month in the date
                  day: Integer. The date
              return: The number of days from 01-01-1900 to the date provided
              """
  
              # Making a list of years from the year 1900
              years = range(1900, year)
  
              def is_leap_year(year):
                  """Determine whether a year is a leap year."""
                  return year % 4 == 0 and (year % 100 != 0 or year % 400 == 0)
  
              # Number of days in a year are 366 if it is a leap year
              days_in_year = []
              for item in years:
                  if is_leap_year(item):
                      days_in_year.append(366)
                  else:
                      days_in_year.append(365)
  
              # Making the total of all the days in preceding years
              days_in_precending_years = 0
              for days in days_in_year:
                  days_in_precending_years += days
  
              if is_leap_year(year):
                  month_dict = {1: 31, 2: 29, 3: 31, 4: 30, 5: 31, 6: 30,
                                7: 31, 8: 31, 9: 30, 10: 31, 11: 30, 12: 31}
              else:
                  month_dict = {1: 31, 2: 28, 3: 31, 4: 30, 5: 31, 6: 30,
                                7: 31, 8: 31, 9: 30, 10: 31, 11: 30, 12: 31}
  
              """Making the total of all the days in preceding months\
              in the same year"""
              keys = tuple(month_dict.keys())
              days_in_precending_months = 0
              for i in range(month - 1):
                  days_in_precending_months += month_dict[keys[i]]
  
              return days_in_precending_years + days_in_precending_months + day + 1
  
          julian_day = days_from_010119(year, month, day) + 2415018.5 + \
              find_fraction_of_24(hour, minute) - (float(self.time_zone) / 24)
  
          julian_century = (julian_day - 2451545) / 36525
  
          # degrees
          geom_mean_long_sun = (280.46646 + julian_century *
                                (36000.76983 + julian_century * 0.0003032)
                                ) % 360
          # degrees
          geom_mean_anom_sun = 357.52911 + julian_century * \
              (35999.05029 - 0.0001537 * julian_century)
  
          eccent_orbit = 0.016708634 - julian_century * \
              (0.000042037 + 0.0000001267 * julian_century)
  
          sun_eq_of_ctr = math.sin(
              math.radians(geom_mean_anom_sun)) * \
              (1.914602 - julian_century * (0.004817 + 0.000014 * julian_century)
               ) +\
              math.sin(math.radians(2 * geom_mean_anom_sun)) * \
              (0.019993 - 0.000101 * julian_century) + \
              math.sin(math.radians(3 * geom_mean_anom_sun)) * \
              0.000289
  
          # degrees
          sun_true_long = geom_mean_long_sun + sun_eq_of_ctr
  
          # degrees
          sun_app_long = sun_true_long - 0.00569 - 0.00478 * \
              math.sin(math.radians(125.04 - 1934.136 * julian_century))
  
          # degrees
          mean_obliq_ecliptic = 23 + \
              (26 + ((21.448 - julian_century * (46.815 + julian_century *
                                                 (0.00059 - julian_century *
                                                  0.001813)))) / 60) / 60
  
          # degrees
          oblique_corr = mean_obliq_ecliptic + 0.00256 * \
              math.cos(math.radians(125.04 - 1934.136 * julian_century))
  
          # RADIANS
          sol_dec = math.degrees(math.asin(math.sin(math.radians(oblique_corr)) *
                                           math.sin(math.radians(sun_app_long))))
  
          var_y = math.tan(math.radians(oblique_corr / 2)) * \
              math.tan(math.radians(oblique_corr / 2))
  
          # minutes
          eq_of_time = 4 \
              * math.degrees(
                  var_y * math.sin(2 * math.radians(geom_mean_long_sun)) -
                  2 * eccent_orbit * math.sin(math.radians(geom_mean_anom_sun)) +
                  4 * eccent_orbit * var_y *
                  math.sin(math.radians(geom_mean_anom_sun)) *
                  math.cos(2 * math.radians(geom_mean_long_sun)) -
                  0.5 * (var_y ** 2) *
                  math.sin(4 * math.radians(geom_mean_long_sun)) -
                  1.25 * (eccent_orbit ** 2) *
                  math.sin(2 * math.radians(geom_mean_anom_sun))
              )
  
          return sol_dec, eq_of_time