pysportbot 0.0.1__py3-none-any.whl

pysportbot/__init__.py

@@ -0,0 +1,116 @@
+import logging
+from typing import Optional
+
+from pandas import DataFrame
+
+from .activities import Activities
+from .authenticator import Authenticator
+from .bookings import Bookings
+from .centres import Centres
+from .session import Session
+from .utils.errors import ErrorMessages
+from .utils.logger import set_log_level, setup_logger
+
+
+class SportBot:
+    """Unified interface for interacting with the booking system."""
+
+    def __init__(self, log_level: str = "INFO", print_centres: bool = False) -> None:
+        setup_logger(log_level)
+        self._logger = logging.getLogger("SportBot")
+        self._logger.info("Initializing SportBot...")
+        self._centres = Centres(print_centres)
+        self._session: Session = Session()
+        self._auth: Optional[Authenticator] = None
+        self._activities: Activities = Activities(self._session)
+        self._bookings: Bookings = Bookings(self._session)
+        self._df_activities: DataFrame | None = None
+        self._is_logged_in: bool = False  # State variable for login status
+
+    def set_log_level(self, log_level: str) -> None:
+        set_log_level(log_level)
+        self._logger.info(f"Log level changed to {log_level}.")
+
+    def login(self, email: str, password: str, centre: str) -> None:
+
+        # Check if the selected centre is valid
+        self._centres.check_centre(centre)
+        self._logger.info(f"Selected centre: {centre}")
+
+        # Initialize the Authenticator
+        self._auth = Authenticator(self._session, centre)
+
+        self._logger.info("Attempting to log in...")
+        try:
+            self._auth.login(email, password)
+            self._df_activities = self._activities.fetch()
+            self._is_logged_in = True
+            self._logger.info("Login successful!")
+        except Exception:
+            self._is_logged_in = False  # Ensure state is False on failure
+            self._logger.exception(ErrorMessages.login_failed())
+            raise
+
+    def is_logged_in(self) -> bool:
+        """Returns the login status."""
+        return self._is_logged_in
+
+    def activities(self, limit: int | None = None) -> DataFrame:
+        if not self._is_logged_in:
+            self._logger.error(ErrorMessages.not_logged_in())
+            raise PermissionError(ErrorMessages.not_logged_in())
+
+        if self._df_activities is None:
+            self._logger.error(ErrorMessages.no_activities_loaded())
+            raise ValueError(ErrorMessages.no_activities_loaded())
+
+        df = self._df_activities[["name_activity", "id_activity"]]
+        return df.head(limit) if limit else df
+
+    def daily_slots(self, activity: str, day: str, limit: int | None = None) -> DataFrame:
+        if not self._is_logged_in:
+            self._logger.error(ErrorMessages.not_logged_in())
+            raise PermissionError(ErrorMessages.not_logged_in())
+
+        if self._df_activities is None:
+            self._logger.error(ErrorMessages.no_activities_loaded())
+            raise ValueError(ErrorMessages.no_activities_loaded())
+
+        df = self._activities.daily_slots(self._df_activities, activity, day)
+        return df.head(limit) if limit else df
+
+    def book(self, activity: str, start_time: str) -> None:
+        if not self._is_logged_in:
+            self._logger.error(ErrorMessages.not_logged_in())
+            raise PermissionError(ErrorMessages.not_logged_in())
+
+        if self._df_activities is None:
+            self._logger.error(ErrorMessages.no_activities_loaded())
+            raise ValueError(ErrorMessages.no_activities_loaded())
+
+        slots = self.daily_slots(activity, start_time.split(" ")[0])
+        matching_slot = slots[slots["start_timestamp"] == start_time]
+        if matching_slot.empty:
+            error_msg = ErrorMessages.slot_not_found(activity, start_time)
+            self._logger.error(error_msg)
+            raise IndexError(error_msg)
+
+        self._bookings.book(matching_slot.iloc[0]["id_activity_calendar"])
+
+    def cancel(self, activity: str, start_time: str) -> None:
+        if not self._is_logged_in:
+            self._logger.error(ErrorMessages.not_logged_in())
+            raise PermissionError(ErrorMessages.not_logged_in())
+
+        if self._df_activities is None:
+            self._logger.error(ErrorMessages.no_activities_loaded())
+            raise ValueError(ErrorMessages.no_activities_loaded())
+
+        slots = self.daily_slots(activity, start_time.split(" ")[0])
+        matching_slot = slots[slots["start_timestamp"] == start_time]
+        if matching_slot.empty:
+            error_msg = ErrorMessages.slot_not_found(activity, start_time)
+            self._logger.error(error_msg)
+            raise IndexError(error_msg)
+
+        self._bookings.cancel(matching_slot.iloc[0]["id_activity_calendar"])

