Exemplo n.º 1
0
    def year_7_month_6(self, month: List[BabylonianDay]) -> List[AbstractQuery]:
        res = []

        if self.mode == BM33066Mode.ALL or self.mode == BM33066Mode.LUNAR_SIX_ONLY:
            res.append(LunarSixQuery(self.db, month, 1, LunarSix.NA1, 15 + 2/3))
            res.append(LunarSixQuery(self.db, month, 13, LunarSix.SU2, 11))
            res.append(LunarSixQuery(self.db, month, 14, LunarSix.NA, 4))
            res.append(LunarSixQuery(self.db, month, 15, LunarSix.ME, 1 + 1/3))
            res.append(LunarSixQuery(self.db, month, 16, LunarSix.GI6, 8 + 2/3))
            res.append(LunarSixQuery(self.db, month, 28, LunarSix.KUR, 15))

        if self.mode == BM33066Mode.ALL or self.mode == BM33066Mode.PLANET_ONLY:
            res.append(PlanetaryEventQuery(self.db, JUPITER, OuterPlanetPhenomena.FA, SearchRange.for_night(month, 22)))
            res.append(AngularSeparationQuery(self.db, JUPITER, VIRGO.central_star, 0, VIRGO.radius,
                                              EclipticPosition.BEHIND, SearchRange.for_night(month, 22)))
            res.append(PlanetaryEventQuery(self.db, SATURN, OuterPlanetPhenomena.LA, SearchRange.for_night(month, 3)))
            res.append(AngularSeparationQuery(self.db, SATURN, VIRGO.central_star, 0, VIRGO.radius,
                                              None, SearchRange.for_night(month, 3)))
            res.append(PlanetaryEventQuery(self.db, MARS, OuterPlanetPhenomena.FA, SearchRange.for_night(month, 13)))
            res.append(AngularSeparationQuery(self.db, MARS, LEO.central_star, 0, LEO.radius,
                                              None, SearchRange.for_night(month, 13)))

            #  Month VI, the 24th, Venus was 1 +[x cubits?] above Mars.
            res.append(AngularSeparationQuery(self.db, VENUS, MARS, 1 * CUBIT, 5 * CUBIT,
                                              EclipticPosition.ABOVE, SearchRange.for_night(month, 24)))

        return res
Exemplo n.º 2
0
    def month_a(self, month: List[BabylonianDay]) -> List[AbstractQuery]:
        res = []
        day14 = SearchRange.for_night(month, 14)
        # Mercury's last appearance in the east behind Pisces
        res.append(
            PlanetaryEventQuery(self.db, MERCURY, InnerPlanetPhenomena.ML,
                                day14))
        res.append(
            AngularSeparationQuery(self.db, MERCURY, PISCES.central_star, 0,
                                   PISCES.radius, None, day14))
        # Saturn's last appearance behind Pisces
        res.append(
            PlanetaryEventQuery(self.db, SATURN, OuterPlanetPhenomena.LA,
                                day14))
        res.append(
            AngularSeparationQuery(self.db, SATURN, PISCES.central_star, 0,
                                   PISCES.radius, EclipticPosition.BEHIND,
                                   day14))

        day17 = SearchRange.for_night(month, 17)
        # Mars became stationary
        res.append(
            PlanetaryEventQuery(self.db, MARS, OuterPlanetPhenomena.ST, day17))
        # it came close to the bright star of the Scorpion's head
        res.append(
            AngularSeparationQuery(self.db, MARS, ANTARES, 0, 10, None, day17))

        return res
Exemplo n.º 3
0
    def year_8_month_5(self, month: List[BabylonianDay]) -> List[AbstractQuery]:
        res = []

        if self.mode == BM33066Mode.ALL or self.mode == BM33066Mode.PLANET_ONLY:
            res.append(PlanetaryEventQuery(self.db, SATURN, OuterPlanetPhenomena.LA, SearchRange.for_night(month, 29)))
            res.append(PlanetaryEventQuery(self.db, MARS, OuterPlanetPhenomena.ST, SearchRange.for_night(month, 12)))

        return res
Exemplo n.º 4
0
 def year_14_month_a(self,
                     month: List[BabylonianDay]) -> List[AbstractQuery]:
     range = SearchRange.any_day(month)
     return [
         PlanetaryEventQuery(self.db, SATURN, OuterPlanetPhenomena.LA,
                             range)
     ]
