pysportbot 0.0.6__py3-none-any.whl → 0.0.8__py3-none-any.whl

pysportbot/__init__.py

@@ -18,7 +18,7 @@ class SportBot:
     """Unified interface for interacting with the booking system."""
 
     def __init__(self, log_level: str = "INFO", print_centres: bool = False, time_zone: str = "Europe/Madrid") -> None:
-        setup_logger(log_level)
+        setup_logger(log_level, timezone=time_zone)
         self._logger = logging.getLogger("SportBot")
         self._logger.info("Initializing SportBot...")
         self._logger.info(f"Log level: {log_level}")
@@ -83,6 +83,8 @@ class SportBot:
         return df.head(limit) if limit else df
 
     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())
@@ -98,9 +100,18 @@ class SportBot:
             self._logger.error(error_msg)
             raise IndexError(error_msg)
 
-        self._bookings.book(matching_slot.iloc[0]["id_activity_calendar"])
+        slot_id = matching_slot.iloc[0]["id_activity_calendar"]
+
+        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
 
     def cancel(self, activity: str, start_time: str) -> None:
+
+        self._logger.debug(f"Attempting to cancel class '{activity}' on {start_time}")
         if not self._is_logged_in:
             self._logger.error(ErrorMessages.not_logged_in())
             raise PermissionError(ErrorMessages.not_logged_in())
@@ -116,4 +127,10 @@ class SportBot:
             self._logger.error(error_msg)
             raise IndexError(error_msg)
 
-        self._bookings.cancel(matching_slot.iloc[0]["id_activity_calendar"])
+        slot_id = matching_slot.iloc[0]["id_activity_calendar"]
+        try:
+            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

pysportbot/activities.py

@@ -56,7 +56,7 @@ class Activities:
             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}...")
+        logger.info(f"Fetching available slots for '{activity_name}' on {day}...")
 
         # Check if the activity exists
         activity_match = df_activities[df_activities["name_activity"] == activity_name]

pysportbot/bookings.py

@@ -27,7 +27,7 @@ class Bookings:
             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}...")
