pysportbot 0.0.1__py3-none-any.whl

pysportbot/service/booking.py

@@ -0,0 +1,147 @@
+import time
+from datetime import datetime, timedelta
+from typing import Any, Dict
+
+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:
+    """
+    Helper function to raise a ValueError for no matching slots.
+    """
+    raise ValueError(ErrorMessages.no_matching_slots_for_time(activity, class_time, booking_date))
+
+
+def attempt_booking(
+    bot: SportBot,
+    cls: Dict[str, Any],
+    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"]
+
+    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}")
+            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})")
+            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}")
+
+            if ErrorMessages.slot_already_booked() in error_str:
+                logger.warning(f"{activity} at {class_time} on {booking_date} is already booked; skipping retry.")
+                return
+
+            if attempt_num < retry_attempts:
+                logger.info(f"Retrying in {retry_delay_minutes} minutes...")
+                time.sleep(retry_delay_minutes * 60)
+        else:
+            return
+
+    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,
+    retry_attempts: int,
+    retry_delay_minutes: int,
+    time_zone: str = "Europe/Madrid",
+) -> 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:
+            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,
+                )
+            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,
+        )

pysportbot/service/config_loader.py

@@ -0,0 +1,7 @@
+import json
+from typing import Any, Dict, cast
+
+
+def load_config(config_path: str) -> Dict[str, Any]:
+    with open(config_path) as f:
+        return cast(Dict[str, Any], json.load(f))

pysportbot/service/config_validator.py

@@ -0,0 +1,54 @@
+from datetime import datetime
+from typing import Any, Dict
+
+from pysportbot import SportBot
+from pysportbot.utils.errors import ErrorMessages
+from pysportbot.utils.logger import get_logger
+
+logger = get_logger(__name__)
+
+DAY_MAP = {"monday": 0, "tuesday": 1, "wednesday": 2, "thursday": 3, "friday": 4, "saturday": 5, "sunday": 6}
+
+
+def validate_config(config: Dict[str, Any]) -> None:
+    required_keys = ["email", "password", "centre", "classes"]
+    for key in required_keys:
+        if key not in config:
+            raise ValueError(ErrorMessages.missing_required_key(key))
+
+    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
+        ):
+            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:
+    logger.info("Fetching available activities for validation...")
+    available_activities = bot.activities()
+    available_activity_names = set(available_activities["name_activity"].tolist())
+
+    logger.debug(f"Available activities: {available_activity_names}")
+
+    for cls in config["classes"]:
+        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/scheduling.py

@@ -0,0 +1,61 @@
+from datetime import datetime, timedelta
+
+import pytz
+
+from .config_validator import DAY_MAP
+
+
+def calculate_next_execution(booking_execution: str, time_zone: str = "Europe/Madrid") -> datetime:
+    """
+    Calculate the next execution time based on the booking execution day and time.
+
+    Args:
+        booking_execution (str): Execution in the format 'Day HH:MM:SS' or 'now'.
+        time_zone (str): The timezone for localization.
+
+    Returns:
+        datetime: The next execution time as a timezone-aware datetime.
+    """
+    tz = pytz.timezone(time_zone)
+
+    # Handle the special case where execution is "now"
+    if booking_execution == "now":
+        return datetime.now(tz)
+
+    execution_day, execution_time = booking_execution.split()
+    now = datetime.now(tz)
+
+    # Map the day name to a day-of-week index
+    day_of_week_target = DAY_MAP[execution_day.lower().strip()]
+    current_weekday = now.weekday()
+
+    # Parse the execution time
+    exec_time = datetime.strptime(execution_time, "%H:%M:%S").time()
+
+    # Determine the next execution date
+    if day_of_week_target == current_weekday and now.time() < exec_time:
+        next_execution_date = now
+    else:
+        days_ahead = day_of_week_target - current_weekday
+        if days_ahead <= 0:
+            days_ahead += 7
+        next_execution_date = now + timedelta(days=days_ahead)
+
+    # Combine date and time
+    execution_datetime = datetime.combine(next_execution_date.date(), exec_time)
+
+    # Localize if naive
+    if execution_datetime.tzinfo is None:
+        execution_datetime = tz.localize(execution_datetime)
+
+    return execution_datetime
+
+
+def calculate_class_day(class_day: str, time_zone: str = "Europe/Madrid") -> datetime:
+    tz = pytz.timezone(time_zone)
+    now = datetime.now(tz)
+    target_weekday = DAY_MAP[class_day.lower().strip()]
+    days_ahead = target_weekday - now.weekday()
+    if days_ahead < 0:
+        days_ahead += 7
+    return now + timedelta(days=days_ahead)