Exemplo n.º 5
0
    def year_7_month_7(self, month: List[BabylonianDay]) -> List[AbstractQuery]:
        res = []

        if self.mode == BM33066Mode.ALL or self.mode == BM33066Mode.LUNAR_SIX_ONLY:
            res.append(LunarSixQuery(self.db, month, 1, LunarSix.NA1, 16 + 2/3))
            res.append(LunarSixQuery(self.db, month, 13, LunarSix.SU2, 6.5))
            res.append(LunarSixQuery(self.db, month, 14, LunarSix.ME, 7.5))
            res.append(LunarSixQuery(self.db, month, 14, LunarSix.NA, 12))
            res.append(LunarSixQuery(self.db, month, 15, LunarSix.GI6, 3))
            res.append(LunarSixQuery(self.db, month, 26, LunarSix.KUR, 22))

        if self.mode == BM33066Mode.ALL or self.mode == BM33066Mode.PLANET_ONLY:
            res.append(PlanetaryEventQuery(self.db, SATURN, OuterPlanetPhenomena.FA, SearchRange.for_night(month, 13)))
            res.append(AngularSeparationQuery(self.db, SATURN, VIRGO.central_star, 0, VIRGO.radius,
                                              EclipticPosition.BEHIND, SearchRange.for_night(month, 13)))

            # Month VII, the 23rd, last part of the night, Jupiter was 3 cubits above the moon.
            res.append(AngularSeparationQuery(self.db, JUPITER, MOON, 3 * CUBIT, 1 * CUBIT,
                                              EclipticPosition.ABOVE, SearchRange.for_night(month, 23)))

            # Month VII, the 29th, last part of the night, Venus on the north side [came near?] 2 fingers to Ju[piter].
            res.append(AngularSeparationQuery(self.db, VENUS, JUPITER, 2 * FINGER, 4 * FINGER,
                                              None, SearchRange.for_night(month, 29)))

            # Month VII, the 12th, Saturn was 1 cubit in front of Jupiter.
            res.append(AngularSeparationQuery(self.db, SATURN, JUPITER, 1 * CUBIT, 6 * FINGER,
                                              EclipticPosition.AHEAD, SearchRange.for_night(month, 12)))

            # Month VII, the 11th, Mars came near to Jupiter 2 fingers.
            res.append(AngularSeparationQuery(self.db, MARS, JUPITER, 2 * FINGER, 2 * FINGER,
                                              None, SearchRange.for_night(month, 11)))

        return res
Exemplo n.º 6
0
    def month_b(self, month: List[BabylonianDay]) -> List[AbstractQuery]:
        res = []
        day5 = SearchRange.for_night(month, 5)
        # Mercury's first appearance in the east in Pisces
        res.append(
            PlanetaryEventQuery(self.db, MERCURY, InnerPlanetPhenomena.MF,
                                day5))
        res.append(
            AngularSeparationQuery(self.db, MERCURY, PISCES.central_star, 0,
                                   PISCES.radius, None, day5))

        day19 = SearchRange.for_night(month, 19)
        # Venus stood in the region of Aries, 10 fingers behind Mars
        res.append(
            AngularSeparationQuery(self.db, VENUS, MARS, 10 * FINGER,
                                   10 * FINGER, EclipticPosition.BEHIND,
                                   day19))
        res.append(
            AngularSeparationQuery(self.db, MARS, ARIES.central_star, 0,
                                   ARIES.radius, None, day19))

        day20 = SearchRange.for_night(month, 20)
        # Mars was 1 finger to the left of the front? of Aries
        res.append(
            AngularSeparationQuery(self.db, MARS, ARIES.central_star, 0,
                                   ARIES.radius, None, day20))

        return res
Exemplo n.º 7
0
 def year_4_month_4(self,
                    month: List[BabylonianDay]) -> List[AbstractQuery]:
     range = SearchRange.for_night(month, 29)
     return [
         PlanetaryEventQuery(self.db, SATURN, OuterPlanetPhenomena.LA,
                             range)
     ]
