feat: add search

kosmorro/__main__.py

@@ -21,8 +21,15 @@
 import os.path
 
 from babel.dates import format_date
-from kosmorrolib import Position, get_ephemerides, get_events, get_moon_phase
-from kosmorrolib.exceptions import OutOfRangeDateError
+from kosmorrolib import (
+    Position,
+    get_ephemerides,
+    get_events,
+    get_moon_phase,
+    search_events,
+)
+from kosmorrolib.exceptions import OutOfRangeDateError, InvalidDateRangeError
+from kosmorrolib.enum import EventType
 from datetime import date
 
 from . import dumper, environment, debug
@@ -37,6 +44,7 @@
 )
 from .exceptions import (
     InvalidOutputFormatError,
+    SearchDatesNotGivenError,
     UnavailableFeatureError,
     OutOfRangeDateError as DateRangeError,
 )
@@ -55,6 +63,8 @@ def run():
     if args.special_action is not None:
         return 0 if args.special_action() else 1
 
+    search_enabled = args.search is not None
+
     try:
         compute_date = parse_date(args.date)
     except ValueError as error:
@@ -105,14 +115,34 @@ def run():
     try:
         use_colors = not environment.NO_COLOR and args.colors
 
-        output = get_information(
-            compute_date,
-            position,
-            timezone,
-            output_format,
-            use_colors,
-            args.show_graph,
-        )
+        output = None
+        if search_enabled:
+            output = get_search_information(
+                args.search,
+                args.from_,
+                args.to,
+                timezone,
+                output_format,
+                use_colors,
+                args.show_graph,
+            )
+        else:
+            output = get_information(
+                compute_date,
+                position,
+                timezone,
+                output_format,
+                use_colors,
+                args.show_graph,
+            )
+    except SearchDatesNotGivenError as error:
+        print_stderr(colored(error.msg, "red"))
+        debug.debug_print(error)
+        return 5
+    except ValueError as error:
+        print_stderr(colored(error.args[0], color="red", attrs=["bold"]))
+        debug.debug_print(error)
+        return 4
     except InvalidOutputFormatError as error:
         print_stderr(colored(error.msg, "red"))
         debug.debug_print(error)
@@ -204,13 +234,61 @@ def get_information(
             timezone=timezone,
             with_colors=colors,
             show_graph=show_graph,
+            search_enabled=False,
         )
     except KeyError as error:
         raise InvalidOutputFormatError(output_format, list(get_dumpers().keys()))
     except OutOfRangeDateError as error:
         raise DateRangeError(error.min_date, error.max_date)
 
 
+def get_search_information(
+    requested_events: [EventType],
+    search_from: date,
+    search_to: date,
+    timezone: int,
+    output_format: str,
+    colors: bool,
+    show_graph: bool,
+) -> dumper.Dumper:
+    try:
+        if search_from is None or search_to is None:
+            raise SearchDatesNotGivenError
+
+        event_types = [EventType[event.upper()] for event in requested_events]
+        from_ = parse_date(search_from)
+        to = parse_date(search_to)
+        events_list = search_events(event_types, to, from_, timezone)
+
+        return get_dumpers()[output_format](
+            ephemerides=[],
+            moon_phase=None,
+            events=events_list,
+            date=None,
+            timezone=timezone,
+            with_colors=colors,
+            show_graph=show_graph,
+            search_enabled=True,
+        )
+    except InvalidDateRangeError as error:
+        print(
+            colored(
+                _(
+                    "Search start date {start_search} must be before end date {end_search}"
+                ).format(
+                    start_search=format_date(error.start_date, "long"),
+                    end_search=format_date(error.end_date, "long"),
+                ),
+                "red",
+            )
+        )
+    except KeyError as error:
+        raise InvalidOutputFormatError(output_format, list(get_dumpers().keys()))
+    except OutOfRangeDateError as error:
+        print(colored(error.msg, "red"))
+        debug.debug_print(error)
+
+
 def get_dumpers() -> {str: dumper.Dumper}:
     return {
         "txt": dumper.TextDumper,
@@ -308,6 +386,24 @@ def get_args(output_formats: [str]):
             "Can also be set in the KOSMORRO_TIMEZONE environment variable."
         ),
     )
+    parser.add_argument(
+        "--search",
+        "-s",
+        type=str,
+        nargs="*",
+        default=None,
+        help=_("Search for specific event types by date."),
+    )
+    parser.add_argument(
+        "--from",
+        dest="from_",
+        type=str,
+        default=None,
+        help=_("The date to begin searching for events."),
+    )
+    parser.add_argument(
+        "--to", type=str, default=None, help=_("The date to end searching for events.")
+    )
     parser.add_argument(
         "--no-colors",
         dest="colors",

kosmorro/dumper.py

@@ -25,7 +25,7 @@
 import shutil
 from pathlib import Path
 
-from babel.dates import format_date, format_time
+from babel.dates import format_date, format_time, format_datetime
 from tabulate import tabulate
 from termcolor import colored
 
@@ -60,6 +60,7 @@ def __init__(
         timezone: int,
         with_colors: bool,
         show_graph: bool,
+        search_enabled: bool,
     ):
         self.ephemerides = ephemerides
         self.moon_phase = moon_phase
@@ -68,6 +69,7 @@ def __init__(
         self.timezone = timezone
         self.with_colors = with_colors
         self.show_graph = show_graph
+        self.search_enabled = search_enabled
 
     def get_date_as_string(self, capitalized: bool = False) -> str:
         date = format_date(self.date, "full")
@@ -220,9 +222,10 @@ def get_events(self, events: [Event]) -> str:
             if description is None:
                 continue
 
+            date_format = "MMM dd, yyyy hh:mm a" if self.search_enabled else "hh:mm a"
             data.append(
                 [
-                    self.style(format_time(event.start_time, "short"), "th"),
+                    self.style(format_datetime(event.start_time, date_format), "th"),
                     description,
                 ]
             )

kosmorro/exceptions.py

@@ -40,6 +40,19 @@ def __init__(self, min_date: date, max_date: date):
         )
 
 
+class InvalidDateRangeError(RuntimeError):
+    def __init__(self, start_date: date, end_date: date):
+        super().__init__()
+        self.start_date = start_date
+        self.end_date = end_date
+        self.msg = _(
+            "The start date {starting_date} must be before the end date {ending_date}"
+        ).format(
+            starting_date=format_date(start_date, "long"),
+            ending_date=format_date(end_date, "long"),
+        )
+
+
 class InvalidOutputFormatError(RuntimeError):
     def __init__(self, output_format: str, accepted_extensions: [str]):
         super().__init__()
@@ -53,6 +66,14 @@ def __init__(self, output_format: str, accepted_extensions: [str]):
         )
 
 
+class SearchDatesNotGivenError(RuntimeError):
+    def __init__(self):
+        super().__init__()
+        self.msg = _(
+            "Both 'from' and 'to' dates are required when searching for events."
+        )
+
+
 class CompileError(RuntimeError):
     def __init__(self, msg):
         super().__init__()