pysportbot/service/service.py

@@ -0,0 +1,47 @@
+import time
+from typing import Any, Dict
+
+import schedule
+
+from pysportbot import SportBot
+from pysportbot.utils.logger import get_logger
+
+from .booking import schedule_bookings
+from .config_validator import validate_activities, validate_config
+
+logger = get_logger(__name__)
+
+
+def run_service(
+    config: Dict[str, Any],
+    offset_seconds: int,
+    retry_attempts: int,
+    retry_delay_minutes: int,
+    time_zone: str = "Europe/Madrid",
+) -> None:
+
+    # Validate the configuration file
+    validate_config(config)
+
+    bot = SportBot()
+    bot.login(config["email"], config["password"], config["centre"])
+
+    # Validate the activities in the configuration file
+    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)

pysportbot/session.py

@@ -0,0 +1,47 @@
+from requests import Session as RequestsSession
+
+from .utils.logger import get_logger
+
+logger = get_logger(__name__)
+
+
+class Session:
+    """Handles the session and headers for HTTP requests."""
+
+    def __init__(self) -> None:
+        """Initialize a new session and set default headers."""
+        self.session: RequestsSession = RequestsSession()
+        self.headers: dict[str, str] = {
+            "User-Agent": "Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:133.0) Gecko/20100101 Firefox/133.0",
+            "Accept": "application/json, text/plain, */*",
+            "Accept-Language": "en-US,en;q=0.5",
+            "DNT": "1",
+            "Sec-GPC": "1",
+            "Connection": "keep-alive",
+            "Upgrade-Insecure-Requests": "1",
+            "Sec-Fetch-Dest": "empty",
+            "Sec-Fetch-Mode": "cors",
+            "Sec-Fetch-Site": "same-origin",
+            "TE": "trailers",
+        }
+        logger.info("Session initialized.")
+
+    def set_header(self, key: str, value: str) -> None:
+        """
+        Set or update a header in the session.
+
+        Args:
+            key (str): The header key to set or update.
+            value (str): The header value to assign.
+        """
+        self.headers[key] = value
+        logger.debug(f"Header updated: {key} = {value}")
+
+    def get_session(self) -> RequestsSession:
+        """
+        Get the underlying Requests session object.
+
+        Returns:
+            RequestsSession: The Requests session instance.
+        """
+        return self.session

pysportbot/utils/errors.py