Exemplo n.º 8
0
    def year_37_month_2(self, month: List[BabylonianDay]) -> List[AbstractQuery]:
        res = []

        # Sîn (Moon) appeared below the Rear Bright Star of the Large Twins (β Geminorum)
        if self.mode == VAT4956Mode.ALL or self.mode == VAT4956Mode.LUNAR_ONLY:
            res.append(AngularSeparationQuery(self.db, MOON, BETA_GEMINORUM, 0, 15,
                                              EclipticPosition.BELOW, SearchRange.for_night(month, 1)))

        # Kajjamānu (Saturn) was in front of the Swallow (Pisces).
        if self.mode == VAT4956Mode.ALL or self.mode == VAT4956Mode.PLANET_ONLY:
            res.append(AngularSeparationQuery(self.db, SATURN, PISCES.central_star, 0, PISCES.radius,
                                              EclipticPosition.AHEAD, SearchRange.for_night(month, 1)))

        # The 3rd, Ṣalbaṭānu (Mars) entered the Crab (Praesepe), the 5th it emerged.
        if self.mode == VAT4956Mode.ALL or self.mode == VAT4956Mode.PLANET_ONLY:
            res.append(AngularSeparationQuery(self.db, MARS, FORTY_TWO_CANCRI, 0, 5,
                                              None, SearchRange.range_of_nights(month, 3, 5)))

        # The 10th, Šiḫṭu (Mercury) [rose] in the west behind the [Little] Twins [...] (Gemini)
        if self.mode == VAT4956Mode.ALL or self.mode == VAT4956Mode.PLANET_ONLY:
            res.append(PlanetaryEventQuery(self.db, MERCURY, InnerPlanetPhenomena.EF,
                                           SearchRange.for_night_and_day(month, 10)))
            res.append(AngularSeparationQuery(self.db, MERCURY, GEMINI.central_star, 0, GEMINI.radius,
                                              None, SearchRange.for_night_and_day(month, 10)))

        # The 18th, Dilbat (Venus) was ‘balanced’ 1 cubit 4 fingers above the King (Regulus).
        if self.mode == VAT4956Mode.ALL or self.mode == VAT4956Mode.PLANET_ONLY:
            res.append(AngularSeparationQuery(self.db, VENUS, REGULUS, (1 * CUBIT) + (4 * FINGER),
                                              8 * CUBIT, EclipticPosition.ABOVE, SearchRange.for_night(month, 18)))

        #  The 26th (KUR) (moonrise to sunrise) was 23, I did not observe Sîn.
        if self.mode == VAT4956Mode.ALL or self.mode == VAT4956Mode.LUNAR_SIX_ONLY:
            res.append(LunarSixQuery(self.db, month, 26, LunarSix.KUR, 23, low_precision=True))

        return res
Exemplo n.º 9
0
    def year_37_month_1(self, month: List[BabylonianDay]) -> List[AbstractQuery]:
        res = []

        # Sîn (Moon) appeared behind the Bull of Heaven (Taurus)
        if self.mode == VAT4956Mode.ALL or self.mode == VAT4956Mode.LUNAR_ONLY:
            res.append(AngularSeparationQuery(self.db, MOON, TAURUS.central_star, 0, TAURUS.radius,
                                              EclipticPosition.BEHIND, SearchRange.for_night(month, 1)))

        # Kajjamānu (Saturn) was in front of the Swallow (Pisces).
        if self.mode == VAT4956Mode.ALL or self.mode == VAT4956Mode.PLANET_ONLY:
            res.append(AngularSeparationQuery(self.db, SATURN, PISCES.central_star, 0, PISCES.radius,
                                              EclipticPosition.AHEAD, SearchRange.for_night(month, 1)))

        # the 9th, beginning of the night, Sîn (Moon) stood 1 cubit in front of the Rear Foot of the Lion (β Virginis).
        if self.mode == VAT4956Mode.ALL or self.mode == VAT4956Mode.LUNAR_ONLY:
            res.append(AngularSeparationQuery(self.db, MOON, BETA_VIRGINIS, 1 * CUBIT, 6 * FINGER,
                                              EclipticPosition.AHEAD, SearchRange.for_night(month, 9)))

        #  The 11th] or the 12th Sagmegar (Jupiter) ‘rose to daylight’ (AR).
        if self.mode == VAT4956Mode.ALL or self.mode == VAT4956Mode.PLANET_ONLY:
            res.append(PlanetaryEventQuery(self.db, JUPITER, OuterPlanetPhenomena.AR,
                                           SearchRange.range_of_nights(month, 11, 12)))

        #  NA (sunrise to moonset) was 4.
        if self.mode == VAT4956Mode.ALL or self.mode == VAT4956Mode.LUNAR_SIX_ONLY:
            res.append(LunarSixQuery(self.db, month, 14, LunarSix.NA, 4.0))

        return res
