pysportbot 0.0.4__py3-none-any.whl → 0.0.6__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,10 +10,10 @@ 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("--offset-seconds", type=int, default=5, 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."
+        "--retry-delay-minutes", type=int, default=1, help="Delay in minutes between retries for weekly 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.")

pysportbot/service/booking.py

@@ -1,147 +1,156 @@
 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],
+    activity: str,
+    class_day: str,
+    class_time: str,
     offset_seconds: int,
     retry_attempts: int = 1,
     retry_delay_minutes: 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.
+        offset_seconds (int): Delay before attempting booking.
+        retry_attempts (int): Number of retry attempts.
+        retry_delay_minutes (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)
+            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)
         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(
+def schedule_bookings_parallel(
     bot: SportBot,
-    config: Dict[str, Any],
-    cls: Dict[str, Any],
+    classes: List[Dict[str, Any]],
+    booking_execution: str,
     offset_seconds: int,
     retry_attempts: int,
     retry_delay_minutes: int,
-    time_zone: str = "Europe/Madrid",
+    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.
+        offset_seconds (int): Delay before each booking attempt.
+        retry_attempts (int): Number of retry attempts.
+        retry_delay_minutes (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)
+
+    with ThreadPoolExecutor(max_workers=max_threads) as executor:
+        future_to_class = {
+            executor.submit(
+                attempt_booking,
+                bot,
+                cls["activity"],
+                cls["class_day"],
+                cls["class_time"],
+                offset_seconds,
+                retry_attempts,
+                retry_delay_minutes,
+                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,14 +1,11 @@
-import time
+import os
 from typing import Any, Dict
 
-import schedule
-
 from pysportbot import SportBot
+from pysportbot.service.booking import schedule_bookings_parallel
+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],
@@ -18,32 +15,45 @@ def run_service(
     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.
+        offset_seconds (int): Delay before each booking attempt.
+        retry_attempts (int): Number of retry attempts.
+        retry_delay_minutes (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_parallel(
+        bot,
+        config["classes"],
+        config["booking_execution"],
+        offset_seconds,
+        retry_attempts,
+        retry_delay_minutes,
+        time_zone,
+        max_threads,
+    )
+
+    logger.info("All bookings completed.")

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.4.dist-info → pysportbot-0.0.6.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: pysportbot
-Version: 0.0.4
+Version: 0.0.6
 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
@@ -29,9 +28,9 @@ Description-Content-Type: text/markdown
 [![Build status](https://img.shields.io/github/actions/workflow/status/jbeirer/resasports-bot/main.yml?branch=main)](https://github.com/jbeirer/resasports-bot/actions/workflows/main.yml?query=branch%3Amain)
 [![codecov](https://codecov.io/gh/jbeirer/resasports-bot/graph/badge.svg?token=ZCJV384TXF)](https://codecov.io/gh/jbeirer/resasports-bot)
 [![Commit activity](https://img.shields.io/github/commit-activity/m/jbeirer/resasports-bot)](https://github.com/jbeirer/resasports-bot/commits/main/)
-[![License](https://img.shields.io/github/license/jbeirer/resasports-bot)](https://github.com/jbeirer/resasports-bot?tab=MIT-1-ov-file)
+[![License](https://img.shields.io/github/license/jbeirer/resasports-bot)](https://github.com/jbeirer/resasports-bot/blob/main/LICENSE)
 [![Documentation](https://img.shields.io/badge/api-docs-blue)](https://jbeirer.github.io/resasports-bot/)
-[![Contributor Covenant](https://img.shields.io/badge/Contributor%20Covenant-2.1-4baaaa.svg)](CODE_OF_CONDUCT.md)
+[![Contributor Covenant](https://img.shields.io/badge/Contributor%20Covenant-2.1-4baaaa.svg)](https://github.com/jbeirer/resasports-bot/blob/main/CODE_OF_CONDUCT.md)
 
 Welcome to pysportbot!
 
@@ -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
         }
     ]
 }

{pysportbot-0.0.4.dist-info → pysportbot-0.0.6.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=PSaqYZ8wWlmFT0_taeOA2NLZfm9fIOy6MBhrv_IPSP4,1319
+pysportbot/service/booking.py,sha256=bjPb9BLF7XOhFnr1ZArxUHNO6-10yM1z-3S5-ZFpXjQ,5713
 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=_LR7rJ4GAgp4saSFREiSJCm4GzzEor6ZYkIkuAq7PLM,1866
 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/logger.py,sha256=38rB0M6KPlelXPcgXPSEhXB36-_ZTERLJAQ8DRYIOTM,5189
 pysportbot/utils/time.py,sha256=VZSW8AxFIoFD5ZSmLUPcwawp6PmpkcxNjP3Db-Hl_fw,1244
-pysportbot-0.0.4.dist-info/LICENSE,sha256=6ov3DypdEVYpp2pn_B1MniKWO5C9iDA4O6PGcbork6c,1077
-pysportbot-0.0.4.dist-info/METADATA,sha256=y6MCUbZBDuw0yXJwhLFSbAfIQvmEW22y5sheiX01tPQ,5533
-pysportbot-0.0.4.dist-info/WHEEL,sha256=Nq82e9rUAnEjt98J6MlVmMCZb-t9cYE2Ir1kpBmnWfs,88
-pysportbot-0.0.4.dist-info/RECORD,,
+pysportbot-0.0.6.dist-info/LICENSE,sha256=6ov3DypdEVYpp2pn_B1MniKWO5C9iDA4O6PGcbork6c,1077
+pysportbot-0.0.6.dist-info/METADATA,sha256=lECBuUu6DaV2CiVXWwHpmz1b--lL7DhxwpOsrXTITKU,4904
+pysportbot-0.0.6.dist-info/WHEEL,sha256=Nq82e9rUAnEjt98J6MlVmMCZb-t9cYE2Ir1kpBmnWfs,88
+pysportbot-0.0.6.dist-info/RECORD,,