pysportbot/activities.py

@@ -0,0 +1,122 @@
+import json
+
+import pandas as pd
+from pandas import DataFrame
+
+from .endpoints import Endpoints
+from .session import Session
+from .utils.errors import ErrorMessages
+from .utils.logger import get_logger
+from .utils.time import get_unix_day_bounds
+
+logger = get_logger(__name__)
+
+
+class Activities:
+    """Handles activity fetching and slot management."""
+
+    def __init__(self, session: Session) -> None:
+        """Initialize the Activities class."""
+        self.session = session.session
+        self.headers = session.headers
+
+    def fetch(self) -> DataFrame:
+        """
+        Fetch all available activities.
+
+        Returns:
+            DataFrame: A DataFrame containing activity details.
+
+        Raises:
+            RuntimeError: If the request fails.
+        """
+        logger.info("Fetching activities...")
+        response = self.session.post(Endpoints.ACTIVITIES, headers=self.headers)
+        if response.status_code != 200:
+            error_msg = ErrorMessages.failed_fetch("activities")
+            logger.error(error_msg)
+            raise RuntimeError(error_msg)
+        logger.info("Activities fetched successfully.")
+        activities = json.loads(response.content.decode("utf-8"))["activities"]
+        return pd.DataFrame.from_dict(activities, orient="index")
+
+    def daily_slots(self, df_activities: DataFrame, activity_name: str, day: str) -> DataFrame:
+        """
+        Fetch available slots for a specific activity on a given day.
+
+        Args:
+            df_activities (DataFrame): The DataFrame of activities.
+            activity_name (str): The name of the activity.
+            day (str): The day in 'YYYY-MM-DD' format.
+
+        Returns:
+            DataFrame: A DataFrame containing available slots.
+
+        Raises:
+            ValueError: If the specified activity is not found.
+            RuntimeError: If slots cannot be fetched.
+        """
+        logger.info(f"Fetching daily slots for '{activity_name}' on {day}...")
+
+        # Check if the activity exists
+        activity_match = df_activities[df_activities["name_activity"] == activity_name]
+        if activity_match.empty:
+            error_msg = ErrorMessages.activity_not_found(
+                activity_name, df_activities["name_activity"].unique().tolist()
+            )
+            logger.error(error_msg)
+            raise ValueError(error_msg)
+
+        # Extract activity ID
+        activity_id = str(activity_match.id_activity.iloc[0])
+        id_category_activity = df_activities.loc[activity_id].activityCategoryId
+
+        # Get Unix timestamp bounds for the day
+        unix_day_bounds = get_unix_day_bounds(day)
+
+        # Fetch slots
+        params = {
+            "id_category_activity": id_category_activity,
+            "start": unix_day_bounds[0],
+            "end": unix_day_bounds[1],
+        }
+        response = self.session.get(Endpoints.SLOTS, headers=self.headers, params=params)
+        if response.status_code != 200:
+            error_msg = ErrorMessages.failed_fetch("slots")
+            logger.error(error_msg)
+            raise RuntimeError(error_msg)
+
+        slots = json.loads(response.content.decode("utf-8"))
+        if not slots:
+            warning_msg = ErrorMessages.no_slots(activity_name, day)
+            logger.warning(warning_msg)
+            return DataFrame()
+
+        logger.info(f"Daily slots fetched for '{activity_name}' on {day}.")
+
+        # Filter desired columns
+        columns = [
+            "name_activity",
+            "id_activity_calendar",
+            "id_activity",
+            "id_category_activity",
+            "start_timestamp",
+            "end_timestamp",
+            "n_inscribed",
+            "capacity",
+            "n_waiting_list",
+            "cancelled",
+            "can_join",
+            "trainer",
+        ]
+        df_slots = pd.DataFrame(slots)
+        df_slots = df_slots[df_slots.columns.intersection(columns)]  # Ensure no KeyError
+
+        # Only select rows of the specified activity
+        df_slots = df_slots[df_slots.id_activity == activity_id]
+        if df_slots.empty:
+            warning_msg = ErrorMessages.no_matching_slots(activity_name, day)
+            logger.warning(warning_msg)
+            return DataFrame()
+
+        return df_slots

pysportbot/authenticator.py