Exemplo n.º 10
0
 def year_7_month_6(self,
                    month: List[BabylonianDay]) -> List[AbstractQuery]:
     range = SearchRange.x_plus(month, 10)
     return [
         PlanetaryEventQuery(self.db, SATURN, OuterPlanetPhenomena.LA,
                             range)
     ]
Exemplo n.º 11
0
 def year_2_month_5(self,
                    month: List[BabylonianDay]) -> List[AbstractQuery]:
     any_day = SearchRange.any_day(month)
     res1 = PlanetaryEventQuery(self.db, SATURN, OuterPlanetPhenomena.FA,
                                any_day)
     res2 = AngularSeparationQuery(self.db, SATURN, EPSILON_LEONIS, 0, 20,
                                   None, any_day)
     return [res1, res2]
Exemplo n.º 12
0
 def year_4_month_unknown(
         self, month: List[BabylonianDay]) -> List[AbstractQuery]:
     range = SearchRange.any_day(month)
     res1 = PlanetaryEventQuery(self.db, SATURN, OuterPlanetPhenomena.FA,
                                range)
     res2 = AngularSeparationQuery(self.db, SATURN, LEO.central_star, 0,
                                   LEO.radius, None, range)
     return [res1, res2]
Exemplo n.º 13
0
 def year_10_month_a(self,
                     month: List[BabylonianDay]) -> List[AbstractQuery]:
     range = SearchRange.for_night(month, 20)
     res1 = PlanetaryEventQuery(self.db, SATURN, OuterPlanetPhenomena.LA,
                                range)
     res2 = AngularSeparationQuery(self.db, SATURN, LIBRA.central_star, 0,
                                   LIBRA.radius, None, range)
     return [res1, res2]
Exemplo n.º 14
0
 def year_3_month_5(self,
                    month: List[BabylonianDay]) -> List[AbstractQuery]:
     range = SearchRange.for_night(month, 16)
     res1 = PlanetaryEventQuery(self.db, SATURN, OuterPlanetPhenomena.FA,
                                range)
     res2 = AngularSeparationQuery(self.db, SATURN, REGULUS, 0, 20,
                                   EclipticPosition.BEHIND, range)
     return [res1, res2]
Exemplo n.º 15
0
 def year_11_month_unknown(
         self, month: List[BabylonianDay]) -> List[AbstractQuery]:
     range = SearchRange.any_day(month)
     res1 = PlanetaryEventQuery(self.db, SATURN, OuterPlanetPhenomena.FA,
                                range)
     res2 = AngularSeparationQuery(self.db, SATURN, ANTARES, 0, 20,
                                   EclipticPosition.ABOVE, range)
     return [res1, res2]
Exemplo n.º 16
0
 def year_10_month_b(self,
                     month: List[BabylonianDay]) -> List[AbstractQuery]:
     range = SearchRange.for_night(month, 23)
     res1 = PlanetaryEventQuery(self.db, SATURN, OuterPlanetPhenomena.FA,
                                range)
     res2 = AngularSeparationQuery(self.db, SATURN, ANTARES, 0, 20,
                                   EclipticPosition.AHEAD, range)
     return [res1, res2]
Exemplo n.º 17
0
    def year_8_month_1(self, month: List[BabylonianDay]) -> List[AbstractQuery]:
        res = []

        if self.mode == BM33066Mode.ALL or self.mode == BM33066Mode.PLANET_ONLY:
            res.append(PlanetaryEventQuery(self.db, VENUS, InnerPlanetPhenomena.EF, SearchRange.for_night(month, 13)))
            res.append(AngularSeparationQuery(self.db, VENUS, AURIGA.central_star, 0, AURIGA.radius,
                                              None, SearchRange.for_night(month, 13)))

        return res
Exemplo n.º 18
0
    def year_9_month_2(self, month: List[BabylonianDay]) -> List[AbstractQuery]:
        res = []

        if self.mode == BM33066Mode.ALL or self.mode == BM33066Mode.PLANET_ONLY:
            res.append(PlanetaryEventQuery(self.db, MARS, OuterPlanetPhenomena.LA, SearchRange.for_night(month, 9)))
            res.append(AngularSeparationQuery(self.db, MARS, REGULUS, 0, 15,
                                              EclipticPosition.BEHIND, SearchRange.for_night(month, 9)))

        return res
