fix: avoid returning ephemerides for yesterday or tomorrow

kosmorrolib/core.py

@@ -109,7 +109,6 @@ def get_offset(date_arg: str, signifier: str):
         months = get_offset(date_arg, 'm')
         years = get_offset(date_arg, 'y')
 
-
         if date_arg[0] == '+':
             return date.today() + relativedelta(days=days, months=months, years=years)
         return date.today() - relativedelta(days=days, months=months, years=years)

kosmorrolib/dateutil.py

@@ -0,0 +1,28 @@
+#!/usr/bin/env python3
+
+#    Kosmorro - Compute The Next Ephemerides
+#    Copyright (C) 2019  Jérôme Deuchnord <jerome@deuchnord.fr>
+#
+#    This program is free software: you can redistribute it and/or modify
+#    it under the terms of the GNU Affero General Public License as
+#    published by the Free Software Foundation, either version 3 of the
+#    License, or (at your option) any later version.
+#
+#    This program is distributed in the hope that it will be useful,
+#    but WITHOUT ANY WARRANTY; without even the implied warranty of
+#    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#    GNU Affero General Public License for more details.
+#
+#    You should have received a copy of the GNU Affero General Public License
+#    along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+from datetime import datetime, timezone, timedelta
+
+
+def translate_to_timezone(date: datetime, to_tz: int, from_tz: int = None):
+    if from_tz is not None:
+        source_tz = timezone(timedelta(hours=from_tz))
+    else:
+        source_tz = timezone.utc
+
+    return date.replace(tzinfo=source_tz).astimezone(tz=timezone(timedelta(hours=to_tz)))

kosmorrolib/dumper.py