@@ -0,0 +1,140 @@
+import logging
+
+
+class ErrorMessages:
+    """Centralized error messages for the application."""
+
+    @staticmethod
+    def no_centre_selected() -> str:
+        """Return an error message for no centre selected."""
+        return "No centre selected. Please set a centre first."
+
+    @staticmethod
+    def centre_not_found(centre: str) -> str:
+        """Return an error message for a centre not found."""
+        return f"Centre '{centre}' not found. Please check the list of available centres."
+
+    @staticmethod
+    def missing_required_key(key: str) -> str:
+        return f"Missing required key in config: {key}"
+
+    @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'."
+
+    @staticmethod
+    def invalid_booking_execution_format() -> str:
+        return "Invalid booking_execution format. Use 'now' or 'Day HH:MM:SS'."
+
+    @staticmethod
+    def no_matching_slots_for_time(activity: str, class_time: str, booking_date: str) -> str:
+        return f"No matching slots available for {activity} at {class_time} on {booking_date}"
+
+    @staticmethod
+    def not_logged_in() -> str:
+        """Return an error message for not being logged in."""
+        return "You must log in first."
+
+    @staticmethod
+    def login_failed() -> str:
+        """Return an error message for a failed login."""
+        return "Login failed. Please check your credentials and try again."
+
+    @staticmethod
+    def invalid_log_level(level: str) -> ValueError:
+        """
+        Generate a ValueError for an invalid logging level.
+
+        Args:
+            level (str): The invalid logging level.
+
+        Returns:
+            ValueError: A ValueError with a detailed message.
+        """
+        valid_levels = ", ".join(logging._nameToLevel.keys())
+        return ValueError(f"Invalid logging level: {level}. Valid levels are {valid_levels}.")
+
+    @staticmethod
+    def endpoint_not_found(name: str) -> ValueError:
+        """
+        Generate a ValueError for a missing endpoint.
+
+        Args:
+            name (str): The name of the endpoint that was not found.
+
+        Returns:
+            ValueError: A ValueError with a detailed message.
+        """
+        return ValueError(f"Endpoint '{name}' does not exist.")
+
+    @staticmethod
+    def no_activities_loaded() -> str:
+        """Return an error message for no activities loaded."""
+        return "No activities loaded. Please log in first."
+
+    @staticmethod
+    def failed_fetch(resource: str) -> str:
+        """Return an error message for a failed fetch request."""
+        return f"Failed to fetch {resource}. Please try again later."
+
+    @staticmethod
+    def activity_not_found(activity_name: str, available_activities: list) -> str:
+        """Return an error message for an activity not found."""
+        return (
+            f"No activity found with the name '{activity_name}'. "
+            f"Available activities are: {', '.join(available_activities)}."
+        )
+
+    @staticmethod
+    def no_slots(activity_name: str, day: str) -> str:
+        """Return a warning message when no slots are available."""
+        return f"No slots available for activity '{activity_name}' on {day}."
+
+    @staticmethod
+    def no_matching_slots(activity_name: str, day: str) -> str:
+        """Return a warning message for no matching slots found."""
+        return f"No matching slots found for activity '{activity_name}' on {day}."
+
+    @staticmethod
+    def slot_not_found(activity_name: str, start_time: str) -> str:
+        """Return an error message for a slot not found."""
+        return f"No slot found for activity '{activity_name}' at {start_time}."
+
+    @staticmethod
+    def slot_not_bookable_yet() -> str:
+        """Return an error message for a slot not bookable yet."""
+        return "The slot is not bookable yet."
+
+    @staticmethod
+    def slot_already_booked() -> str:
+        """Return an error message for a slot already booked."""
+        return "The slot is already booked."
+
+    @staticmethod
+    def slot_unavailable() -> str:
+        """Return an error message for a slot that is unavailable."""
+        return "The slot is not available."
+
+    @staticmethod
+    def cancellation_failed() -> str:
+        """Return an error message for a failed cancellation."""
+        return "Cancellation failed. The slot may not have been booked."
+
+    @staticmethod
+    def failed_login() -> str:
+        """Return an error message for a failed login."""
+        return "Login failed. Please check your credentials and try again."
+
+    @staticmethod
+    def failed_login_nubapp() -> str:
+        """Return an error message for a failed login to Nubapp."""
+        return "Login to Nubapp failed. Please try again later."
+
+    @staticmethod
+    def unknown_error(action: str) -> str:
+        """Return an error message for an unknown error."""
+        return f"An unknown error occurred during {action}. Please try again later."

pysportbot/utils/logger.py

