pysportbot 0.0.7__tar.gz → 0.0.8__tar.gz

{pysportbot-0.0.7 → pysportbot-0.0.8}/PKG-INFO

@@ -1,22 +1,20 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.3
 Name: pysportbot
-Version: 0.0.7
-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``` sets the delay in seconds between retries booking retries
-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.7 → pysportbot-0.0.8}/README.md

@@ -11,10 +11,10 @@
 [![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
 ```
 
@@ -50,7 +50,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:
 
@@ -70,7 +70,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:
 
@@ -91,18 +91,22 @@ 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``` sets the delay in seconds between retries booking retries
-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.7 → pysportbot-0.0.8}/pyproject.toml

@@ -1,17 +1,20 @@
-[tool.poetry]
+[project]
 name = "pysportbot"
-version = "v0.0.7"
-description = " A python-based bot for automatic resasports slot booking"
-authors = ["Joshua Falco Beirer <jbeirer@cern.ch>"]
+version = "v0.0.8"
+description = "A python-based bot for automatic resasports slot booking"
+authors = [
+  { name = "Joshua Falco Beirer", email = "jbeirer@cern.ch" }
+]
 repository = "https://github.com/jbeirer/resasports-bot"
 documentation = "https://jbeirer.github.io/resasports-bot/"
 readme = "README.md"
 packages = [
-  {include = "pysportbot"}
+  { include = "pysportbot" }
 ]
+dynamic = ["requires-python", "dependencies"]
 
 [tool.poetry.dependencies]
-python = ">=3.9,<3.13"
+python = ">=3.9,<3.14"
 requests = "^2.32.3"
 beautifulsoup4 = "^4.12.3"
 pandas = "^2.2.3"

{pysportbot-0.0.7 → pysportbot-0.0.8}/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-0.0.7 → pysportbot-0.0.8}/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-0.0.7 → pysportbot-0.0.8}/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-0.0.7 → pysportbot-0.0.8}/pysportbot/service/__main__.py

@@ -10,11 +10,17 @@ 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("--booking-delay", type=int, default=5, help="Global booking delay in seconds before booking.")
+    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=30, help="Delay in seconds between retries 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)
@@ -25,6 +31,7 @@ def main() -> None:
         retry_delay=args.retry_delay,
         time_zone=args.time_zone,
         log_level=args.log_level,
+        max_threads=args.max_threads,
     )
 
 

{pysportbot-0.0.7 → pysportbot-0.0.8}/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,7 +44,6 @@ def attempt_booking(
     activity: str,
     class_day: str,
     class_time: str,
-    booking_delay: int,
     retry_attempts: int = 1,
     retry_delay: int = 0,
     time_zone: str = "Europe/Madrid",
@@ -57,7 +56,6 @@ def attempt_booking(
         activity (str): Activity name.
         class_day (str): Day of the class.
         class_time (str): Time of the class.
-        booking_delay (int): Delay before attempting booking.
         retry_attempts (int): Number of retry attempts.
         retry_delay (int): Delay between retries.
         time_zone (str): Time zone for execution.
@@ -66,7 +64,6 @@ def attempt_booking(
         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}"]
@@ -89,18 +86,16 @@ def attempt_booking(
                 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(
     bot: SportBot,
-    classes: List[Dict[str, Any]],
-    booking_execution: str,
+    config: Dict[str, Any],
     booking_delay: int,
     retry_attempts: int,
     retry_delay: int,
@@ -121,16 +116,25 @@ def schedule_bookings(
         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(
@@ -139,12 +143,11 @@ def schedule_bookings(
                 cls["activity"],
                 cls["class_day"],
                 cls["class_time"],
-                booking_delay,
                 retry_attempts,
                 retry_delay,
                 time_zone,
             ): cls
-            for cls in classes
+            for cls in config["classes"]
         }
 
         for future in as_completed(future_to_class):
@@ -152,6 +155,5 @@ def schedule_bookings(
             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-0.0.7 → pysportbot-0.0.8}/pysportbot/service/service.py

@@ -1,9 +1,9 @@
-import os
 from typing import Any, Dict
 
 from pysportbot import SportBot
 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
 
 
@@ -14,6 +14,7 @@ def run_service(
     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.
@@ -34,21 +35,22 @@ 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(
         bot,
-        config["classes"],
-        config["booking_execution"],
+        config,
         booking_delay,
         retry_attempts,
         retry_delay,

pysportbot-0.0.8/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-0.0.7 → pysportbot-0.0.8}/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)