pysportbot 0.0.9__tar.gz → 0.0.11__tar.gz

{pysportbot-0.0.9 → pysportbot-0.0.11}/PKG-INFO

@@ -1,12 +1,11 @@
 Metadata-Version: 2.3
 Name: pysportbot
-Version: 0.0.9
+Version: 0.0.11
 Summary: A python-based bot for automatic resasports slot booking
 Author: Joshua Falco Beirer
 Author-email: jbeirer@cern.ch
-Requires-Python: >=3.9,<3.14
+Requires-Python: >=3.10,<3.14
 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

{pysportbot-0.0.9 → pysportbot-0.0.11}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "pysportbot"
-version = "v0.0.9"
+version = "v0.0.11"
 description = "A python-based bot for automatic resasports slot booking"
 authors = [
   { name = "Joshua Falco Beirer", email = "jbeirer@cern.ch" }
@@ -14,7 +14,7 @@ packages = [
 dynamic = ["requires-python", "dependencies"]
 
 [tool.poetry.dependencies]
-python = ">=3.9,<3.14"
+python = ">=3.10,<3.14"
 requests = "^2.32.3"
 beautifulsoup4 = "^4.12.3"
 pandas = "^2.2.3"
@@ -23,8 +23,8 @@ pytz = "^2024.2"
 [tool.poetry.group.dev.dependencies]
 pytest = "^8.3.4"
 pytest-cov = "^6.0.0"
-deptry = "^0.21.2"
-mypy = "^1.14.0"
+deptry = "^0.22.0"
+mypy = "^1.14.1"
 pre-commit = "^4.0.1"
 tox = "^4.23.2"
 ipykernel = "^6.29.5"
@@ -37,12 +37,12 @@ mkdocs-material = "^9.5.49"
 mkdocstrings = {extras = ["python"], version = "^0.27.0"}
 
 [build-system]
-requires = ["poetry-core>=1.9.1"]
+requires = ["poetry-core>=2.0.1"]
 build-backend = "poetry.core.masonry.api"
 
 [tool.black]
 line-length = 120
-target-version = ['py37']
+target-version = ['py313']
 preview = true
 
 [tool.mypy]
@@ -65,7 +65,7 @@ filterwarnings = [
 ]
 
 [tool.ruff]
-target-version = "py37"
+target-version = "py313"
 line-length = 120
 fix = true
 lint.select = [
@@ -108,7 +108,11 @@ lint.ignore = [
     # Comparison to true should be 'if cond is true:'
     "E712",
     # Long exception message
-    "TRY003"
+    "TRY003",
+    # Module shadows a Python standard-library module
+    "A005",
+    # Use `logging.exception` instead of `logging.error`
+    "TRY400"
 ]
 
 [tool.coverage.report]

{pysportbot-0.0.9 → pysportbot-0.0.11}/pysportbot/__init__.py

@@ -1,7 +1,6 @@
 # pysportbot/sportbot.py
 
 import logging
-from typing import Optional
 
 from pandas import DataFrame
 
@@ -25,7 +24,7 @@ class SportBot:
         self._logger.info(f"Time zone: {time_zone}")
         self._centres = Centres(print_centres)
         self._session: Session = Session()
-        self._auth: Optional[Authenticator] = None
+        self._auth: Authenticator | None = None
         self._activities: Activities = Activities(self._session)
         self._bookings: Bookings = Bookings(self._session)
         self._df_activities: DataFrame | None = None
@@ -50,7 +49,7 @@ class SportBot:
             self._is_logged_in = True
             self._logger.info("Login successful!")
         except Exception:
-            self._is_logged_in = False  # Ensure state is False on failure
+            self._is_logged_in = False
             self._logger.exception(ErrorMessages.login_failed())
             raise
 
@@ -84,7 +83,6 @@ class SportBot:
 
     def book(self, activity: str, start_time: str) -> None:
 
-        self._logger.debug(f"Attempting to book class '{activity}' on {start_time}")
         if not self._is_logged_in:
             self._logger.error(ErrorMessages.not_logged_in())
             raise PermissionError(ErrorMessages.not_logged_in())
@@ -93,21 +91,42 @@ class SportBot:
             self._logger.error(ErrorMessages.no_activities_loaded())
             raise ValueError(ErrorMessages.no_activities_loaded())
 
+        # Fetch the daily slots for the activity
         slots = self.daily_slots(activity, start_time.split(" ")[0])
+
+        # Find the slot that matches the start time
         matching_slot = slots[slots["start_timestamp"] == start_time]
+
+        # If no matching slot is found, raise an error
         if matching_slot.empty:
             error_msg = ErrorMessages.slot_not_found(activity, start_time)
             self._logger.error(error_msg)
             raise IndexError(error_msg)
 
-        slot_id = matching_slot.iloc[0]["id_activity_calendar"]
-
+        # The targeted slot
+        target_slot = matching_slot.iloc[0]
+        # The unique slot ID
+        slot_id = target_slot["id_activity_calendar"]
+        # The total member capacity of the slot
+        slot_capacity = target_slot["capacity"]
+        # The number of members already inscribed in the slot
+        slot_n_inscribed = target_slot["n_inscribed"]
+        # Log slot capacity
+        self._logger.info(
+            f"Attempting to book class '{activity}' on {start_time} with ID {slot_id} (Slot capacity: {slot_n_inscribed}/{slot_capacity})"
+        )
+
+        # Check if the slot is already booked out
+        if slot_n_inscribed >= slot_capacity:
+            self._logger.error(f"Activity '{activity}' on {start_time} with ID {slot_id} is booked out...")
+            raise ValueError(ErrorMessages.slot_capacity_full())
+
+        # Attempt to book the slot
         try:
             self._bookings.book(slot_id)
             self._logger.info(f"Successfully booked class '{activity}' on {start_time}")
         except ValueError:
-            self._logger.exception(f"Failed to book class '{activity}' on {start_time}")
-            raise
+            self._logger.error(f"Failed to book class '{activity}' on {start_time}")
 
     def cancel(self, activity: str, start_time: str) -> None:
 
@@ -132,5 +151,4 @@ class SportBot:
             self._bookings.cancel(slot_id)
             self._logger.info(f"Successfully cancelled class '{activity}' on {start_time}")
         except ValueError:
-            self._logger.exception(f"Failed to cancel class '{activity}' on {start_time}")
-            raise
+            self._logger.error(f"Failed to cancel class '{activity}' on {start_time}")

{pysportbot-0.0.9 → pysportbot-0.0.11}/pysportbot/service/__main__.py

@@ -1,7 +1,7 @@
 #!/usr/bin/env python3
 
 import argparse
-from typing import Any, Dict
+from typing import Any
 
 from .config_loader import load_config
 from .service import run_service
@@ -23,7 +23,7 @@ def main() -> None:
     )
     args = parser.parse_args()
 
-    config: Dict[str, Any] = load_config(args.config)
+    config: dict[str, Any] = load_config(args.config)
     run_service(
         config,
         booking_delay=args.booking_delay,

{pysportbot-0.0.9 → pysportbot-0.0.11}/pysportbot/service/booking.py

@@ -1,7 +1,7 @@
 import time
 from concurrent.futures import ThreadPoolExecutor, as_completed
 from datetime import datetime
-from typing import Any, Dict
+from typing import Any
 
 import pytz
 
@@ -14,31 +14,6 @@ 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:
-    """
-    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.
-    """
-    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,
     activity: str,
@@ -64,23 +39,19 @@ def attempt_booking(
         booking_date = calculate_class_day(class_day, time_zone).strftime("%Y-%m-%d")
 
         try:
-            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)
-
-            slot_id = matching_slots.iloc[0]["start_timestamp"]
-            logger.info(f"Attempting to book '{activity}' at {slot_id} (Attempt {attempt_num}/{retry_attempts}).")
-            bot.book(activity=activity, start_time=slot_id)
+            bot.book(activity=activity, start_time=f"{booking_date} {class_time}")
 
         except Exception as e:
             error_str = str(e)
             logger.warning(f"Attempt {attempt_num} failed: {error_str}")
 
+            # Decide whether to retry based on the error message
             if ErrorMessages.slot_already_booked() in error_str:
                 logger.warning("Slot already booked; skipping further retries.")
                 return
+            if ErrorMessages.slot_capacity_full() in error_str:
+                logger.warning("Slot capacity full; skipping further retries.")
+                return
 
             if attempt_num < retry_attempts:
                 logger.info(f"Retrying in {retry_delay} seconds...")
@@ -95,7 +66,7 @@ def attempt_booking(
 
 def schedule_bookings(
     bot: SportBot,
-    config: Dict[str, Any],
+    config: dict[str, Any],
     booking_delay: int,
     retry_attempts: int,
     retry_delay: int,
@@ -119,21 +90,51 @@ def schedule_bookings(
     for cls in config["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(config["booking_execution"], time_zone)
+    # Booking execution day and time
+    booking_execution = config["booking_execution"]
+
+    # Exact time when booking will be executed (modulo global booking delay)
+    execution_time = calculate_next_execution(booking_execution, time_zone)
+
+    # Get the time now
+    now = datetime.now(pytz.timezone(time_zone))
+
+    # Calculate the seconds until execution
+    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')}."
+        )
+        # Re-authenticate 60 seconds before booking execution
+        reauth_time = time_until_execution - 60
+
+        if reauth_time <= 0:
+            logger.debug("Less than 60 seconds remain until execution; re-authenticating now.")
+        else:
+            logger.debug(f"Re-authenticating in {reauth_time:.2f} seconds.")
+            time.sleep(reauth_time)
+
+        # Re-authenticate before booking
+        logger.info("Re-authenticating before booking.")
+        try:
+            bot.login(config["email"], config["password"], config["centre"])
+        except Exception:
+            logger.warning("Re-authentication failed before booking execution.")
+
+        # Wait the remaining time until execution
+        now = datetime.now(pytz.timezone(time_zone))
+        remaining_time = (execution_time - now).total_seconds()
+        if remaining_time > 0:
+            logger.info(f"Waiting {remaining_time:.2f} seconds until booking execution.")
+            time.sleep(remaining_time)
 
     # Global booking delay
     logger.info(f"Waiting {booking_delay} seconds before attempting booking.")
     time.sleep(booking_delay)
 
-    # Re-authenticate before booking
-    logger.debug("Re-authenticating before booking.")
-    try:
-        bot.login(config["email"], config["password"], config["centre"])
-    except Exception:
-        logger.exception("Re-authentication failed before booking execution.")
-        raise
-
     # Submit bookings in parallel
     with ThreadPoolExecutor(max_workers=max_threads) as executor:
         future_to_class = {
@@ -156,4 +157,4 @@ def schedule_bookings(
             try:
                 future.result()
             except Exception:
-                logger.exception(f"Booking for '{activity}' at {class_time} failed.")
+                logger.error(f"Booking for '{activity}' at {class_time} failed.")

pysportbot-0.0.11/pysportbot/service/config_loader.py

@@ -0,0 +1,7 @@
+import json
+from typing import Any, 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-0.0.9 → pysportbot-0.0.11}/pysportbot/service/config_validator.py

@@ -1,5 +1,5 @@
 from datetime import datetime
-from typing import Any, Dict
+from typing import Any
 
 from pysportbot import SportBot
 from pysportbot.utils.errors import ErrorMessages
@@ -10,7 +10,7 @@ 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:
+def validate_config(config: dict[str, Any]) -> None:
     """
     Validate the overall configuration structure and values.
 
@@ -48,7 +48,7 @@ def validate_config(config: Dict[str, Any]) -> None:
             raise ValueError(ErrorMessages.invalid_class_definition())
 
 
-def validate_activities(bot: SportBot, config: Dict[str, Any]) -> None:
+def validate_activities(bot: SportBot, config: dict[str, Any]) -> None:
     """
     Validate that all activities specified in the configuration exist.
 

{pysportbot-0.0.9 → pysportbot-0.0.11}/pysportbot/service/service.py

@@ -1,4 +1,4 @@
-from typing import Any, Dict
+from typing import Any
 
 from pysportbot import SportBot
 from pysportbot.service.booking import schedule_bookings
@@ -8,7 +8,7 @@ from pysportbot.utils.logger import get_logger
 
 
 def run_service(
-    config: Dict[str, Any],
+    config: dict[str, Any],
     booking_delay: int,
     retry_attempts: int,
     retry_delay: int,

{pysportbot-0.0.9 → pysportbot-0.0.11}/pysportbot/utils/errors.py

@@ -115,6 +115,11 @@ class ErrorMessages:
         """Return an error message for a slot that is unavailable."""
         return "The slot is not available."
 
+    @staticmethod
+    def slot_capacity_full() -> str:
+        """Return an error message for a slot that is full."""
+        return "The slot is full. Cannot book."
+
     @staticmethod
     def cancellation_failed() -> str:
         """Return an error message for a failed cancellation."""

{pysportbot-0.0.9 → pysportbot-0.0.11}/pysportbot/utils/logger.py

@@ -1,7 +1,7 @@
 import logging
 import threading
 from datetime import datetime
-from typing import ClassVar, Optional
+from typing import ClassVar
 
 import pytz
 
@@ -52,7 +52,7 @@ class ColorFormatter(logging.Formatter):
         self.include_threads = include_threads
         self.thread_colors: dict[str, str] = {}  # Initialize empty dictionary
 
-    def formatTime(self, record: logging.LogRecord, datefmt: Optional[str] = None) -> str:
+    def formatTime(self, record: logging.LogRecord, datefmt: str | None = None) -> str:
         """
         Override to format the time in the desired timezone.
         """

pysportbot-0.0.9/pysportbot/service/config_loader.py

@@ -1,7 +0,0 @@
-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))