@@ -52,39 +52,6 @@ def __init__(self, ephemerides: [AsterEphemerides] = None, moon_phase: MoonPhase
         self.with_colors = with_colors
         self.show_graph = show_graph
 
-        if self.timezone != 0:
-            self._convert_dates_to_timezones()
-
-    def _convert_dates_to_timezones(self):
-        if self.moon_phase.time is not None:
-            self.moon_phase.time = self._datetime_to_timezone(self.moon_phase.time)
-        if self.moon_phase.next_phase_date is not None:
-            self.moon_phase.next_phase_date = self._datetime_to_timezone(
-                self.moon_phase.next_phase_date)
-
-        if self.ephemerides is not None:
-            for ephemeris in self.ephemerides:
-                if ephemeris.rise_time is not None:
-                    ephemeris.rise_time = self._datetime_to_timezone(ephemeris.rise_time)
-                if ephemeris.culmination_time is not None:
-                    ephemeris.culmination_time = self._datetime_to_timezone(ephemeris.culmination_time)
-                if ephemeris.set_time is not None:
-                    ephemeris.set_time = self._datetime_to_timezone(ephemeris.set_time)
-
-        for event in self.events:
-            event.start_time = self._datetime_to_timezone(event.start_time)
-            if event.end_time is not None:
-                event.end_time = self._datetime_to_timezone(event.end_time)
-
-    def _datetime_to_timezone(self, time: datetime.datetime):
-        return time.replace(tzinfo=datetime.timezone.utc).astimezone(
-            tz=datetime.timezone(
-                datetime.timedelta(
-                    hours=self.timezone
-                )
-            )
-        )
-
     def get_date_as_string(self, capitalized: bool = False) -> str:
         date = self.date.strftime(FULL_DATE_FORMAT)
 
@@ -401,10 +368,6 @@ def _remove_section(document: str, section: str):
 
 
 class PdfDumper(Dumper):
-    def _convert_dates_to_timezones(self):
-        """This method is disabled in this dumper, because the timezone is already converted
-         in :class:`_LatexDumper`."""
-
     def to_string(self):
         try:
             latex_dumper = _LatexDumper(self.ephemerides, self.moon_phase, self.events,

kosmorrolib/ephemerides.py

@@ -23,6 +23,7 @@
 from skyfield.constants import tau
 
 from .data import Position, AsterEphemerides, MoonPhase, Object, ASTERS, skyfield_to_moon_phase
+from .dateutil import translate_to_timezone
 from .core import get_skf_objects, get_timescale, get_iau2000b
 
 RISEN_ANGLE = -0.8333
@@ -51,7 +52,7 @@ def moon_phase_at(time: Time):
     return skyfield_to_moon_phase(times, phase, today)
 
 
-def get_ephemerides(date: datetime.date, position: Position) -> [AsterEphemerides]:
+def get_ephemerides(date: datetime.date, position: Position, timezone: int = 0) -> [AsterEphemerides]:
     ephemerides = []
 
     def get_angle(for_aster: Object):
@@ -67,8 +68,8 @@ def fun(time: Time) -> bool:
         fun.rough_period = 0.5
         return fun
 
-    start_time = get_timescale().utc(date.year, date.month, date.day)
-    end_time = get_timescale().utc(date.year, date.month, date.day, 23, 59, 59)
+    start_time = get_timescale().utc(date.year, date.month, date.day, -timezone)
+    end_time = get_timescale().utc(date.year, date.month, date.day, 23 - timezone, 59, 59)
 
     for aster in ASTERS:
         rise_times, arr = find_discrete(start_time, end_time, is_risen(aster))
@@ -87,13 +88,16 @@ def fun(time: Time) -> bool:
 
         # Convert the Time instances to Python datetime objects
         if rise_time is not None:
-            rise_time = rise_time.utc_datetime().replace(microsecond=0)
+            rise_time = translate_to_timezone(rise_time.utc_datetime().replace(microsecond=0),
+                                              to_tz=timezone)
 
         if culmination_time is not None:
-            culmination_time = culmination_time.utc_datetime().replace(microsecond=0)
+            culmination_time = translate_to_timezone(culmination_time.utc_datetime().replace(microsecond=0),
+                                                     to_tz=timezone)
 
         if set_time is not None:
-            set_time = set_time.utc_datetime().replace(microsecond=0) if set_time is not None else None
+            set_time = translate_to_timezone(set_time.utc_datetime().replace(microsecond=0),
+                                             to_tz=timezone)
 
         ephemerides.append(AsterEphemerides(rise_time, culmination_time, set_time, aster=aster))
 

kosmorrolib/events.py

@@ -23,10 +23,11 @@
 from numpy import pi
 
 from .data import Event, Star, Planet, ASTERS
+from .dateutil import translate_to_timezone
 from .core import get_timescale, get_skf_objects, flatten_list
 
 
-def _search_conjunction(start_time: Time, end_time: Time) -> [Event]:
+def _search_conjunction(start_time: Time, end_time: Time, timezone: int) -> [Event]:
     earth = get_skf_objects()['earth']
     aster1 = None
     aster2 = None
@@ -65,16 +66,18 @@ def is_in_conjunction(time: Time):
                                            aster2] if aster1_pos.distance().km < aster2_pos.distance().km else [aster2,
                                                                                                                 aster1]
 
-                        conjunctions.append(Event('OCCULTATION', occulting_aster, time.utc_datetime()))
+                        conjunctions.append(Event('OCCULTATION', occulting_aster,
+                                                  translate_to_timezone(time.utc_datetime(), timezone)))
                     else:
-                        conjunctions.append(Event('CONJUNCTION', [aster1, aster2], time.utc_datetime()))
+                        conjunctions.append(Event('CONJUNCTION', [aster1, aster2],
+                                                  translate_to_timezone(time.utc_datetime(), timezone)))
 
         computed.append(aster1)
 
     return conjunctions
 
 
-def _search_oppositions(start_time: Time, end_time: Time) -> [Event]:
+def _search_oppositions(start_time: Time, end_time: Time, timezone: int) -> [Event]:
     earth = get_skf_objects()['earth']
     sun = get_skf_objects()['sun']
     aster = None
@@ -96,12 +99,12 @@ def is_oppositing(time: Time) -> [bool]:
 
         times, _ = find_discrete(start_time, end_time, is_oppositing)
         for time in times:
-            events.append(Event('OPPOSITION', [aster], time.utc_datetime()))
+            events.append(Event('OPPOSITION', [aster], translate_to_timezone(time.utc_datetime(), timezone)))
 
     return events
 
 
-def _search_maximal_elongations(start_time: Time, end_time: Time) -> [Event]:
+def _search_maximal_elongations(start_time: Time, end_time: Time, timezone: int) -> [Event]:
     earth = get_skf_objects()['earth']
     sun = get_skf_objects()['sun']
     aster = None
@@ -124,18 +127,18 @@ def get_elongation(time: Time):
 
         for i, time in enumerate(times):
             elongation = elongations[i]
-            events.append(Event('MAXIMAL_ELONGATION', [aster], time.utc_datetime(),
+            events.append(Event('MAXIMAL_ELONGATION', [aster], translate_to_timezone(time.utc_datetime(), timezone),
                                 details='{:.3n}°'.format(elongation)))
 
     return events
 
 
-def search_events(date: date_type) -> [Event]:
-    start_time = get_timescale().utc(date.year, date.month, date.day)
-    end_time = get_timescale().utc(date.year, date.month, date.day + 1)
+def search_events(date: date_type, timezone: int = 0) -> [Event]:
+    start_time = get_timescale().utc(date.year, date.month, date.day, -timezone)
+    end_time = get_timescale().utc(date.year, date.month, date.day + 1, -timezone)
 
     return sorted(flatten_list([
-        _search_oppositions(start_time, end_time),
-        _search_conjunction(start_time, end_time),
-        _search_maximal_elongations(start_time, end_time)
+        _search_oppositions(start_time, end_time, timezone),
+        _search_conjunction(start_time, end_time, timezone),
+        _search_maximal_elongations(start_time, end_time, timezone)
     ]), key=lambda event: event.start_time)