pysportbot 0.0.1__tar.gz

pysportbot-0.0.1/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.

pysportbot-0.0.1/PKG-INFO

@@ -0,0 +1,148 @@
+Metadata-Version: 2.1
+Name: pysportbot
+Version: 0.0.1
+Summary:  A python-based bot for automatic resasports slot booking
+Home-page: https://github.com/jbeirer/pysportbot
+Author: Joshua Falco Beirer
+Author-email: jbeirer@cern.ch
+Requires-Python: >=3.9,<3.13
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+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/pysportbot/
+Project-URL: Repository, https://github.com/jbeirer/pysportbot
+Description-Content-Type: text/markdown
+
+# No queues. Just gains.
+
+<img src=https://github.com/jbeirer/resasports-bot/raw/main/docs/logo.png alt="Logo" width="250">
+
+
+[![Release](https://img.shields.io/github/v/release/jbeirer/resasports-bot)](https://img.shields.io/github/v/release/jbeirer/resasports-bot)
+[![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://img.shields.io/github/commit-activity/m/jbeirer/resasports-bot)
+[![License](https://img.shields.io/github/license/jbeirer/resasports-bot)](https://img.shields.io/github/license/jbeirer/resasports-bot)
+
+
+Welcome to pysportbot!
+
+## Download pysportbot
+```python
+pip install pysportbot
+```
+
+## Quick Start
+
+```python
+from pysportbot import SportBot
+
+# Create bot instance, will list available centres is requested
+bot = SportBot(log_level='INFO', print_centres=False)
+
+# Connect to service with email and password as well as the name of the centre
+bot.login('email', 'password', 'centre')
+
+# List available activites
+bot.activities(limit = 10)
+
+# List bookable slots for an activity on a specific day
+bot.daily_slots(activity='YourFavouriteGymClass', day = '2025-01-03', limit = 10)
+
+# Book an activity slot on a specific day and time
+bot.book(activity='YourFavouriteGymClass', start_time = '2024-12-30 07:00:00')
+
+# Cancel an activity slot ona specific day and time
+bot.cancel(activity='YourFavouriteGymClass', start_time = '2024-12-30 07:00:00')
+```
+
+## Advanced usage as service
+
+You can easily run `pysportbot` as a service to manage your bookings automatically with
+```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:
+
+##### 1. Book an upcoming class now
+
+Let's say you would like to book Yoga next Monday at 18:00:00, then your `config.json` would look like:
+
+```json
+{
+    "email": "your-email",
+    "password": "your-password",
+    "center": "your-gym-name",
+    "classes": [
+        {
+            "activity": "Yoga",
+            "class_day": "Monday",
+            "class_time": "18:00:00",
+            "booking_execution": "now",
+            "weekly": false
+        }
+    ]
+}
+```
+##### 2. Book an upcoming class on a specific day and time
+
+Let's say you would like to book Yoga next Monday at 18:00:00, but the execution of the booking should only happen on Friday at 07:30:00 then your `config.json` would look like:
+
+```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": 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:
+
+```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
+        }
+    ]
+}
+```
+
+The service also provides various other options that can be inspected with
+
+```bash
+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
+3. ```--time_zone``` sets the time zone for the service
+
+## LICENSE
+
+pysportbot is free of use and open-source. All versions are
+published under the [MIT License](https://github.com/jbeirer/pysportbot/blob/main/LICENSE).
+

pysportbot-0.0.1/README.md

@@ -0,0 +1,125 @@
+# No queues. Just gains.
+
+<img src=https://github.com/jbeirer/resasports-bot/raw/main/docs/logo.png alt="Logo" width="250">
+
+
+[![Release](https://img.shields.io/github/v/release/jbeirer/resasports-bot)](https://img.shields.io/github/v/release/jbeirer/resasports-bot)
+[![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://img.shields.io/github/commit-activity/m/jbeirer/resasports-bot)
+[![License](https://img.shields.io/github/license/jbeirer/resasports-bot)](https://img.shields.io/github/license/jbeirer/resasports-bot)
+
+
+Welcome to pysportbot!
+
+## Download pysportbot
+```python
+pip install pysportbot
+```
+
+## Quick Start
+
+```python
+from pysportbot import SportBot
+
+# Create bot instance, will list available centres is requested
+bot = SportBot(log_level='INFO', print_centres=False)
+
+# Connect to service with email and password as well as the name of the centre
+bot.login('email', 'password', 'centre')
+
+# List available activites
+bot.activities(limit = 10)
+
+# List bookable slots for an activity on a specific day
+bot.daily_slots(activity='YourFavouriteGymClass', day = '2025-01-03', limit = 10)
+
+# Book an activity slot on a specific day and time
+bot.book(activity='YourFavouriteGymClass', start_time = '2024-12-30 07:00:00')
+
+# Cancel an activity slot ona specific day and time
+bot.cancel(activity='YourFavouriteGymClass', start_time = '2024-12-30 07:00:00')
+```
+
+## Advanced usage as service
+
+You can easily run `pysportbot` as a service to manage your bookings automatically with
+```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:
+
+##### 1. Book an upcoming class now
+
+Let's say you would like to book Yoga next Monday at 18:00:00, then your `config.json` would look like:
+
+```json
+{
+    "email": "your-email",
+    "password": "your-password",
+    "center": "your-gym-name",
+    "classes": [
+        {
+            "activity": "Yoga",
+            "class_day": "Monday",
+            "class_time": "18:00:00",
+            "booking_execution": "now",
+            "weekly": false
+        }
+    ]
+}
+```
+##### 2. Book an upcoming class on a specific day and time
+
+Let's say you would like to book Yoga next Monday at 18:00:00, but the execution of the booking should only happen on Friday at 07:30:00 then your `config.json` would look like:
+
+```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": 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:
+
+```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
+        }
+    ]
+}
+```
+
+The service also provides various other options that can be inspected with
+
+```bash
+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
+3. ```--time_zone``` sets the time zone for the service
+
+## LICENSE
+
+pysportbot is free of use and open-source. All versions are
+published under the [MIT License](https://github.com/jbeirer/pysportbot/blob/main/LICENSE).

pysportbot-0.0.1/pyproject.toml

@@ -0,0 +1,121 @@
+[tool.poetry]
+name = "pysportbot"
+version = "v0.0.1"
+description = " A python-based bot for automatic resasports slot booking"
+authors = ["Joshua Falco Beirer <jbeirer@cern.ch>"]
+repository = "https://github.com/jbeirer/pysportbot"
+documentation = "https://jbeirer.github.io/pysportbot/"
+readme = "README.md"
+packages = [
+  {include = "pysportbot"}
+]
+
+[tool.poetry.dependencies]
+python = ">=3.9,<3.13"
+requests = "^2.32.3"
+beautifulsoup4 = "^4.12.3"
+pandas = "^2.2.3"
+pytz = "^2024.2"
+schedule = "^1.2.2"
+
+[tool.poetry.group.dev.dependencies]
+pytest = "^8.3.4"
+pytest-cov = "^6.0.0"
+deptry = "^0.21.2"
+mypy = "^1.14.0"
+pre-commit = "^4.0.1"
+tox = "^4.23.2"
+ipykernel = "^6.29.5"
+types-pytz = "^2024.2.0.20241221"
+types-requests = "^2.32.0.20241016"
+
+[tool.poetry.group.docs.dependencies]
+mkdocs = "^1.6.1"
+mkdocs-material = "^9.5.49"
+mkdocstrings = {extras = ["python"], version = "^0.27.0"}
+
+[build-system]
+requires = ["poetry-core>=1.9.1"]
+build-backend = "poetry.core.masonry.api"
+
+[tool.black]
+line-length = 120
+target-version = ['py37']
+preview = true
+
+[tool.mypy]
+files = ["pysportbot"]
+disallow_untyped_defs = "True"
+no_implicit_optional = "True"
+check_untyped_defs = "True"
+warn_return_any = "True"
+warn_unused_ignores = "True"
+show_error_codes = "True"
+ignore_missing_imports= "True"
+disallow_any_unimported = "False"
+
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+# filter deprecation warnings from external packages
+filterwarnings = [
+    "ignore::DeprecationWarning:(?!pysportbot).*",
+]
+
+[tool.ruff]
+target-version = "py37"
+line-length = 120
+fix = true
+lint.select = [
+    # flake8-2020
+    "YTT",
+    # flake8-bandit
+    "S",
+    # flake8-bugbear
+    "B",
+    # flake8-builtins
+    "A",
+    # flake8-comprehensions
+    "C4",
+    # flake8-debugger
+    "T10",
+    # flake8-simplify
+    "SIM",
+    # isort
+    "I",
+    # mccabe
+    "C90",
+    # pycodestyle
+    "E", "W",
+    # pyflakes
+    "F",
+    # pygrep-hooks
+    "PGH",
+    # pyupgrade
+    "UP",
+    # ruff
+    "RUF",
+    # tryceratops
+    "TRY",
+]
+lint.ignore = [
+    # LineTooLong
+    "E501",
+    # DoNotAssignLambda
+    "E731",
+    # Comparison to true should be 'if cond is true:'
+    "E712",
+    # Long exception message
+    "TRY003"
+]
+
+[tool.coverage.report]
+skip_empty = true
+
+[tool.coverage.run]
+branch = true
+source = ["pysportbot"]
+
+
+[tool.ruff.lint.per-file-ignores]
+"tests/*" = ["S101"]

pysportbot-0.0.1/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-0.0.1/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