@@ -0,0 +1,118 @@
+import ast
+import json
+from urllib.parse import parse_qs
+
+from bs4 import BeautifulSoup
+
+from .endpoints import Endpoints
+from .session import Session
+from .utils.errors import ErrorMessages
+from .utils.logger import get_logger
+
+logger = get_logger(__name__)
+
+
+class Authenticator:
+    """Handles user authentication and Nubapp login functionality."""
+
+    def __init__(self, session: Session, centre: str) -> None:
+        """
+        Initialize the Authenticator.
+
+        Args:
+            session (Session): An instance of the Session class.
+        """
+        self.session = session.session
+        self.headers = session.headers
+        # Has the user successfully authenticated?
+        self.authenticated = False
+        # User ID for the authenticated user
+        self.user_id = None
+        # Centre selected by the user
+        self.centre = centre
+
+    def login(self, email: str, password: str) -> None:
+        """
+        Authenticate the user with email and password and log in to Nubapp.
+
+        Args:
+            email (str): The user's email address.
+            password (str): The user's password.
+
+        Raises:
+            RuntimeError: If the login process fails at any stage.
+        """
+        logger.info("Starting login process...")
+
+        # Step 1: Fetch CSRF token
+        logger.debug(f"GET {Endpoints.USER_LOGIN} | Headers: {json.dumps(self.headers, indent=2)}")
+        response = self.session.get(Endpoints.USER_LOGIN, headers=self.headers)
+        if response.status_code != 200:
+            logger.error(f"Failed to fetch login popup: {response.status_code}")
+            raise RuntimeError(ErrorMessages.failed_fetch("login popup"))
+        logger.debug("Login popup fetched successfully.")
+        csrf_token = BeautifulSoup(response.text, "html.parser").find("input", {"name": "_csrf_token"})["value"]
+
+        # Step 2: Perform login
+        payload = {
+            "_username": email,
+            "_password": password,
+            "_csrf_token": csrf_token,
+            "_submit": "",
+            "_force": "true",
+        }
+        self.headers.update({"Content-Type": "application/x-www-form-urlencoded"})
+        logger.debug(
+            f"POST {Endpoints.LOGIN_CHECK} | Headers: {json.dumps(self.headers, indent=2)} | "
+            f"Payload: {json.dumps(payload, indent=2)}"
+        )
+        response = self.session.post(Endpoints.LOGIN_CHECK, data=payload, headers=self.headers)
+        if response.status_code != 200:
+            logger.error(f"Login failed: {response.status_code}, {response.text}")
+            raise ValueError(ErrorMessages.failed_login())
+        logger.info("Login successful!")
+
+        # Step 3: Retrieve credentials for Nubapp
+        cred_endpoint = Endpoints.get_cred_endpoint(self.centre)
+        logger.debug(f"GET {cred_endpoint} | Headers: {json.dumps(self.headers, indent=2)}")
+        response = self.session.get(cred_endpoint, headers=self.headers)
+        if response.status_code != 200:
+            logger.error(f"Failed to retrieve Nubapp credentials: {response.status_code}")
+            raise RuntimeError(ErrorMessages.failed_fetch("credentials"))
+        nubapp_creds = ast.literal_eval(response.content.decode("utf-8"))["payload"]
+        nubapp_creds = {k: v[0] for k, v in parse_qs(nubapp_creds).items()}
+        nubapp_creds["platform"] = "resasocial"
+        nubapp_creds["network"] = "resasports"
+        logger.debug(f"Nubapp credentials retrieved: {json.dumps(nubapp_creds, indent=2)}")
+
+        # Step 4: Log in to Nubapp
+        logger.debug(
+            f"GET {Endpoints.NUBAP_LOGIN} | Headers: {json.dumps(self.headers, indent=2)} | "
+            f"Params: {json.dumps(nubapp_creds, indent=2)}"
+        )
+        response = self.session.get(Endpoints.NUBAP_LOGIN, headers=self.headers, params=nubapp_creds)
+        if response.status_code != 200:
+            logger.error(f"Login to Nubapp failed: {response.status_code}, {response.text}")
+            raise ValueError(ErrorMessages.failed_login_nubapp())
+        logger.info("Login to Nubapp successful!")
+
+        # Step 5: Get user information
+        response = self.session.post(Endpoints.USER, headers=self.headers, allow_redirects=True)
+
+        if response.status_code == 200:
+            response_dict = json.loads(response.content.decode("utf-8"))
+
+            if response_dict["user"]:
+                self.user_id = response_dict.get("user", {}).get("id_user")
+                if self.user_id:
+                    self.authenticated = True
+                    logger.info(f"Authentication successful. User ID: {self.user_id}")
+                else:
+                    self.authenticated = False
+                    raise ValueError()
+            else:
+                self.authenticated = False
+                raise ValueError(ErrorMessages.failed_login())
+        else:
+            logger.error(f"Failed to retrieve user information: {response.status_code}, {response.text}")
+            raise ValueError(ErrorMessages.failed_login())

