pysportbot 0.0.10__py3-none-any.whl → 0.0.11__py3-none-any.whl

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/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,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/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.10.dist-info → pysportbot-0.0.11.dist-info}/METADATA

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

{pysportbot-0.0.10.dist-info → pysportbot-0.0.11.dist-info}/RECORD

@@ -1,4 +1,4 @@
-pysportbot/__init__.py,sha256=xrsPD3OrQGbT9ttuMp1vi-i69i4A-ePNc9IoutcJHnk,5620
+pysportbot/__init__.py,sha256=tZwOIuLO1-a3d4KKA5nNfXfN6PjJxem_hxyuff9utk4,6425
 pysportbot/activities.py,sha256=Aq8l570sxqEAKplsEMVkuDoPJJjoaZlIwPh6i64_SJ8,4252
 pysportbot/authenticator.py,sha256=xEU9O6W6Yp9DCueoUD0ASMkm17yvdUZqTvV4h6WlSnI,5012
 pysportbot/bookings.py,sha256=W91AYGPu0sCpGliuiVdlENsoGYzH8P6v-SyKisbSb7g,3127
@@ -6,7 +6,7 @@ pysportbot/centres.py,sha256=FTK-tXUOxiJvLCHP6Bk9XEQKODQZOwwkYLlioSJPBEk,3399
 pysportbot/endpoints.py,sha256=ANh5JAbdzyZQ-i4ODrhYlskPpU1gkBrw9UhMC7kRSvU,1353
 pysportbot/service/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 pysportbot/service/__main__.py,sha256=gsKfDMOmsVC3LHCQs0Dmp7YWJBlZeGcTsX-Mx4mk6ro,1496
-pysportbot/service/booking.py,sha256=ZrfIX0ghp1X_DUtknpQbY-ABi2nWFLZYAXR06cOb4lk,5616
+pysportbot/service/booking.py,sha256=cOUzqbpX6UTlDB5-bQZdiBnc7tdbvBQtJLQNXsM9ZHE,5661
 pysportbot/service/config_loader.py,sha256=t086yaAyAKkCJTpxedwhyJ7QqSf5XROGDzjrFLsUxJE,179
 pysportbot/service/config_validator.py,sha256=0P_pcXU7s3T3asODqFtv3mSp1HyPoVBphE4Qe1mxcps,2615
 pysportbot/service/scheduling.py,sha256=bwqbiQQ9y4ss4UXZkWuOVCgCa9XlZt1n4TT_8z9bD7M,1973
@@ -14,10 +14,10 @@ pysportbot/service/service.py,sha256=eW-roFozDzkK7kTzYbSzNwZhbZpBr-22yUrAHVnrD-0
 pysportbot/service/threading.py,sha256=j0tHgGty8iWDjpZtTzIu-5TUnDb9S6SJErm3QBpG-nY,1947
 pysportbot/session.py,sha256=pTQrz3bGzLYBtzVOgKv04l4UXDSgtA3Infn368bjg5I,1529
 pysportbot/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-pysportbot/utils/errors.py,sha256=mpTeKjOUIxJbOqL6A6apdMb7Cpto86DkrKHWfROXjMc,4979
+pysportbot/utils/errors.py,sha256=IRarfGtk1tETxUGAhPAIbeits_u2tJvVCGTtkHIdYFQ,5146
 pysportbot/utils/logger.py,sha256=ANayMEeeAIVGKvITAxOFm2EdCbzBBTpNywuytAr4Z90,5366
 pysportbot/utils/time.py,sha256=VZSW8AxFIoFD5ZSmLUPcwawp6PmpkcxNjP3Db-Hl_fw,1244
-pysportbot-0.0.10.dist-info/LICENSE,sha256=6ov3DypdEVYpp2pn_B1MniKWO5C9iDA4O6PGcbork6c,1077
-pysportbot-0.0.10.dist-info/METADATA,sha256=tWybhZ0aefyjtkRBAQZzQgALjd7tAOaMXvUPdD-Byvk,5161
-pysportbot-0.0.10.dist-info/WHEEL,sha256=RaoafKOydTQ7I_I3JTrPCg6kUmTgtm4BornzOqyEfJ8,88
-pysportbot-0.0.10.dist-info/RECORD,,
+pysportbot-0.0.11.dist-info/LICENSE,sha256=6ov3DypdEVYpp2pn_B1MniKWO5C9iDA4O6PGcbork6c,1077
+pysportbot-0.0.11.dist-info/METADATA,sha256=uPyuHrJiU-pC1zOVdlKpwgZgowrTLsI_PGZ7IzxbZME,5161
+pysportbot-0.0.11.dist-info/WHEEL,sha256=RaoafKOydTQ7I_I3JTrPCg6kUmTgtm4BornzOqyEfJ8,88
+pysportbot-0.0.11.dist-info/RECORD,,