Exemplo n.º 19
0
    def year_8_month_6(self, month: List[BabylonianDay]) -> List[AbstractQuery]:
        res = []

        if self.mode == BM33066Mode.ALL or self.mode == BM33066Mode.PLANET_ONLY:
            res.append(PlanetaryEventQuery(self.db, JUPITER, OuterPlanetPhenomena.LA, SearchRange.for_night(month, 4)))
            res.append(AngularSeparationQuery(self.db, JUPITER, LIBRA.central_star, 0, LIBRA.radius,
                                              EclipticPosition.BEHIND, SearchRange.for_night(month, 4)))

        return res
Exemplo n.º 20
0
    def year_8_month_2(self, month: List[BabylonianDay]) -> List[AbstractQuery]:
        res = []

        if self.mode == BM33066Mode.ALL or self.mode == BM33066Mode.PLANET_ONLY:
            res.append(PlanetaryEventQuery(self.db, JUPITER, OuterPlanetPhenomena.ST, SearchRange.for_night(month, 25)))
            res.append(AngularSeparationQuery(self.db, JUPITER, VIRGO.central_star, 0, VIRGO.radius,
                                              None, SearchRange.for_night(month, 25)))

        return res
Exemplo n.º 21
0
 def shamash_14_xii(self,
                    month: List[BabylonianDay]) -> List[AbstractQuery]:
     day4 = SearchRange.for_night(month, 4)
     # Mercury's first appearance in the west
     res1 = PlanetaryEventQuery(self.db, MERCURY, InnerPlanetPhenomena.EF,
                                day4)
     # in the area of the Swallow.
     res2 = AngularSeparationQuery(self.db, MERCURY, PISCES.central_star, 0,
                                   PISCES.radius, None, day4)
     return [res1, res2]
Exemplo n.º 22
0
    def year_7_month_3(self, month: List[BabylonianDay]) -> List[AbstractQuery]:
        res = []

        if self.mode == BM33066Mode.ALL or self.mode == BM33066Mode.LUNAR_SIX_ONLY:
            res.append(LunarSixQuery(self.db, month, 1, LunarSix.NA1, 18.5))
            res.append(LunarSixQuery(self.db, month, 14, LunarSix.ME, 9.5))
            res.append(LunarSixQuery(self.db, month, 14, LunarSix.SU2, 4))
            res.append(LunarSixQuery(self.db, month, 15, LunarSix.GI6, 5))
            res.append(LunarSixQuery(self.db, month, 15, LunarSix.NA, 8.5))
            res.append(LunarSixQuery(self.db, month, 27, LunarSix.KUR, 15))

        if self.mode == BM33066Mode.ALL or self.mode == BM33066Mode.PLANET_ONLY:
            res.append(PlanetaryEventQuery(self.db, VENUS, InnerPlanetPhenomena.EL, SearchRange.for_night(month, 10)))
            res.append(AngularSeparationQuery(self.db, VENUS, LEO.central_star, 0, LEO.radius,
                                              None, SearchRange.for_night(month, 10)))
            res.append(PlanetaryEventQuery(self.db, VENUS, InnerPlanetPhenomena.MF, SearchRange.for_night(month, 27)))
            res.append(AngularSeparationQuery(self.db, VENUS, CANCER.central_star, 0, CANCER.radius,
                                              None, SearchRange.for_night(month, 27)))


        return res
Exemplo n.º 23
0
    def year_7_month_2(self, month: List[BabylonianDay]) -> List[AbstractQuery]:
        res = []

        if self.mode == BM33066Mode.ALL or self.mode == BM33066Mode.LUNAR_SIX_ONLY:
            res.append(LunarSixQuery(self.db, month, 1, LunarSix.NA1, 23))
            res.append(LunarSixQuery(self.db, month, 13, LunarSix.SU2, 8 + 2/3))
            res.append(LunarSixQuery(self.db, month, 14, LunarSix.ME, 1))
            res.append(LunarSixQuery(self.db, month, 14, LunarSix.NA, 1 + 2/3))
            res.append(LunarSixQuery(self.db, month, 15, LunarSix.GI6, 14.5))
            res.append(LunarSixQuery(self.db, month, 27, LunarSix.KUR, 21))

        if self.mode == BM33066Mode.ALL or self.mode == BM33066Mode.PLANET_ONLY:
            res.append(PlanetaryEventQuery(self.db, MARS, OuterPlanetPhenomena.LA, SearchRange.for_night(month, 28)))
            res.append(AngularSeparationQuery(self.db, MARS, GEMINI.central_star, 0, GEMINI.radius,
                                              EclipticPosition.AHEAD, SearchRange.for_night(month, 28)))

        return res