pysportbot/bookings.py

@@ -0,0 +1,87 @@
+import json
+
+from .endpoints import Endpoints
+from .session import Session
+from .utils.errors import ErrorMessages
+from .utils.logger import get_logger
+
+logger = get_logger(__name__)
+
+
+class Bookings:
+    """Handles booking and cancellation of activity slots."""
+
+    def __init__(self, session: Session) -> None:
+        """Initialize the Bookings class."""
+        self.session = session.session
+        self.headers = session.headers
+
+    def book(self, slot_id: str) -> None:
+        """
+        Book a specific slot by its ID.
+
+        Args:
+            slot_id (str): The unique ID of the activity slot.
+
+        Raises:
+            ValueError: If the slot is already booked or unavailable.
+            RuntimeError: If an unknown error occurs during booking.
+        """
+        logger.info(f"Attempting to book slot {slot_id}...")
+
+        # Payload for booking
+        payload = {
+            "items[activities][0][id_activity_calendar]": slot_id,
+            "items[activities][0][unit_price]": "0",
+            "items[activities][0][n_guests]": "0",
+            "items[activities][0][id_resource]": "false",
+            "discount_code": "false",
+            "form": "",
+            "formIntoNotes": "",
+        }
+
+        # Send booking request
+        response = self.session.post(Endpoints.BOOKING, data=payload, headers=self.headers)
+        response_json = json.loads(response.content.decode("utf-8"))
+
+        # Handle response
+        if response_json["error"] == 0:
+            logger.info(f"Successfully booked slot {slot_id}.")
+        elif response_json["error"] == 5:
+            logger.warning(f"Slot {slot_id} is already booked.")
+            raise ValueError(ErrorMessages.slot_already_booked())
+        elif response_json["error"] == 6:
+            logger.warning(f"Slot {slot_id} is not available.")
+            raise ValueError(ErrorMessages.slot_unavailable())
+        elif response_json["error"] == 28:
+            logger.warning(f"Slot {slot_id} is not bookable yet.")
+            raise ValueError(ErrorMessages.slot_not_bookable_yet())
+        else:
+            logger.error(f"Booking failed with error code: {response_json['error']}")
+            raise RuntimeError(ErrorMessages.unknown_error("booking"))
+
+    def cancel(self, slot_id: str) -> None:
+        """
+        Cancel a specific slot by its ID.
+
+        Args:
+            slot_id (str): The unique ID of the activity slot.
+
+        Raises:
+            ValueError: If the cancellation fails.
+        """
+        logger.info(f"Attempting to cancel slot {slot_id}...")
+
+        # Payload for cancellation
+        payload = {"id_activity_calendar": slot_id}
+
+        # Send cancellation request
+        response = self.session.post(Endpoints.CANCELLATION, data=payload, headers=self.headers)
+        response_json = json.loads(response.content.decode("utf-8"))
+
+        # Handle response
+        if response_json["success"]:
+            logger.info(f"Successfully cancelled slot {slot_id}.")
+        else:
+            logger.warning(f"Slot {slot_id} was not booked.")
+            raise ValueError(ErrorMessages.cancellation_failed())

pysportbot/centres.py

