pysportbot 0.0.5__py3-none-any.whl → 0.0.7__py3-none-any.whl

pysportbot/activities.py

@@ -92,7 +92,7 @@ class Activities:
             logger.warning(warning_msg)
             return DataFrame()
 
-        logger.info(f"Daily slots fetched for '{activity_name}' on {day}.")
+        logger.debug(f"Daily slots fetched for '{activity_name}' on {day}.")
 
         # Filter desired columns
         columns = [

pysportbot/service/__main__.py

@@ -10,11 +10,9 @@ from .service import run_service
 def main() -> None:
     parser = argparse.ArgumentParser(description="Run the pysportbot as a service.")
     parser.add_argument("--config", type=str, required=True, help="Path to the JSON configuration file.")
-    parser.add_argument("--offset-seconds", type=int, default=10, help="Time offset in seconds before booking.")
-    parser.add_argument("--retry-attempts", type=int, default=3, help="Number of retry attempts for weekly bookings.")
-    parser.add_argument(
-        "--retry-delay-minutes", type=int, default=2, help="Delay in minutes between retries for weekly bookings."
-    )
+    parser.add_argument("--booking-delay", type=int, default=5, help="Global booking delay in seconds before booking.")
+    parser.add_argument("--retry-attempts", type=int, default=3, help="Number of retry attempts for bookings.")
+    parser.add_argument("--retry-delay", type=int, default=30, help="Delay in seconds between retries for bookings.")
     parser.add_argument("--time-zone", type=str, default="Europe/Madrid", help="Timezone for the service.")
     parser.add_argument("--log-level", type=str, default="INFO", help="Logging level for the service.")
     args = parser.parse_args()
@@ -22,9 +20,9 @@ def main() -> None:
     config: Dict[str, Any] = load_config(args.config)
     run_service(
         config,
-        offset_seconds=args.offset_seconds,
+        booking_delay=args.booking_delay,
         retry_attempts=args.retry_attempts,
-        retry_delay_minutes=args.retry_delay_minutes,
+        retry_delay=args.retry_delay,
         time_zone=args.time_zone,
         log_level=args.log_level,
     )

pysportbot/service/booking.py

@@ -1,147 +1,157 @@
 import time
-from datetime import datetime, timedelta
-from typing import Any, Dict
+from concurrent.futures import ThreadPoolExecutor, as_completed
+from datetime import datetime
+from typing import Any, Dict, List
 
 import pytz
-import schedule
 
 from pysportbot import SportBot
 from pysportbot.utils.errors import ErrorMessages
 from pysportbot.utils.logger import get_logger
 
-from .config_validator import DAY_MAP
 from .scheduling import calculate_class_day, calculate_next_execution
 
 logger = get_logger(__name__)
 
 
 def _raise_no_matching_slots_error(activity: str, class_time: str, booking_date: str) -> None:
+    raise ValueError(ErrorMessages.no_matching_slots_for_time(activity, class_time, booking_date))
+
+
+def wait_for_execution(booking_execution: str, time_zone: str) -> None:
     """
-    Helper function to raise a ValueError for no matching slots.
+    Wait until the specified global execution time.
+
+    Args:
+        booking_execution (str): Global execution time in "Day HH:MM:SS" format.
+        time_zone (str): Timezone for calculation.
     """
-    raise ValueError(ErrorMessages.no_matching_slots_for_time(activity, class_time, booking_date))
+    tz = pytz.timezone(time_zone)
+    execution_time = calculate_next_execution(booking_execution, time_zone)
+    now = datetime.now(tz)
+    time_until_execution = (execution_time - now).total_seconds()
+
+    if time_until_execution > 0:
+        logger.info(
+            f"Waiting {time_until_execution:.2f} seconds until global execution time: "
+            f"{execution_time.strftime('%Y-%m-%d %H:%M:%S %z')}."
+        )
+        time.sleep(time_until_execution)
 
 
 def attempt_booking(
     bot: SportBot,
-    cls: Dict[str, Any],
-    offset_seconds: int,
+    activity: str,
+    class_day: str,
+    class_time: str,
+    booking_delay: int,
     retry_attempts: int = 1,
-    retry_delay_minutes: int = 0,
+    retry_delay: int = 0,
     time_zone: str = "Europe/Madrid",
 ) -> None:
-    activity = cls["activity"]
-    class_day = cls["class_day"]
-    class_time = cls["class_time"]
-    booking_execution = cls["booking_execution"]
-
+    """
+    Attempt to book a slot for the given class.
+
+    Args:
+        bot (SportBot): The SportBot instance.
+        activity (str): Activity name.
+        class_day (str): Day of the class.
+        class_time (str): Time of the class.
+        booking_delay (int): Delay before attempting booking.
+        retry_attempts (int): Number of retry attempts.
+        retry_delay (int): Delay between retries.
+        time_zone (str): Time zone for execution.
+    """
     for attempt_num in range(1, retry_attempts + 1):
         booking_date = calculate_class_day(class_day, time_zone).strftime("%Y-%m-%d")
 
         try:
-            logger.info(f"Fetching available slots for {activity} on {booking_date}")
+            logger.info(f"Fetching available slots for '{activity}' on {booking_date}.")
             available_slots = bot.daily_slots(activity=activity, day=booking_date)
 
             matching_slots = available_slots[available_slots["start_timestamp"] == f"{booking_date} {class_time}"]
             if matching_slots.empty:
                 _raise_no_matching_slots_error(activity, class_time, booking_date)
 
-            if booking_execution != "now":
-                logger.info(f"Waiting {offset_seconds} seconds before attempting booking.")
-                time.sleep(offset_seconds)
-
             slot_id = matching_slots.iloc[0]["start_timestamp"]
-            logger.info(f"Attempting to book slot for {activity} at {slot_id} (Attempt {attempt_num}/{retry_attempts})")
+            logger.info(f"Attempting to book '{activity}' at {slot_id} (Attempt {attempt_num}/{retry_attempts}).")
             bot.book(activity=activity, start_time=slot_id)
-            logger.info(f"Successfully booked {activity} at {slot_id}")
 
         except Exception as e:
             error_str = str(e)
-            logger.warning(f"Attempt {attempt_num} failed for {activity}: {error_str}")
+            logger.warning(f"Attempt {attempt_num} failed: {error_str}")
 
             if ErrorMessages.slot_already_booked() in error_str:
-                logger.warning(f"{activity} at {class_time} on {booking_date} is already booked; skipping retry.")
+                logger.warning("Slot already booked; skipping further retries.")
                 return
 
             if attempt_num < retry_attempts:
-                logger.info(f"Retrying in {retry_delay_minutes} minutes...")
-                time.sleep(retry_delay_minutes * 60)
+                logger.info(f"Retrying in {retry_delay} seconds...")
+                time.sleep(retry_delay)
         else:
+            # If the booking attempt succeeds, log and exit
+            logger.info(f"Successfully booked '{activity}' at {slot_id}.")
             return
 
-    logger.error(f"Failed to book {activity} after {retry_attempts} attempts.")
+    # If all attempts fail, log an error
+    logger.error(f"Failed to book '{activity}' after {retry_attempts} attempts.")
 
 
 def schedule_bookings(
     bot: SportBot,
-    config: Dict[str, Any],
-    cls: Dict[str, Any],
-    offset_seconds: int,
+    classes: List[Dict[str, Any]],
+    booking_execution: str,
+    booking_delay: int,
     retry_attempts: int,
-    retry_delay_minutes: int,
-    time_zone: str = "Europe/Madrid",
+    retry_delay: int,
+    time_zone: str,
+    max_threads: int,
 ) -> None:
-    booking_execution = cls["booking_execution"]
-    weekly = cls["weekly"]
-    activity = cls["activity"]
-    class_day = cls["class_day"]
-    class_time = cls["class_time"]
-
-    if weekly:
-        # For weekly bookings, schedule recurring jobs
-        execution_day, execution_time = booking_execution.split()
-        logger.info(
-            f"Class '{activity}' on {class_day} at {class_time} "
-            f"will be booked every {execution_day} at {execution_time}."
-        )
-
-        def booking_task() -> None:
+    """
+    Execute bookings in parallel with a limit on the number of threads.
+
+    Args:
+        bot (SportBot): The SportBot instance.
+        classes (list): List of class configurations.
+        booking_execution (str): Global execution time for all bookings.
+        booking_delay (int): Delay before each booking attempt.
+        retry_attempts (int): Number of retry attempts.
+        retry_delay (int): Delay between retries.
+        time_zone (str): Timezone for booking.
+        max_threads (int): Maximum number of threads to use.
+    """
+    # Log planned bookings
+    for cls in classes:
+        logger.info(f"Scheduled to book '{cls['activity']}' next {cls['class_day']} at {cls['class_time']}.")
+
+    # Wait globally before starting bookings
+    wait_for_execution(booking_execution, time_zone)
+
+    # Global booking delay
+    logger.info(f"Waiting {booking_delay} seconds before attempting booking.")
+    time.sleep(booking_delay)
+
+    with ThreadPoolExecutor(max_workers=max_threads) as executor:
+        future_to_class = {
+            executor.submit(
+                attempt_booking,
+                bot,
+                cls["activity"],
+                cls["class_day"],
+                cls["class_time"],
+                booking_delay,
+                retry_attempts,
+                retry_delay,
+                time_zone,
+            ): cls
+            for cls in classes
+        }
+
+        for future in as_completed(future_to_class):
+            cls = future_to_class[future]
+            activity, class_time = cls["activity"], cls["class_time"]
             try:
-                logger.info("Re-authenticating before weekly booking...")
-                bot.login(config["email"], config["password"], config["centre"])
-                logger.info("Re-authentication successful.")
-                attempt_booking(
-                    bot,
-                    cls,
-                    offset_seconds,
-                    retry_attempts,
-                    retry_delay_minutes,
-                    time_zone,
-                )
+                future.result()
+                logger.info(f"Booking for '{activity}' at {class_time} completed successfully.")
             except Exception:
-                logger.exception(f"Failed to execute weekly booking task for {activity}")
-
-        # e.g., schedule.every().monday.at("HH:MM:SS").do(...)
-        getattr(schedule.every(), execution_day.lower()).at(execution_time).do(booking_task)
-
-    else:
-        # For one-off (non-weekly) bookings, calculate exact date/time
-        next_execution = calculate_next_execution(booking_execution, time_zone)
-        tz = pytz.timezone(time_zone)
-
-        day_of_week_target = DAY_MAP[class_day.lower().strip()]
-        execution_day_of_week = next_execution.weekday()
-
-        days_to_class = (day_of_week_target - execution_day_of_week + 7) % 7
-        planned_class_date_dt = next_execution + timedelta(days=days_to_class)
-        planned_class_date_str = planned_class_date_dt.strftime("%Y-%m-%d (%A)")
-
-        next_execution_str = next_execution.strftime("%Y-%m-%d (%A) %H:%M:%S %z")
-
-        logger.info(
-            f"Class '{activity}' on {planned_class_date_str} at {class_time} "
-            f"will be booked on {next_execution_str}."
-        )
-
-        # Wait until the next execution time
-        time_until_execution = (next_execution - datetime.now(tz)).total_seconds()
-        time.sleep(max(0, time_until_execution))
-
-        attempt_booking(
-            bot,
-            cls,
-            offset_seconds,
-            retry_attempts=retry_attempts,
-            retry_delay_minutes=retry_delay_minutes,
-            time_zone=time_zone,
-        )
+                logger.exception(f"Booking for '{activity}' at {class_time} failed.")

pysportbot/service/config_validator.py

@@ -11,36 +11,54 @@ DAY_MAP = {"monday": 0, "tuesday": 1, "wednesday": 2, "thursday": 3, "friday": 4
 
 
 def validate_config(config: Dict[str, Any]) -> None:
-    required_keys = ["email", "password", "centre", "classes"]
+    """
+    Validate the overall configuration structure and values.
+
+    Args:
+        config (Dict[str, Any]): Configuration dictionary.
+
+    Raises:
+        ValueError: If the configuration is invalid.
+    """
+
+    def raise_invalid_booking_format_error() -> None:
+        """Helper function to raise an error for invalid booking_execution format."""
+        raise ValueError(ErrorMessages.invalid_booking_execution_format())
+
+    required_keys = ["email", "password", "centre", "classes", "booking_execution"]
     for key in required_keys:
         if key not in config:
             raise ValueError(ErrorMessages.missing_required_key(key))
 
+    # Validate global booking_execution
+    if config["booking_execution"] != "now":
+        try:
+            day_and_time = config["booking_execution"].split()
+            if len(day_and_time) != 2:
+                raise_invalid_booking_format_error()
+
+            _, exec_time = day_and_time
+            datetime.strptime(exec_time, "%H:%M:%S")
+        except ValueError:
+            raise_invalid_booking_format_error()
+
+    # Validate individual class definitions
     for cls in config["classes"]:
-        if (
-            "activity" not in cls
-            or "class_day" not in cls
-            or "class_time" not in cls
-            or "booking_execution" not in cls
-            or "weekly" not in cls
-        ):
+        if "activity" not in cls or "class_day" not in cls or "class_time" not in cls:
             raise ValueError(ErrorMessages.invalid_class_definition())
 
-        if cls["weekly"] and cls["booking_execution"] == "now":
-            raise ValueError(ErrorMessages.invalid_weekly_now())
 
-        if cls["booking_execution"] != "now":
-            day_and_time = cls["booking_execution"].split()
-            if len(day_and_time) != 2:
-                raise ValueError(ErrorMessages.invalid_booking_execution_format())
-            _, exec_time = day_and_time
-            try:
-                datetime.strptime(exec_time, "%H:%M:%S")
-            except ValueError as err:
-                raise ValueError(ErrorMessages.invalid_booking_execution_format()) from err
+def validate_activities(bot: SportBot, config: Dict[str, Any]) -> None:
+    """
+    Validate that all activities specified in the configuration exist.
 
+    Args:
+        bot (SportBot): The SportBot instance.
+        config (Dict[str, Any]): Configuration dictionary.
 
-def validate_activities(bot: SportBot, config: Dict[str, Any]) -> None:
+    Raises:
+        ValueError: If an activity is not found.
+    """
     logger.info("Fetching available activities for validation...")
     available_activities = bot.activities()
     available_activity_names = set(available_activities["name_activity"].tolist())
@@ -51,4 +69,5 @@ def validate_activities(bot: SportBot, config: Dict[str, Any]) -> None:
         activity_name = cls["activity"]
         if activity_name not in available_activity_names:
             raise ValueError(ErrorMessages.activity_not_found(activity_name, list(available_activity_names)))
+
     logger.info("All activities in the configuration file have been validated.")

pysportbot/service/service.py

@@ -1,49 +1,59 @@
-import time
+import os
 from typing import Any, Dict
 
-import schedule
-
 from pysportbot import SportBot
+from pysportbot.service.booking import schedule_bookings
+from pysportbot.service.config_validator import validate_activities, validate_config
 from pysportbot.utils.logger import get_logger
 
-from .booking import schedule_bookings
-from .config_validator import validate_activities, validate_config
-
 
 def run_service(
     config: Dict[str, Any],
-    offset_seconds: int,
+    booking_delay: int,
     retry_attempts: int,
-    retry_delay_minutes: int,
+    retry_delay: int,
     time_zone: str = "Europe/Madrid",
     log_level: str = "INFO",
 ) -> None:
-    # Initialize service logger
+    """
+    Run the booking service with the given configuration.
+
+    Args:
+        config (dict): Configuration dictionary for booking service.
+        booking_delay (int): Delay before each booking attempt.
+        retry_attempts (int): Number of retry attempts.
+        retry_delay (int): Delay between retry attempts in minutes.
+        time_zone (str): Time zone for the booking.
+        log_level (str): Logging level for the service.
+    """
+    # Initialize logger
     logger = get_logger(__name__)
     logger.setLevel(log_level)
 
-    # Validate the configuration file
+    # Validate configuration
     validate_config(config)
-    # Initialize the SportBot instance
+
+    # Initialize the SportBot and authenticate
     bot = SportBot(log_level=log_level, time_zone=time_zone)
     bot.login(config["email"], config["password"], config["centre"])
 
-    # Validate the activities in the configuration file
+    # Validate activities in the configuration
     validate_activities(bot, config)
 
-    for cls in config["classes"]:
-        schedule_bookings(
-            bot,
-            config,
-            cls,
-            offset_seconds,
-            retry_attempts,
-            retry_delay_minutes,
-            time_zone,
-        )
-
-    if schedule.jobs:
-        logger.info("Weekly bookings scheduled. Running the scheduler...")
-        while True:
-            schedule.run_pending()
-            time.sleep(1)
+    # Determine the number of threads
+    max_threads = min(len(config["classes"]), os.cpu_count() or 1)
+    logger.info(f"Using up to {max_threads} threads for booking {len(config['classes'])} activities.")
+
+    # Schedule bookings in parallel
+    schedule_bookings(
+        bot,
+        config["classes"],
+        config["booking_execution"],
+        booking_delay,
+        retry_attempts,
+        retry_delay,
+        time_zone,
+        max_threads,
+    )
+
+    logger.info("All bookings completed.")

pysportbot/utils/errors.py

@@ -20,11 +20,7 @@ class ErrorMessages:
 
     @staticmethod
     def invalid_class_definition() -> str:
-        return "Each class must include 'activity', 'class_day', " "'class_time', 'booking_execution', and 'weekly'."
-
-    @staticmethod
-    def invalid_weekly_now() -> str:
-        return "Invalid combination: cannot use weekly=True with booking_execution='now'."
+        return "Each class must include 'activity', 'class_day', " "'class_time'"
 
     @staticmethod
     def invalid_booking_execution_format() -> str:

pysportbot/utils/logger.py

@@ -1,4 +1,5 @@
 import logging
+import threading
 from datetime import datetime
 from typing import ClassVar, Optional
 
@@ -8,7 +9,7 @@ from .errors import ErrorMessages
 
 
 class ColorFormatter(logging.Formatter):
-    """Custom formatter to add color-coded log levels."""
+    """Custom formatter to add color-coded log levels and thread information."""
 
     COLORS: ClassVar[dict[str, str]] = {
         "DEBUG": "\033[94m",  # Blue
@@ -18,17 +19,34 @@ class ColorFormatter(logging.Formatter):
         "RESET": "\033[0m",  # Reset
     }
 
-    def __init__(self, fmt: str, datefmt: str, tz: pytz.BaseTzInfo) -> None:
+    THREAD_COLORS: ClassVar[list[str]] = [
+        "\033[95m",  # Magenta
+        "\033[96m",  # Cyan
+        "\033[93m",  # Yellow
+        "\033[92m",  # Green
+        "\033[94m",  # Blue
+        "\033[90m",  # Gray
+        "\033[37m",  # White
+        "\033[33m",  # Orange
+        "\033[35m",  # Purple
+    ]
+
+    thread_colors: dict[str, str]
+
+    def __init__(self, fmt: str, datefmt: str, tz: pytz.BaseTzInfo, include_threads: bool = False) -> None:
         """
-        Initialize the formatter with a specific timezone.
+        Initialize the formatter with a specific timezone and optional thread formatting.
 
         Args:
             fmt (str): The log message format.
             datefmt (str): The date format.
             tz (pytz.BaseTzInfo): The timezone for log timestamps.
+            include_threads (bool): Whether to include thread information in logs.
         """
         super().__init__(fmt, datefmt)
         self.timezone = tz
+        self.include_threads = include_threads
+        self.thread_colors = {}  # Initialize as an empty dictionary
 
     def formatTime(self, record: logging.LogRecord, datefmt: Optional[str] = None) -> str:
         """
@@ -46,7 +64,7 @@ class ColorFormatter(logging.Formatter):
 
     def format(self, record: logging.LogRecord) -> str:
         """
-        Format the log record with color-coded log levels.
+        Format the log record with color-coded log levels and optional thread information.
 
         Args:
             record (logging.LogRecord): The log record to format.
@@ -56,6 +74,24 @@ class ColorFormatter(logging.Formatter):
         """
         color = self.COLORS.get(record.levelname, self.COLORS["RESET"])
         record.levelname = f"{color}{record.levelname}{self.COLORS['RESET']}"
+
+        if self.include_threads:
+            thread_name = threading.current_thread().name
+            if thread_name == "MainThread":
+                # Skip adding thread info for the main thread
+                record.thread_info = ""
+            else:
+                # Map thread names to simplified format (Thread 0, Thread 1, etc.)
+                if thread_name not in self.thread_colors:
+                    color_index = len(self.thread_colors) % len(self.THREAD_COLORS)
+                    self.thread_colors[thread_name] = self.THREAD_COLORS[color_index]
+
+                thread_color = self.thread_colors[thread_name]
+                simplified_thread_name = thread_name.split("_")[-1]
+                record.thread_info = f"[{thread_color}Thread {simplified_thread_name}{self.COLORS['RESET']}] "
+        else:
+            record.thread_info = ""
+
         return super().format(record)
 
 
@@ -74,12 +110,16 @@ def setup_logger(level: str = "INFO", timezone: str = "Europe/Madrid") -> None:
         handler = logging.StreamHandler()
         handler.setLevel(logging._nameToLevel[level.upper()])
         tz = pytz.timezone(timezone)
-        formatter = ColorFormatter(
-            "[%(asctime)s] [%(levelname)s] %(message)s",
+
+        # Default formatter for the main thread
+        thread_formatter = ColorFormatter(
+            "[%(asctime)s] [%(levelname)s] %(thread_info)s%(message)s",
             datefmt="%Y-%m-%d %H:%M:%S",
             tz=tz,
+            include_threads=True,
         )
-        handler.setFormatter(formatter)
+
+        handler.setFormatter(thread_formatter)
         root_logger.addHandler(handler)
 
 

{pysportbot-0.0.5.dist-info → pysportbot-0.0.7.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: pysportbot
-Version: 0.0.5
+Version: 0.0.7
 Summary:  A python-based bot for automatic resasports slot booking
 Home-page: https://github.com/jbeirer/resasports-bot
 Author: Joshua Falco Beirer
@@ -15,7 +15,6 @@ Requires-Dist: beautifulsoup4 (>=4.12.3,<5.0.0)
 Requires-Dist: pandas (>=2.2.3,<3.0.0)
 Requires-Dist: pytz (>=2024.2,<2025.0)
 Requires-Dist: requests (>=2.32.3,<3.0.0)
-Requires-Dist: schedule (>=1.2.2,<2.0.0)
 Project-URL: Documentation, https://jbeirer.github.io/resasports-bot/
 Project-URL: Repository, https://github.com/jbeirer/resasports-bot
 Description-Content-Type: text/markdown
@@ -70,7 +69,7 @@ You can easily run `pysportbot` as a service to manage your bookings automatical
 ```bash
 python -m pysportbot.service --config config.json
 ```
-The service requires a `json` configuration file that specifies your user data and how you would like to book your classes. Currently, three types of configuration are supported:
+The service requires a `json` configuration file that specifies your user data and how you would like to book your classes. Currently, two types of configuration are supported:
 
 ##### 1. Book an upcoming class now
 
@@ -81,13 +80,13 @@ Let's say you would like to book Yoga next Monday at 18:00:00, then your `config
     "email": "your-email",
     "password": "your-password",
     "center": "your-gym-name",
+    "booking_execution": "now",
+
     "classes": [
         {
             "activity": "Yoga",
             "class_day": "Monday",
             "class_time": "18:00:00",
-            "booking_execution": "now",
-            "weekly": false
         }
     ]
 }
@@ -101,32 +100,13 @@ Let's say you would like to book Yoga next Monday at 18:00:00, but the execution
     "email": "your-email",
     "password": "your-password",
     "center": "your-gym-name",
-    "classes": [
-        {
-            "activity": "Yoga",
-            "class_day": "Monday",
-            "class_time": "18:00:00",
-            "booking_execution": "Friday 07:30:00",
-            "weekly": false
-        }
-    ]
-}
-```
-##### 3. Schedule weekly booking at specific execution day and time
-Let's say you would like to book Yoga every Monday at 18:00:00 and the booking execution should be every Friday at 07:30:00 then your `config.json` would look like:
+    "booking_execution": "Friday 07:30:00",
 
-```json
-{
-    "email": "your-email",
-    "password": "your-password",
-    "center": "your-gym-name",
     "classes": [
         {
             "activity": "Yoga",
             "class_day": "Monday",
             "class_time": "18:00:00",
-            "booking_execution": "Friday 07:30:00",
-            "weekly": true
         }
     ]
 }
@@ -139,7 +119,7 @@ python -m pysportbot.service --help
 ```
 Currently supported options include
 1.  ```--retry-attempts``` sets the number of retries attempted in case a booking attempt fails
-2. ```--retry-delay-minutes``` sets the delay in minutes between retries for weekly bookings
+2. ```--retry-delay``` sets the delay in seconds between retries booking retries
 3. ```--time-zone``` sets the time zone for the service (e.g. Europe/Madrid)
 4. ```--log-level``` sets the log-level of the service (e.g. DEBUG, INFO, WARNING, ERROR)
 

{pysportbot-0.0.5.dist-info → pysportbot-0.0.7.dist-info}/RECORD

@@ -1,22 +1,22 @@
 pysportbot/__init__.py,sha256=4z5KKwrnwj_uiZYTUNgZIw_7s8ZT9C-Olz8_hzhPutw,4919
-pysportbot/activities.py,sha256=dyZDme6CidsBeGqB9lIHFYmlRKTmDLvTJGPoize17B0,4247
+pysportbot/activities.py,sha256=y2-CCdMoPTnKZleF_icYbngbnfpmHL5Cyadv1UuiCpE,4248
 pysportbot/authenticator.py,sha256=xEU9O6W6Yp9DCueoUD0ASMkm17yvdUZqTvV4h6WlSnI,5012
 pysportbot/bookings.py,sha256=vJ0kw74qyirZlbQ7M9XqlKtRoGzuHR0_t6-zUdgldkI,3123
 pysportbot/centres.py,sha256=FTK-tXUOxiJvLCHP6Bk9XEQKODQZOwwkYLlioSJPBEk,3399
 pysportbot/endpoints.py,sha256=ANh5JAbdzyZQ-i4ODrhYlskPpU1gkBrw9UhMC7kRSvU,1353
 pysportbot/service/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-pysportbot/service/__main__.py,sha256=egQ68-BFzvshF8d5DbVKI6ooL46pPD12v_T64CAbza0,1320
-pysportbot/service/booking.py,sha256=CNeMhYFAFi1UXIwAqtx8fKuO5jUsmnuf7VaSmkwIX1c,5425
+pysportbot/service/__main__.py,sha256=R03cbuus-BZ_dgdga94zqKblEkxJPuGuOP1JIz5Deyo,1274
+pysportbot/service/booking.py,sha256=88sZLzX72m7vQXhJdPyiQlZXoi552dK7CCLywbrBYYE,5647
 pysportbot/service/config_loader.py,sha256=elNNwcC7kwc0lmRqj95hAA50qSmLelWv5G2E62tDxP0,185
-pysportbot/service/config_validator.py,sha256=lGsSP7ubD816CQb0fZNYtdHWIXsFsZWtRLIjAMjSJRw,2167
+pysportbot/service/config_validator.py,sha256=ce7p-LgPtvWnTYvpyUEE60627DHHzx5mFhEI9hDNB-4,2621
 pysportbot/service/scheduling.py,sha256=bwqbiQQ9y4ss4UXZkWuOVCgCa9XlZt1n4TT_8z9bD7M,1973
-pysportbot/service/service.py,sha256=JMq71x6KpaS16HRIfNTL8aLiiCT85PTmCLBIcebcK1U,1294
+pysportbot/service/service.py,sha256=Lwy5OTLeR2kneZZ1I3wCw6P4DItmN5Ih6ADSbZHU38M,1821
 pysportbot/session.py,sha256=pTQrz3bGzLYBtzVOgKv04l4UXDSgtA3Infn368bjg5I,1529
 pysportbot/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-pysportbot/utils/errors.py,sha256=sUSs04yr_OmZeTywi1fzPsjVjkLd5iTpXlzlQqNKmgQ,5162
-pysportbot/utils/logger.py,sha256=_31g_qY4_aCMSXKo-63e10CwAs7ug7vSuq6TMNoRmek,3534
+pysportbot/utils/errors.py,sha256=mpTeKjOUIxJbOqL6A6apdMb7Cpto86DkrKHWfROXjMc,4979
+pysportbot/utils/logger.py,sha256=38rB0M6KPlelXPcgXPSEhXB36-_ZTERLJAQ8DRYIOTM,5189
 pysportbot/utils/time.py,sha256=VZSW8AxFIoFD5ZSmLUPcwawp6PmpkcxNjP3Db-Hl_fw,1244
-pysportbot-0.0.5.dist-info/LICENSE,sha256=6ov3DypdEVYpp2pn_B1MniKWO5C9iDA4O6PGcbork6c,1077
-pysportbot-0.0.5.dist-info/METADATA,sha256=KZ4v0i9-v-8-xN2JI28NNU9Izce9vensdqqexSd_tFk,5585
-pysportbot-0.0.5.dist-info/WHEEL,sha256=Nq82e9rUAnEjt98J6MlVmMCZb-t9cYE2Ir1kpBmnWfs,88
-pysportbot-0.0.5.dist-info/RECORD,,
+pysportbot-0.0.7.dist-info/LICENSE,sha256=6ov3DypdEVYpp2pn_B1MniKWO5C9iDA4O6PGcbork6c,1077
+pysportbot-0.0.7.dist-info/METADATA,sha256=rMxYNWwtB0qF_NHV4lDDXccasyi4LE8Ziuh6jO6wAxI,4892
+pysportbot-0.0.7.dist-info/WHEEL,sha256=Nq82e9rUAnEjt98J6MlVmMCZb-t9cYE2Ir1kpBmnWfs,88
+pysportbot-0.0.7.dist-info/RECORD,,