Exemplo n.º 24
0
    def year_7_month_5(self, month: List[BabylonianDay]) -> List[AbstractQuery]:
        res = []

        if self.mode == BM33066Mode.ALL or self.mode == BM33066Mode.LUNAR_SIX_ONLY:
            res.append(LunarSixQuery(self.db, month, 1, LunarSix.NA1, 10, low_precision=True))
            res.append(LunarSixQuery(self.db, month, 14, LunarSix.SU2, 3.5))
            res.append(LunarSixQuery(self.db, month, 15, LunarSix.ME, 2.5, low_precision=True))
            res.append(LunarSixQuery(self.db, month, 15, LunarSix.NA, 11))
            res.append(LunarSixQuery(self.db, month, 16, LunarSix.GI6, 7.5))
            res.append(LunarSixQuery(self.db, month, 27, LunarSix.KUR, 22.5))

        if self.mode == BM33066Mode.ALL or self.mode == BM33066Mode.PLANET_ONLY:
            res.append(PlanetaryEventQuery(self.db, JUPITER, OuterPlanetPhenomena.LA, SearchRange.for_night(month, 22)))
            res.append(AngularSeparationQuery(self.db, JUPITER, VIRGO.central_star, 0, VIRGO.radius,
                                              EclipticPosition.AHEAD, SearchRange.for_night(month, 22)))

        return res
Exemplo n.º 25
0
    def year_7_month_12(self, month: List[BabylonianDay]) -> List[AbstractQuery]:
        res = []

        if self.mode == BM33066Mode.ALL or self.mode == BM33066Mode.LUNAR_SIX_ONLY:
            res.append(LunarSixQuery(self.db, month, 1, LunarSix.NA1, 15.5))
            res.append(LunarSixQuery(self.db, month, 12, LunarSix.SU2, 10.5))
            res.append(LunarSixQuery(self.db, month, 13, LunarSix.ME, 5 + 1/3))
            res.append(LunarSixQuery(self.db, month, 14, LunarSix.GI6, 10))
            res.append(LunarSixQuery(self.db, month, 25, LunarSix.KUR, 23))
            res.append(LunarSixQuery(self.db, month, 27, LunarSix.KUR, 12))

        if self.mode == BM33066Mode.ALL or self.mode == BM33066Mode.PLANET_ONLY:
            res.append(PlanetaryEventQuery(self.db, VENUS, InnerPlanetPhenomena.ML, SearchRange.for_night(month, 7)))
            res.append(AngularSeparationQuery(self.db, VENUS, PISCES.central_star, 0, PISCES.radius,
                                              None, SearchRange.for_night(month, 7)))

        return res
Exemplo n.º 26
0
    def year_7_month_10(self, month: List[BabylonianDay]) -> List[AbstractQuery]:
        res = []

        if self.mode == BM33066Mode.ALL or self.mode == BM33066Mode.ECLIPSE_ONLY:
            t = (2 + 1 / 2) * 30
            res.append(LunarEclipseQuery(self.db, FirstContactTime(t, FirstContactRelative.BEFORE_SUNRISE),
                                         ExpectedEclipseType.TOTAL, None, None,
                                         SearchRange.for_night(month, 14)))

        if self.mode == BM33066Mode.ALL or self.mode == BM33066Mode.PLANET_ONLY:
            res.append(PlanetaryEventQuery(self.db, JUPITER, OuterPlanetPhenomena.ST, SearchRange.for_night(month, 27)))
            res.append(AngularSeparationQuery(self.db, JUPITER, LIBRA.central_star, 0, LIBRA.radius,
                                              EclipticPosition.AHEAD, SearchRange.for_night(month, 27)))

            # Month X, the 5th, Mercury was ½ cubit behind Venus.
            res.append(AngularSeparationQuery(self.db, MERCURY, VENUS, 0.5 * CUBIT, 0.5 * CUBIT,
                                              EclipticPosition.BEHIND, SearchRange.for_night(month, 5)))

        return res