@@ -0,0 +1,108 @@
+# centres.py
+
+import json
+import logging
+
+import pandas as pd
+import requests
+from pandas import DataFrame
+
+from pysportbot.utils.logger import get_logger
+
+from .endpoints import Endpoints
+from .utils.errors import ErrorMessages
+
+logger = get_logger(__name__)
+
+
+class Centres:
+    """
+    Manages fetching and storing the list of available centres
+    from the Resasports service.
+    """
+
+    def __init__(self, print_centres: bool = False) -> None:
+        # Coordinates for the bounding box of the world
+        # Set to the entire world by default
+        self.bounds: dict = {
+            "bounds": {
+                "south": -90,
+                "west": -180,
+                "north": 90,
+                "east": 180,
+            }
+        }
+        self._df_centres = self.fetch_centres()
+        if print_centres:
+            self.print_centres()
+
+        # list of centre (slugs)
+        self.centre_list = self._df_centres["slug"].tolist()
+
+    def check_centre(self, centre: str) -> None:
+        """
+        Set the user selected centre.
+        """
+        if centre not in self.centre_list:
+            logger.error(ErrorMessages.centre_not_found(centre))
+            self.print_centres()
+            raise ValueError(ErrorMessages.centre_not_found(centre))
+
+    def fetch_centres(self) -> DataFrame:
+        """
+        Fetches the info of available centres from Resasports and returns a DataFrame.
+        """
+        try:
+            response = requests.post(
+                Endpoints.CENTRE,
+                json=self.bounds,
+                timeout=10,
+            )
+            response.raise_for_status()
+
+            # Parse the JSON content
+            response_json = json.loads(response.content.decode("utf-8"))
+            # Flatten and extract the desired columns
+            df = pd.json_normalize(response_json["applications"])
+            df = df[["slug", "name", "address.town", "address.country", "address.street_line"]]
+            df.columns = ["slug", "name", "town", "country", "address"]
+
+            if df is None or df.empty:
+                logging.error("Failed to fetch centres.")
+                self._raise_fetch_error()  # Fix for TRY301: abstract raise
+            else:
+                return df
+
+        except Exception:
+            logging.exception("Failed to fetch centres")
+            return pd.DataFrame()
+
+    def _raise_fetch_error(self) -> None:
+        """
+        Helper function to raise a ValueError for failed centre fetches.
+        """
+        raise ValueError("Failed to fetch centres.")
+
+    def print_centres(self, cols: int = 4, col_width: int = 40) -> None:
+        """
+        Prints the stored list of centres to the console.
+        """
+        lines = []
+        for i, name in enumerate(self.centre_list):
+            # Use ljust or rjust to format columns
+            name_column = name[:col_width].ljust(col_width)
+            # Insert a newline after every 'cols' items
+            if (i + 1) % cols == 0:
+                lines.append(name_column + "\n")
+            else:
+                lines.append(name_column)
+
+        final_str = "".join(lines)
+        logger.info(f"Available centres:\n{final_str}")
+
+    @property
+    def df_centres(self) -> DataFrame | None:
+        """
+        Returns the stored DataFrame of centres (or None if fetch_centres hasn't been called).
+        """
+        return self._df_centres

pysportbot/endpoints.py

@@ -0,0 +1,40 @@
+from enum import Enum
+
+
+class Endpoints(str, Enum):
+    """
+    Enum class for API endpoints used in the application.
+    Each member is a string, so you can use them directly.
+    """
+
+    # Base URLs
+    BASE_SOCIAL = "https://social.resasports.com"
+    BASE_NUBAPP = "https://sport.nubapp.com/web"
+
+    # Centre list
+    CENTRE = f"{BASE_SOCIAL}/ajax/applications/bounds/"
+
+    # Authentication Endpoints
+    USER_LOGIN = f"{BASE_SOCIAL}/popup/login"
+    LOGIN_CHECK = f"{BASE_SOCIAL}/popup/login_check"
+    NUBAP_LOGIN = f"{BASE_NUBAPP}/resources/login_from_social.php"
+
+    # User, activities, and slots
+    USER = f"{BASE_NUBAPP}/ajax/users/getUser.php"
+    ACTIVITIES = f"{BASE_NUBAPP}/ajax/application/getActivities.php"
+    SLOTS = f"{BASE_NUBAPP}/ajax/activities/getActivitiesCalendar.php"
+
+    # Booking and Cancellation
+    BOOKING = f"{BASE_NUBAPP}/ajax/bookings/bookBookings.php"
+    CANCELLATION = f"{BASE_NUBAPP}/ajax/activities/leaveActivityCalendar.php"
+
+    @classmethod
+    def get_cred_endpoint(cls, centre_slug: str) -> str:
+        """
+        Build the booking request URL for a given centre slug.
+        """
+        return f"{cls.BASE_SOCIAL}/ajax/application/{centre_slug}/book/request"
+
+    def __str__(self) -> str:
+        """Return the underlying string value instead of the member name."""
+        return str(self.value)

pysportbot/service/__main__.py

@@ -0,0 +1,32 @@
+#!/usr/bin/env python3
+
+import argparse
+from typing import Any, Dict
+
+from .config_loader import load_config
+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("--time_zone", type=str, default="Europe/Madrid", help="Timezone for the service.")
+    args = parser.parse_args()
+
+    config: Dict[str, Any] = load_config(args.config)
+    run_service(
+        config,
+        offset_seconds=args.offset_seconds,
+        retry_attempts=args.retry_attempts,
+        retry_delay_minutes=args.retry_delay_minutes,
+        time_zone=args.time_zone,
+    )
+
+
+if __name__ == "__main__":
+    main()