@@ -0,0 +1,78 @@
+import logging
+from typing import ClassVar
+
+from .errors import ErrorMessages
+
+
+class ColorFormatter(logging.Formatter):
+    """Custom formatter to add color-coded log levels."""
+
+    COLORS: ClassVar[dict[str, str]] = {
+        "DEBUG": "\033[94m",  # Blue
+        "INFO": "\033[92m",  # Green
+        "WARNING": "\033[93m",  # Yellow
+        "ERROR": "\033[91m",  # Red
+        "RESET": "\033[0m",  # Reset
+    }
+
+    def format(self, record: logging.LogRecord) -> str:
+        """
+        Format the log record with color-coded log levels.
+
+        Args:
+            record (logging.LogRecord): The log record to format.
+
+        Returns:
+            str: The formatted log record as a string.
+        """
+        color = self.COLORS.get(record.levelname, self.COLORS["RESET"])
+        record.levelname = f"{color}{record.levelname}{self.COLORS['RESET']}"
+        return super().format(record)
+
+
+def setup_logger(level: str = "INFO") -> None:
+    """
+    Configure the root logger with color-coded output.
+
+    Args:
+        level (str): The desired logging level (DEBUG, INFO, WARNING, ERROR, CRITICAL).
+    """
+    root_logger = logging.getLogger()
+    root_logger.setLevel(logging._nameToLevel[level.upper()])
+
+    if not root_logger.hasHandlers():  # Avoid duplicate handlers
+        handler = logging.StreamHandler()
+        handler.setLevel(logging._nameToLevel[level.upper()])
+        formatter = ColorFormatter("[%(asctime)s] [%(levelname)s] %(message)s", datefmt="%Y-%m-%d %H:%M:%S")
+        handler.setFormatter(formatter)
+        root_logger.addHandler(handler)
+
+
+def set_log_level(level: str) -> None:
+    """
+    Change the logging level of the root logger.
+
+    Args:
+        level (str): The desired logging level (DEBUG, INFO, WARNING, ERROR, CRITICAL).
+
+    Raises:
+        ValueError: If the provided logging level is invalid.
+    """
+    level = level.upper()
+    if level not in logging._nameToLevel:
+        raise ErrorMessages.invalid_log_level(level)
+    logging.getLogger().setLevel(logging._nameToLevel[level])
+    logging.info(f"Log level changed to {level}.")
+
+
+def get_logger(name: str) -> logging.Logger:
+    """
+    Retrieve a logger by name.
+
+    Args:
+        name (str): The name of the logger.
+
+    Returns:
+        logging.Logger: The logger instance.
+    """
+    return logging.getLogger(name)

pysportbot/utils/time.py

@@ -0,0 +1,39 @@
+from datetime import datetime, time
+
+import pytz
+
+
+def get_unix_day_bounds(date_string: str, fmt: str = "%Y-%m-%d", tz: str = "UTC") -> tuple[int, int]:
+    """
+    Get the Unix timestamp bounds for a given day.
+
+    Args:
+        date_string (str): The date in 'YYYY-MM-DD' format.
+        fmt (str): The format of the input date string.
+        tz (str): The timezone name.
+
+    Returns:
+        tuple[int, int]: The start and end Unix timestamps for the day.
+    """
+    tzinfo = pytz.timezone(tz)
+    date = datetime.strptime(date_string, fmt).replace(tzinfo=tzinfo)
+    return (
+        int(datetime.combine(date.date(), time.min, tzinfo=tzinfo).timestamp()),
+        int(datetime.combine(date.date(), time.max, tzinfo=tzinfo).timestamp()),
+    )
+
+
+def format_unix_to_date(unix_timestamp: int, fmt: str = "%Y-%m-%d %H:%M:%S", tz: str = "UTC") -> str:
+    """
+    Convert a Unix timestamp to a formatted date string.
+
+    Args:
+        unix_timestamp (int): The Unix timestamp to convert.
+        fmt (str): The desired output format.
+        tz (str): The timezone name.
+
+    Returns:
+        str: The formatted date string.
+    """
+    tzinfo = pytz.timezone(tz)
+    return datetime.fromtimestamp(unix_timestamp, tz=tzinfo).strftime(fmt)

pysportbot-0.0.1.dist-info/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025, Joshua Falco Beirer
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.