pysportbot 0.0.10__tar.gz → 0.0.12__tar.gz

{pysportbot-0.0.10 → pysportbot-0.0.12}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: pysportbot
-Version: 0.0.10
+Version: 0.0.12
 Summary: A python-based bot for automatic resasports slot booking
 Author: Joshua Falco Beirer
 Author-email: jbeirer@cern.ch

{pysportbot-0.0.10 → pysportbot-0.0.12}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "pysportbot"
-version = "v0.0.10"
+version = "v0.0.12"
 description = "A python-based bot for automatic resasports slot booking"
 authors = [
   { name = "Joshua Falco Beirer", email = "jbeirer@cern.ch" }
@@ -110,7 +110,9 @@ lint.ignore = [
     # Long exception message
     "TRY003",
     # Module shadows a Python standard-library module
-    "A005"
+    "A005",
+    # Use `logging.exception` instead of `logging.error`
+    "TRY400"
 ]
 
 [tool.coverage.report]

{pysportbot-0.0.10 → pysportbot-0.0.12}/pysportbot/__init__.py

@@ -49,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
 
@@ -83,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())
@@ -92,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:
 
@@ -131,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.10 → pysportbot-0.0.12}/pysportbot/service/booking.py

@@ -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...")
@@ -119,20 +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"]
 
-    # Global booking delay
-    logger.info(f"Waiting {booking_delay} seconds before attempting booking.")
-    time.sleep(booking_delay)
+    # 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.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
+        # 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
+    if booking_delay > 0:
+        logger.info(f"Waiting {booking_delay} seconds before attempting booking.")
+        time.sleep(booking_delay)
 
     # Submit bookings in parallel
     with ThreadPoolExecutor(max_workers=max_threads) as executor:
@@ -156,4 +158,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.10 → pysportbot-0.0.12}/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."""