.github/workflows/tests.yml

@@ -20,6 +20,7 @@ jobs:
         - '3.9'
         - '3.10'
         - '3.11'
+        - 3.12-dev
         - pypy-3.9
         include:
         - os: ubuntu-20.04

.pre-commit-config.yaml

@@ -16,7 +16,7 @@ repos:
   rev: 23.7.0
   hooks:
   - id: black
-    args: [-l, '100', --target-version, py35]
+    args: [-l, '100', --target-version, py35, --force-exclude, tests/exceptions/source/modern/*]
 - repo: https://github.com/astral-sh/ruff-pre-commit
   rev: v0.0.286
   hooks:

CHANGELOG.rst

@@ -1,3 +1,11 @@
+`0.7.2`_ (2023-09-11)
+=====================
+
+- Add support for formatting of ``ExceptionGroup`` errors (`#805 <https://github.com/Delgan/loguru/issues/805>`_).
+- Fix possible ``RuntimeError`` when using ``multiprocessing.set_start_method()`` after importing the ``logger`` (`#974 <https://github.com/Delgan/loguru/issues/974>`_)
+- Fix formatting of possible ``__notes__`` attached to an ``Exception`` (`#980 <https://github.com/Delgan/loguru/issues/980>`_).
+
+
 `0.7.1`_ (2023-09-04)
 =====================
 
@@ -213,7 +221,8 @@
 Initial release.
 
 
-.. _Unreleased: https://github.com/delgan/loguru/compare/0.7.1...master
+.. _Unreleased: https://github.com/delgan/loguru/compare/0.7.2...master
+.. _0.7.2: https://github.com/delgan/loguru/releases/tag/0.7.2
 .. _0.7.1: https://github.com/delgan/loguru/releases/tag/0.7.1
 .. _0.7.0: https://github.com/delgan/loguru/releases/tag/0.7.0
 .. _0.6.0: https://github.com/delgan/loguru/releases/tag/0.6.0

loguru/__init__.py

@@ -10,7 +10,7 @@
 from ._logger import Core as _Core
 from ._logger import Logger as _Logger
 
-__version__ = "0.7.1"
+__version__ = "0.7.2"
 
 __all__ = ["logger"]
 

loguru/_better_exceptions.py

@@ -10,6 +10,24 @@
 import tokenize
 import traceback
 
+if sys.version_info >= (3, 11):
+
+    def is_exception_group(exc):
+        return isinstance(exc, ExceptionGroup)
+
+else:
+    try:
+        from exceptiongroup import ExceptionGroup
+    except ImportError:
+
+        def is_exception_group(exc):
+            return False
+
+    else:
+
+        def is_exception_group(exc):
+            return isinstance(exc, ExceptionGroup)
+
 
 class SyntaxHighlighter:
     _default_style = {
@@ -28,6 +46,12 @@ class SyntaxHighlighter:
     _builtins = set(dir(builtins))
     _constants = {"True", "False", "None"}
     _punctation = {"(", ")", "[", "]", "{", "}", ":", ",", ";"}
+    _strings = {tokenize.STRING}
+    _fstring_middle = None
+
+    if sys.version_info >= (3, 12):
+        _strings.update({tokenize.FSTRING_START, tokenize.FSTRING_MIDDLE, tokenize.FSTRING_END})
+        _fstring_middle = tokenize.FSTRING_MIDDLE
 
     def __init__(self, style=None):
         self._style = style or self._default_style
@@ -38,7 +62,12 @@ def highlight(self, source):
         output = ""
 
         for token in self.tokenize(source):
-            type_, string, start, end, line = token
+            type_, string, (start_row, start_column), (_, end_column), line = token
+
+            if type_ == self._fstring_middle:
+                # When an f-string contains "{{" or "}}", they appear as "{" or "}" in the "string"
+                # attribute of the token. However, they do not count in the column position.
+                end_column += string.count("{") + string.count("}")
 
             if type_ == tokenize.NAME:
                 if string in self._constants:
@@ -56,23 +85,20 @@ def highlight(self, source):
                     color = style["operator"]
             elif type_ == tokenize.NUMBER:
                 color = style["number"]
-            elif type_ == tokenize.STRING:
+            elif type_ in self._strings:
                 color = style["string"]
             elif type_ == tokenize.COMMENT:
                 color = style["comment"]
             else:
                 color = style["other"]
 
-            start_row, start_column = start
-            _, end_column = end
-
             if start_row != row:
-                source = source[:column]
+                source = source[column:]
                 row, column = start_row, 0
 
             if type_ != tokenize.ENCODING:
                 output += line[column:start_column]
-                output += color.format(string)
+                output += color.format(line[start_column:end_column])
 
             column = end_column
 
@@ -140,6 +166,15 @@ def _get_lib_dirs():
         paths = {sysconfig.get_path(name, scheme) for scheme in schemes for name in names}
         return [os.path.abspath(path).lower() + os.sep for path in paths if path in sys.path]
 
+    @staticmethod
+    def _indent(text, count, *, prefix="| "):
+        if count == 0:
+            yield text
+            return
+        for line in text.splitlines(True):
+            indented = "  " * count + prefix + line
+            yield indented.rstrip() + "\n"
+
     def _get_char(self, char, default):
         try:
             char.encode(self._encoding)
@@ -344,7 +379,9 @@ def _format_locations(self, frames_lines, *, has_introduction):
 
             yield frame
 
-    def _format_exception(self, value, tb, *, seen=None, is_first=False, from_decorator=False):
+    def _format_exception(
+        self, value, tb, *, seen=None, is_first=False, from_decorator=False, group_nesting=0
+    ):
         # Implemented from built-in traceback module:
         # https://github.com/python/cpython/blob/a5b76167/Lib/traceback.py#L468
         exc_type, exc_value, exc_traceback = type(value), value, tb
@@ -356,46 +393,73 @@ def _format_exception(self, value, tb, *, seen=None, is_first=False, from_decora
 
         if exc_value:
             if exc_value.__cause__ is not None and id(exc_value.__cause__) not in seen:
-                for text in self._format_exception(
-                    exc_value.__cause__, exc_value.__cause__.__traceback__, seen=seen
-                ):
-                    yield text
+                yield from self._format_exception(
+                    exc_value.__cause__,
+                    exc_value.__cause__.__traceback__,
+                    seen=seen,
+                    group_nesting=group_nesting,
+                )
                 cause = "The above exception was the direct cause of the following exception:"
                 if self._colorize:
                     cause = self._theme["cause"].format(cause)
                 if self._diagnose:
-                    yield "\n\n" + cause + "\n\n\n"
+                    yield from self._indent("\n\n" + cause + "\n\n\n", group_nesting)
                 else:
-                    yield "\n" + cause + "\n\n"
+                    yield from self._indent("\n" + cause + "\n\n", group_nesting)
 
             elif (
                 exc_value.__context__ is not None
                 and id(exc_value.__context__) not in seen
                 and not exc_value.__suppress_context__
             ):
-                for text in self._format_exception(
-                    exc_value.__context__, exc_value.__context__.__traceback__, seen=seen
-                ):
-                    yield text
+                yield from self._format_exception(
+                    exc_value.__context__,
+                    exc_value.__context__.__traceback__,
+                    seen=seen,
+                    group_nesting=group_nesting,
+                )
                 context = "During handling of the above exception, another exception occurred:"
                 if self._colorize:
                     context = self._theme["context"].format(context)
                 if self._diagnose:
-                    yield "\n\n" + context + "\n\n\n"
+                    yield from self._indent("\n\n" + context + "\n\n\n", group_nesting)
                 else:
-                    yield "\n" + context + "\n\n"
+                    yield from self._indent("\n" + context + "\n\n", group_nesting)
+
+        is_grouped = is_exception_group(value)
+
+        if is_grouped and group_nesting == 0:
+            yield from self._format_exception(
+                value,
+                tb,
+                seen=seen,
+                group_nesting=1,
+                is_first=is_first,
+                from_decorator=from_decorator,
+            )
+            return
 
         try:
-            tracebacklimit = sys.tracebacklimit
+            traceback_limit = sys.tracebacklimit
         except AttributeError:
-            tracebacklimit = None
+            traceback_limit = None
 
         frames, final_source = self._extract_frames(
-            exc_traceback, is_first, limit=tracebacklimit, from_decorator=from_decorator
+            exc_traceback, is_first, limit=traceback_limit, from_decorator=from_decorator
         )
         exception_only = traceback.format_exception_only(exc_type, exc_value)
 
-        error_message = exception_only[-1][:-1]  # Remove last new line temporarily
+        # Determining the correct index for the "Exception: message" part in the formatted exception
+        # is challenging. This is because it might be preceded by multiple lines specific to
+        # "SyntaxError" or followed by various notes. However, we can make an educated guess based
+        # on the indentation; the preliminary context for "SyntaxError" is always indented, while
+        # the Exception itself is not. This allows us to identify the correct index for the
+        # exception message.
+        for error_message_index, part in enumerate(exception_only):  # noqa: B007
+            if not part.startswith(" "):
+                break
+
+        error_message = exception_only[error_message_index][:-1]  # Remove last new line temporarily
 
         if self._colorize:
             if ":" in error_message:
@@ -414,24 +478,51 @@ def _format_exception(self, value, tb, *, seen=None, is_first=False, from_decora
 
             error_message = "\n" + error_message
 
-        exception_only[-1] = error_message + "\n"
-
-        frames_lines = traceback.format_list(frames) + exception_only
-        has_introduction = bool(frames)
-
-        if self._colorize or self._backtrace or self._diagnose:
-            frames_lines = self._format_locations(frames_lines, has_introduction=has_introduction)
+        exception_only[error_message_index] = error_message + "\n"
 
         if is_first:
             yield self._prefix
 
+        has_introduction = bool(frames)
+
         if has_introduction:
-            introduction = "Traceback (most recent call last):"
+            if is_grouped:
+                introduction = "Exception Group Traceback (most recent call last):"
+            else:
+                introduction = "Traceback (most recent call last):"
             if self._colorize:
                 introduction = self._theme["introduction"].format(introduction)
-            yield introduction + "\n"
+            if group_nesting == 1:  # Implies we're processing the root ExceptionGroup.
+                yield from self._indent(introduction + "\n", group_nesting, prefix="+ ")
+            else:
+                yield from self._indent(introduction + "\n", group_nesting)
 
-        yield "".join(frames_lines)
+        frames_lines = traceback.format_list(frames) + exception_only
+        if self._colorize or self._backtrace or self._diagnose:
+            frames_lines = self._format_locations(frames_lines, has_introduction=has_introduction)
+
+        yield from self._indent("".join(frames_lines), group_nesting)
+
+        if is_grouped:
+            for n, exc in enumerate(value.exceptions, start=1):
+                ruler = "+" + (" %s " % ("..." if n > 15 else n)).center(35, "-")
+                yield from self._indent(ruler, group_nesting, prefix="+-" if n == 1 else "  ")
+                if n > 15:
+                    message = "and %d more exceptions\n" % (len(value.exceptions) - 15)
+                    yield from self._indent(message, group_nesting + 1)
+                    break
+                elif group_nesting == 10 and is_exception_group(exc):
+                    message = "... (max_group_depth is 10)\n"
+                    yield from self._indent(message, group_nesting + 1)
+                else:
+                    yield from self._format_exception(
+                        exc,
+                        exc.__traceback__,
+                        seen=seen,
+                        group_nesting=group_nesting + 1,
+                    )
+            if not is_exception_group(exc) or group_nesting == 10:
+                yield from self._indent("-" * 35, group_nesting + 1, prefix="+-")
 
     def format_exception(self, type_, value, tb, *, from_decorator=False):
         yield from self._format_exception(value, tb, is_first=True, from_decorator=from_decorator)

loguru/_datetime.py

@@ -94,7 +94,9 @@ def aware_now():
         seconds = local.tm_gmtoff
         zone = local.tm_zone
     except AttributeError:
-        offset = datetime_.fromtimestamp(timestamp) - datetime_.utcfromtimestamp(timestamp)
+        # Workaround for Python 3.5.
+        utc_naive = datetime_.fromtimestamp(timestamp, tz=timezone.utc).replace(tzinfo=None)
+        offset = datetime_.fromtimestamp(timestamp) - utc_naive
         seconds = offset.total_seconds()
         zone = strftime("%Z")
 

loguru/_handler.py

@@ -1,5 +1,6 @@
 import functools
 import json
+import multiprocessing
 import os
 import threading
 from contextlib import contextmanager
@@ -88,10 +89,15 @@ def __init__(
                 self._decolorized_format = self._formatter.strip()
 
         if self._enqueue:
-            self._queue = self._multiprocessing_context.SimpleQueue()
+            if self._multiprocessing_context is None:
+                self._queue = multiprocessing.SimpleQueue()
+                self._confirmation_event = multiprocessing.Event()
+                self._confirmation_lock = multiprocessing.Lock()
+            else:
+                self._queue = self._multiprocessing_context.SimpleQueue()
+                self._confirmation_event = self._multiprocessing_context.Event()
+                self._confirmation_lock = self._multiprocessing_context.Lock()
             self._queue_lock = create_handler_lock()
-            self._confirmation_event = self._multiprocessing_context.Event()
-            self._confirmation_lock = self._multiprocessing_context.Lock()
             self._owner_process_pid = os.getpid()
             self._thread = Thread(
                 target=self._queued_writer, daemon=True, name="loguru-writer-%d" % self._id

loguru/_logger.py

@@ -85,7 +85,6 @@
 import builtins
 import contextlib
 import functools
-import itertools
 import logging
 import re
 import sys
@@ -182,7 +181,7 @@ def __init__(self):
             name: (name, name, level.no, level.icon) for name, level in self.levels.items()
         }
 
-        self.handlers_count = itertools.count()
+        self.handlers_count = 0
         self.handlers = {}
 
         self.extra = {}
@@ -778,7 +777,8 @@ def add(
         >>> logger.add(stream_object, level="INFO")
         """
         with self._core.lock:
-            handler_id = next(self._core.handlers_count)
+            handler_id = self._core.handlers_count
+            self._core.handlers_count += 1
 
         error_interceptor = ErrorInterceptor(catch, handler_id)
 
@@ -967,9 +967,9 @@ def add(
         if not isinstance(encoding, str):
             encoding = "ascii"
 
-        if context is None or isinstance(context, str):
+        if isinstance(context, str):
             context = get_context(context)
-        elif not isinstance(context, BaseContext):
+        elif context is not None and not isinstance(context, BaseContext):
             raise TypeError(
                 "Invalid context, it should be a string or a multiprocessing context, "
                 "not: '%s'" % type(context).__name__

ruff.toml

@@ -1,6 +1,6 @@
 # Enforce pyflakes(F), pycodestyle(E, W), isort (I), bugbears (B), and pep8-naming (N) rules
 select = ["F", "E", "W", "I", "B", "N"]
 line-length = 100
-exclude = ["tests/exceptions/source"]
+exclude = ["tests/exceptions/source/*"]
 [pycodestyle]
 max-doc-length = 100