+        logger.debug(f"Attempting to book slot {slot_id}...")
 
         # Payload for booking
         payload = {
@@ -46,7 +46,7 @@ class Bookings:
 
         # Handle response
         if response_json["error"] == 0:
-            logger.info(f"Successfully booked slot {slot_id}.")
+            logger.debug(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())
@@ -70,7 +70,7 @@ class Bookings:
         Raises:
             ValueError: If the cancellation fails.
         """
-        logger.info(f"Attempting to cancel slot {slot_id}...")
+        logger.debug(f"Attempting to cancel slot {slot_id}...")
 
         # Payload for cancellation
         payload = {"id_activity_calendar": slot_id}
@@ -81,7 +81,7 @@ class Bookings:
 
         # Handle response
         if response_json["success"]:
-            logger.info(f"Successfully cancelled slot {slot_id}.")
+            logger.debug(f"Successfully cancelled slot {slot_id}.")
         else:
             logger.warning(f"Slot {slot_id} was not booked.")
             raise ValueError(ErrorMessages.cancellation_failed())

pysportbot/service/__main__.py

@@ -10,23 +10,28 @@ 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=5, 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=1, help="Delay in minutes between retries for weekly bookings."
-    )
+    parser.add_argument("--booking-delay", type=int, default=0, help="Global booking delay in seconds before booking.")
+    parser.add_argument("--retry-attempts", type=int, default=3, help="Number of retry attempts for bookings.")
+    parser.add_argument("--retry-delay", type=int, default=5, help="Delay in seconds between retries for bookings.")
     parser.add_argument("--time-zone", type=str, default="Europe/Madrid", help="Timezone for the service.")
     parser.add_argument("--log-level", type=str, default="INFO", help="Logging level for the service.")
+    parser.add_argument(
+        "--max-threads",
+        type=int,
+        default=-1,
+        help="Maxium number of threads to use for booking. -1 defaults to all available cores.",
+    )
     args = parser.parse_args()
 
     config: Dict[str, Any] = load_config(args.config)
     run_service(
         config,
-        offset_seconds=args.offset_seconds,
+        booking_delay=args.booking_delay,
         retry_attempts=args.retry_attempts,
-        retry_delay_minutes=args.retry_delay_minutes,
+        retry_delay=args.retry_delay,
         time_zone=args.time_zone,
         log_level=args.log_level,
+        max_threads=args.max_threads,
     )
 
 

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, List
+from typing import Any, Dict
 
 import pytz
 
@@ -44,9 +44,8 @@ def attempt_booking(
     activity: str,
     class_day: str,
     class_time: str,
-    offset_seconds: int,
     retry_attempts: int = 1,
-    retry_delay_minutes: int = 0,
+    retry_delay: int = 0,
     time_zone: str = "Europe/Madrid",
 ) -> None:
     """
@@ -57,25 +56,20 @@ def attempt_booking(
         activity (str): Activity name.
         class_day (str): Day of the class.
         class_time (str): Time of the class.
-        offset_seconds (int): Delay before attempting booking.
         retry_attempts (int): Number of retry attempts.
-        retry_delay_minutes (int): Delay between retries.
+        retry_delay (int): Delay between retries.
         time_zone (str): Time zone for execution.
     """
     for attempt_num in range(1, retry_attempts + 1):
         booking_date = calculate_class_day(class_day, time_zone).strftime("%Y-%m-%d")
 
         try:
-            logger.info(f"Fetching available slots for '{activity}' on {booking_date}.")
             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)
 
-            logger.info(f"Waiting {offset_seconds} seconds before attempting booking.")
-            time.sleep(offset_seconds)
-
             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)
@@ -89,24 +83,22 @@ def attempt_booking(
                 return
 
             if attempt_num < retry_attempts:
-                logger.info(f"Retrying in {retry_delay_minutes} minutes...")
-                time.sleep(retry_delay_minutes * 60)
+                logger.info(f"Retrying in {retry_delay} seconds...")
+                time.sleep(retry_delay)
         else:
-            # If the booking attempt succeeds, log and exit
-            logger.info(f"Successfully booked '{activity}' at {slot_id}.")
             return
 
     # If all attempts fail, log an error
-    logger.error(f"Failed to book '{activity}' after {retry_attempts} attempts.")
+    # Do not raise an exception to allow other bookings to proceed
+    logger.error(f"Failed to book '{activity}' at {class_time} on {booking_date} after {retry_attempts} attempts.")
 
 
-def schedule_bookings_parallel(
+def schedule_bookings(
     bot: SportBot,
-    classes: List[Dict[str, Any]],
-    booking_execution: str,
-    offset_seconds: int,
+    config: Dict[str, Any],
+    booking_delay: int,
     retry_attempts: int,
-    retry_delay_minutes: int,
+    retry_delay: int,
     time_zone: str,
     max_threads: int,
 ) -> None:
@@ -117,19 +109,32 @@ def schedule_bookings_parallel(
         bot (SportBot): The SportBot instance.
         classes (list): List of class configurations.
         booking_execution (str): Global execution time for all bookings.
-        offset_seconds (int): Delay before each booking attempt.
+        booking_delay (int): Delay before each booking attempt.
         retry_attempts (int): Number of retry attempts.
-        retry_delay_minutes (int): Delay between retries.
+        retry_delay (int): Delay between retries.
         time_zone (str): Timezone for booking.
         max_threads (int): Maximum number of threads to use.
     """
     # Log planned bookings
-    for cls in classes:
+    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(booking_execution, time_zone)
+    wait_for_execution(config["booking_execution"], time_zone)
+
+    # 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 = {
             executor.submit(
@@ -138,12 +143,11 @@ def schedule_bookings_parallel(
                 cls["activity"],
                 cls["class_day"],
                 cls["class_time"],
-                offset_seconds,
                 retry_attempts,
-                retry_delay_minutes,
+                retry_delay,
                 time_zone,
             ): cls
-            for cls in classes
+            for cls in config["classes"]
         }
 
         for future in as_completed(future_to_class):
@@ -151,6 +155,5 @@ def schedule_bookings_parallel(
             activity, class_time = cls["activity"], cls["class_time"]
             try:
                 future.result()
-                logger.info(f"Booking for '{activity}' at {class_time} completed successfully.")
             except Exception:
                 logger.exception(f"Booking for '{activity}' at {class_time} failed.")

pysportbot/service/service.py

@@ -1,28 +1,29 @@
-import os
 from typing import Any, Dict
 
 from pysportbot import SportBot
-from pysportbot.service.booking import schedule_bookings_parallel
+from pysportbot.service.booking import schedule_bookings
 from pysportbot.service.config_validator import validate_activities, validate_config
+from pysportbot.service.threading import get_n_threads
 from pysportbot.utils.logger import get_logger
 
 
 def run_service(
     config: Dict[str, Any],
-    offset_seconds: int,
+    booking_delay: int,
     retry_attempts: int,
-    retry_delay_minutes: int,
+    retry_delay: int,
     time_zone: str = "Europe/Madrid",
     log_level: str = "INFO",
+    max_threads: int = -1,
 ) -> None:
     """
     Run the booking service with the given configuration.
 
     Args:
         config (dict): Configuration dictionary for booking service.
-        offset_seconds (int): Delay before each booking attempt.
+        booking_delay (int): Delay before each booking attempt.
         retry_attempts (int): Number of retry attempts.
-        retry_delay_minutes (int): Delay between retry attempts in minutes.
+        retry_delay (int): Delay between retry attempts in minutes.
         time_zone (str): Time zone for the booking.
         log_level (str): Logging level for the service.
     """
@@ -34,24 +35,25 @@ def run_service(
     validate_config(config)
 
     # Initialize the SportBot and authenticate
+    # Note: will re-authenticate before booking execution
+    # to ensure the session is still valid
     bot = SportBot(log_level=log_level, time_zone=time_zone)
     bot.login(config["email"], config["password"], config["centre"])
 
     # Validate activities in the configuration
     validate_activities(bot, config)
 
-    # Determine the number of threads
-    max_threads = min(len(config["classes"]), os.cpu_count() or 1)
-    logger.info(f"Using up to {max_threads} threads for booking {len(config['classes'])} activities.")
+    # Determine the number of threads, where threads -1 defaults to all available cores
+    requested_bookings = len(config["classes"])
+    max_threads = get_n_threads(max_threads, requested_bookings)
 
     # Schedule bookings in parallel
-    schedule_bookings_parallel(
+    schedule_bookings(
         bot,
-        config["classes"],
-        config["booking_execution"],
-        offset_seconds,
+        config,
+        booking_delay,
         retry_attempts,
-        retry_delay_minutes,
+        retry_delay,
         time_zone,
         max_threads,
     )

pysportbot/service/threading.py

@@ -0,0 +1,51 @@
+import os
+
+from pysportbot.utils.logger import get_logger
+
+logger = get_logger(__name__)
+
+
+def get_n_threads(max_user_threads: int, requested_bookings: int) -> int:
+    """
+    Determine the number of threads to use based on user input and system resources.
+
+    Args:
+        max_user_threads (int): Maximum number of threads requested by the user (-1 for auto-detect).
+        requested_bookings (int): Number of bookings to process.
+
+    Returns:
+        int: The maximum number of threads to use.
+
+    Raises:
+        ValueError: If max_user_threads is 0.
+    """
+    logger.debug(f"Maximum number of user-requested threads: {max_user_threads}")
+    logger.debug(f"Requested bookings: {requested_bookings}")
+
+    available_threads: int = os.cpu_count() or 1  # Fallback to 1 if os.cpu_count() is None
+    logger.debug(f"Available threads: {available_threads}")
+
+    if max_user_threads == 0:
+        logger.error("The 'max_user_threads' argument cannot be 0.")
+        raise ValueError("The 'max_user_threads' argument cannot be 0.")
+
+    if max_user_threads > available_threads:
+        logger.warning(
+            f"User-requested threads ({max_user_threads}) exceed available threads ({available_threads}). "
+            f"Limiting to {available_threads} threads."
+        )
+
+    if requested_bookings <= 0:
+        logger.warning("No bookings requested. Returning 0 threads.")
+        return 0  # No threads needed if there are no bookings
+
+    # If max_user_threads is -1, use the lesser of available threads and requested bookings
+    if max_user_threads == -1:
+        max_threads: int = min(available_threads, requested_bookings)
+    else:
+        # Use the lesser of max_user_threads, available threads, and requested bookings
+        max_threads = min(max_user_threads, available_threads, requested_bookings)
+
+    logger.info(f"Using up to {max_threads} threads for booking {requested_bookings} activities.")
+
+    return max_threads

pysportbot/utils/errors.py

@@ -20,11 +20,7 @@ class ErrorMessages:
 
     @staticmethod
     def invalid_class_definition() -> str:
-        return "Each class must include 'activity', 'class_day', " "'class_time', 'booking_execution', and 'weekly'."
-
-    @staticmethod
-    def invalid_weekly_now() -> str:
-        return "Invalid combination: cannot use weekly=True with booking_execution='now'."
+        return "Each class must include 'activity', 'class_day', " "'class_time'"
 
     @staticmethod
     def invalid_booking_execution_format() -> str:

pysportbot/utils/logger.py

@@ -9,7 +9,9 @@ from .errors import ErrorMessages
 
 
 class ColorFormatter(logging.Formatter):
-    """Custom formatter to add color-coded log levels and thread information."""
+    """Custom formatter to add color-coded log levels and thread information,
+    while aligning log levels in the output as `[INFO]    message`.
+    """
 
     COLORS: ClassVar[dict[str, str]] = {
         "DEBUG": "\033[94m",  # Blue
@@ -31,7 +33,9 @@ class ColorFormatter(logging.Formatter):
         "\033[35m",  # Purple
     ]
 
-    thread_colors: dict[str, str]
+    # The longest built-in level is WARNING = 7 letters => "[WARNING]" is 0 characters
+    # so let's set this to 9 to align them nicely.
+    _MAX_BRACKET_LEN = 9
 
     def __init__(self, fmt: str, datefmt: str, tz: pytz.BaseTzInfo, include_threads: bool = False) -> None:
         """
@@ -41,47 +45,46 @@ class ColorFormatter(logging.Formatter):
             fmt (str): The log message format.
             datefmt (str): The date format.
             tz (pytz.BaseTzInfo): The timezone for log timestamps.
-            include_threads (bool): Whether to include thread information in logs.
+            include_threads (bool): Whether to include thread info in logs.
         """
         super().__init__(fmt, datefmt)
         self.timezone = tz
         self.include_threads = include_threads
-        self.thread_colors = {}  # Initialize as an empty dictionary
+        self.thread_colors: dict[str, str] = {}  # Initialize empty dictionary
 
     def formatTime(self, record: logging.LogRecord, datefmt: Optional[str] = None) -> str:
         """
         Override to format the time in the desired timezone.
-
-        Args:
-            record (logging.LogRecord): The log record.
-            datefmt (Optional[str]): The date format.
-
-        Returns:
-            str: The formatted timestamp.
         """
         record_time = datetime.fromtimestamp(record.created, self.timezone)
         return record_time.strftime(datefmt or self.default_time_format)
 
     def format(self, record: logging.LogRecord) -> str:
         """
-        Format the log record with color-coded log levels and optional thread information.
+        Format the log record with color-coded (and bracketed) log levels, plus optional thread info.
+        Example final output: "[INFO]    message".
+        """
+        raw_level_name = record.levelname
 
-        Args:
-            record (logging.LogRecord): The log record to format.
+        # Build the bracketed level, e.g. "[INFO]"
+        bracketed_level = f"[{raw_level_name}]"
 
-        Returns:
-            str: The formatted log record as a string.
-        """
-        color = self.COLORS.get(record.levelname, self.COLORS["RESET"])
-        record.levelname = f"{color}{record.levelname}{self.COLORS['RESET']}"
+        # Pad it to a fixed width (e.g. 10) so shorter levels also line up
+        padded_bracketed_level = f"{bracketed_level:<{self._MAX_BRACKET_LEN}}"
 
+        # Colorize the padded bracketed string
+        color = self.COLORS.get(raw_level_name, self.COLORS["RESET"])
+        colored_bracketed = f"{color}{padded_bracketed_level}{self.COLORS['RESET']}"
+
+        # We'll store this in a custom attribute
+        record.colored_bracketed_level = colored_bracketed
+
+        # Handle the thread info if requested
         if self.include_threads:
             thread_name = threading.current_thread().name
             if thread_name == "MainThread":
-                # Skip adding thread info for the main thread
                 record.thread_info = ""
             else:
-                # Map thread names to simplified format (Thread 0, Thread 1, etc.)
                 if thread_name not in self.thread_colors:
                     color_index = len(self.thread_colors) % len(self.THREAD_COLORS)
                     self.thread_colors[thread_name] = self.THREAD_COLORS[color_index]
@@ -101,25 +104,24 @@ def setup_logger(level: str = "INFO", timezone: str = "Europe/Madrid") -> None:
 
     Args:
         level (str): The desired logging level (DEBUG, INFO, WARNING, ERROR, CRITICAL).
-        timezone (str): The desired timezone for log timestamps (e.g., Europe/Madrid).
+        timezone (str): The desired timezone for log timestamps (e.g., 'Europe/Madrid').
     """
     root_logger = logging.getLogger()
     root_logger.setLevel(logging._nameToLevel[level.upper()])
 
-    if not root_logger.hasHandlers():  # Avoid duplicate handlers
+    # Prevent adding multiple handlers if already set up
+    if not root_logger.hasHandlers():
         handler = logging.StreamHandler()
         handler.setLevel(logging._nameToLevel[level.upper()])
+
         tz = pytz.timezone(timezone)
 
-        # Default formatter for the main thread
-        thread_formatter = ColorFormatter(
-            "[%(asctime)s] [%(levelname)s] %(thread_info)s%(message)s",
-            datefmt="%Y-%m-%d %H:%M:%S",
-            tz=tz,
-            include_threads=True,
-        )
+        # IMPORTANT: Note the %(colored_bracketed_level)s placeholder
+        fmt = "[%(asctime)s] %(colored_bracketed_level)s %(thread_info)s%(message)s"
+
+        formatter = ColorFormatter(fmt=fmt, datefmt="%Y-%m-%d %H:%M:%S", tz=tz, include_threads=True)
+        handler.setFormatter(formatter)
 
-        handler.setFormatter(thread_formatter)
         root_logger.addHandler(handler)
 
 
@@ -143,11 +145,5 @@ def set_log_level(level: str) -> None:
 def get_logger(name: str) -> logging.Logger:
     """
     Retrieve a logger by name.
-
-    Args:
-        name (str): The name of the logger.
-
-    Returns:
-        logging.Logger: The logger instance.
     """
     return logging.getLogger(name)

{pysportbot-0.0.6.dist-info → pysportbot-0.0.8.dist-info}/METADATA

@@ -1,22 +1,20 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.3
 Name: pysportbot
-Version: 0.0.6
-Summary:  A python-based bot for automatic resasports slot booking
-Home-page: https://github.com/jbeirer/resasports-bot
+Version: 0.0.8
+Summary: A python-based bot for automatic resasports slot booking
 Author: Joshua Falco Beirer
 Author-email: jbeirer@cern.ch
-Requires-Python: >=3.9,<3.13
+Requires-Python: >=3.9,<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
+Classifier: Programming Language :: Python :: 3.13
 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)
-Project-URL: Documentation, https://jbeirer.github.io/resasports-bot/
-Project-URL: Repository, https://github.com/jbeirer/resasports-bot
 Description-Content-Type: text/markdown
 
 # No queues. Just gains.
@@ -32,10 +30,10 @@ Description-Content-Type: text/markdown
 [![Documentation](https://img.shields.io/badge/api-docs-blue)](https://jbeirer.github.io/resasports-bot/)
 [![Contributor Covenant](https://img.shields.io/badge/Contributor%20Covenant-2.1-4baaaa.svg)](https://github.com/jbeirer/resasports-bot/blob/main/CODE_OF_CONDUCT.md)
 
-Welcome to pysportbot!
+PySportBot empowers you to programmatically book fitness classes at any sports center that uses the [Resasports](https://social.resasports.com/en/) booking management software.
 
-## Download pysportbot
-```python
+## Install
+```bash
 pip install pysportbot
 ```
 
@@ -71,7 +69,7 @@ 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, two types of configuration are supported:
 
-##### 1. Book an upcoming class now
+### 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:
 
@@ -91,7 +89,7 @@ Let's say you would like to book Yoga next Monday at 18:00:00, then your `config
     ]
 }
 ```
-##### 2. Book an upcoming class on a specific day and time
+### 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:
 
@@ -112,19 +110,23 @@ Let's say you would like to book Yoga next Monday at 18:00:00, but the execution
 }
 ```
 
+**Note:** By default, pysportbot will be attempt to execute *N* bookings in parallel, where *N* is the number of available cores on your machine.
+
 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 (e.g. Europe/Madrid)
-4. ```--log-level``` sets the log-level of the service (e.g. DEBUG, INFO, WARNING, ERROR)
+1. ```--booking-delay``` sets a global delay in seconds before booking execution [default: 0]
+2. ```--retry-attempts``` sets the number of retries attempted in case a booking attempt fails [default: 3]
+3. ```--retry-delay``` sets the delay in seconds between booking retries [default: 5]
+4. ```--time-zone``` sets the time zone for the service [default: Europe/Madrid]
+5. ```--log-level``` sets the log-level of the service [default: INFO]
+6. ```--max-threads``` limits the number of used threads for parallel bookings [default: -1]
 
 ## 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).
+published under the [MIT License](https://github.com/jbeirer/resasports-bot/blob/main/LICENSE).
 

pysportbot-0.0.8.dist-info/RECORD

@@ -0,0 +1,23 @@
+pysportbot/__init__.py,sha256=TomOCaCWzIuJtFsbglygUChn1wdNaARGiX5Ymt1v2aw,5651
+pysportbot/activities.py,sha256=Aq8l570sxqEAKplsEMVkuDoPJJjoaZlIwPh6i64_SJ8,4252
+pysportbot/authenticator.py,sha256=xEU9O6W6Yp9DCueoUD0ASMkm17yvdUZqTvV4h6WlSnI,5012
+pysportbot/bookings.py,sha256=W91AYGPu0sCpGliuiVdlENsoGYzH8P6v-SyKisbSb7g,3127
+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=J7c4O4QqrRyb3HvNEj3RLzCw-M-YEfU1aOrNPMlkTXM,1502
+pysportbot/service/booking.py,sha256=sRV3cseOtgoMPl4Mnnt2SI0TReB4X0-jox5cxGvZBKo,5622
+pysportbot/service/config_loader.py,sha256=elNNwcC7kwc0lmRqj95hAA50qSmLelWv5G2E62tDxP0,185
+pysportbot/service/config_validator.py,sha256=ce7p-LgPtvWnTYvpyUEE60627DHHzx5mFhEI9hDNB-4,2621
+pysportbot/service/scheduling.py,sha256=bwqbiQQ9y4ss4UXZkWuOVCgCa9XlZt1n4TT_8z9bD7M,1973
+pysportbot/service/service.py,sha256=c7hE9xU9osNImprwTobR1wC9tLFdP_DfvIJtlHjqlE8,1939
+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/logger.py,sha256=BfR1COAmVr5v0T5JX-6-MsMXOx2XVzfib4Td1sSWYjI,5379
+pysportbot/utils/time.py,sha256=VZSW8AxFIoFD5ZSmLUPcwawp6PmpkcxNjP3Db-Hl_fw,1244
+pysportbot-0.0.8.dist-info/LICENSE,sha256=6ov3DypdEVYpp2pn_B1MniKWO5C9iDA4O6PGcbork6c,1077
+pysportbot-0.0.8.dist-info/METADATA,sha256=-7JBOQq4lVwvVhwdr21JrdnTr_vG9v_V-wt2Yy5imTM,5228
+pysportbot-0.0.8.dist-info/WHEEL,sha256=RaoafKOydTQ7I_I3JTrPCg6kUmTgtm4BornzOqyEfJ8,88
+pysportbot-0.0.8.dist-info/RECORD,,

{pysportbot-0.0.6.dist-info → pysportbot-0.0.8.dist-info}/WHEEL

@@ -1,4 +1,4 @@
 Wheel-Version: 1.0
-Generator: poetry-core 1.9.1
+Generator: poetry-core 2.0.0
 Root-Is-Purelib: true
 Tag: py3-none-any

pysportbot-0.0.6.dist-info/RECORD

@@ -1,22 +0,0 @@
-pysportbot/__init__.py,sha256=4z5KKwrnwj_uiZYTUNgZIw_7s8ZT9C-Olz8_hzhPutw,4919
-pysportbot/activities.py,sha256=y2-CCdMoPTnKZleF_icYbngbnfpmHL5Cyadv1UuiCpE,4248
-pysportbot/authenticator.py,sha256=xEU9O6W6Yp9DCueoUD0ASMkm17yvdUZqTvV4h6WlSnI,5012
-pysportbot/bookings.py,sha256=vJ0kw74qyirZlbQ7M9XqlKtRoGzuHR0_t6-zUdgldkI,3123
-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=PSaqYZ8wWlmFT0_taeOA2NLZfm9fIOy6MBhrv_IPSP4,1319
-pysportbot/service/booking.py,sha256=bjPb9BLF7XOhFnr1ZArxUHNO6-10yM1z-3S5-ZFpXjQ,5713
-pysportbot/service/config_loader.py,sha256=elNNwcC7kwc0lmRqj95hAA50qSmLelWv5G2E62tDxP0,185
-pysportbot/service/config_validator.py,sha256=ce7p-LgPtvWnTYvpyUEE60627DHHzx5mFhEI9hDNB-4,2621
-pysportbot/service/scheduling.py,sha256=bwqbiQQ9y4ss4UXZkWuOVCgCa9XlZt1n4TT_8z9bD7M,1973
-pysportbot/service/service.py,sha256=_LR7rJ4GAgp4saSFREiSJCm4GzzEor6ZYkIkuAq7PLM,1866
-pysportbot/session.py,sha256=pTQrz3bGzLYBtzVOgKv04l4UXDSgtA3Infn368bjg5I,1529
-pysportbot/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-pysportbot/utils/errors.py,sha256=sUSs04yr_OmZeTywi1fzPsjVjkLd5iTpXlzlQqNKmgQ,5162
-pysportbot/utils/logger.py,sha256=38rB0M6KPlelXPcgXPSEhXB36-_ZTERLJAQ8DRYIOTM,5189
-pysportbot/utils/time.py,sha256=VZSW8AxFIoFD5ZSmLUPcwawp6PmpkcxNjP3Db-Hl_fw,1244
-pysportbot-0.0.6.dist-info/LICENSE,sha256=6ov3DypdEVYpp2pn_B1MniKWO5C9iDA4O6PGcbork6c,1077
-pysportbot-0.0.6.dist-info/METADATA,sha256=lECBuUu6DaV2CiVXWwHpmz1b--lL7DhxwpOsrXTITKU,4904
-pysportbot-0.0.6.dist-info/WHEEL,sha256=Nq82e9rUAnEjt98J6MlVmMCZb-t9cYE2Ir1kpBmnWfs,88
-pysportbot-0.0.6.dist-info/RECORD,,