Fix impossibility to set empty env variable color on Windows

loguru/_handler.py

@@ -107,7 +107,7 @@ def decolorize_format(format_):
     @staticmethod
     @functools.lru_cache(maxsize=32)
     def colorize_format(format_, color):
-        am = Handler.make_ansimarkup(color)
+        am = Handler.make_ansimarkup(color.strip())
         return am.parse(format_)
 
     def update_format(self, color):

loguru/_logger.py

@@ -522,15 +522,18 @@ def start(
 
         Each of the |start| default parameter can be modified by setting the ``LOGURU_[PARAM]``
         environment variable. For example on Linux: ``export LOGURU_FORMAT="{time} - {message}"``
-        or ``export LOGURU_ENHANCE=NO``.
+        or ``export LOGURU_BACKTRACE=NO``.
 
         The default levels attributes can also be modified by setting the ``LOGURU_[LEVEL]_[ATTR]``
-        environment variable. For example, on Windows: ``setx LOGURU_DEBUG_COLOR="<blue>"``
-        or ``setx LOGURU_TRACE_ICON="🚀"``.
+        environment variable. For example, on Windows: ``setx LOGURU_DEBUG_COLOR "<blue>"``
+        or ``setx LOGURU_TRACE_ICON "🚀"``.
 
         If you want to disable the pre-configured sink, you can set the ``LOGURU_AUTOINIT``
         variable to ``False``.
 
+        On Linux, you will probably need to edit the ``~/.profile`` file to make this persistent. On
+        Windows, don't forget to restart your terminal for the change to be taken into account.
+
         Examples
         --------
         >>> logger.start(sys.stdout, format="{time} - {level} - {message}", filter="sub.module")

tests/test_levels.py

@@ -4,40 +4,46 @@
 
 am = ansimarkup.AnsiMarkup(tags={"empty": ansimarkup.parse("")})
 
+
 def test_log_int_level(writer):
-    logger.start(writer, format='{level.name} -> {level.no} -> {message}', colorize=False)
+    logger.start(writer, format="{level.name} -> {level.no} -> {message}", colorize=False)
     logger.log(10, "test")
 
     assert writer.read() == "Level 10 -> 10 -> test\n"
 
+
 def test_log_str_level(writer):
-    logger.start(writer, format='{level.name} -> {level.no} -> {message}', colorize=False)
+    logger.start(writer, format="{level.name} -> {level.no} -> {message}", colorize=False)
     logger.log("DEBUG", "test")
 
     assert writer.read() == "DEBUG -> 10 -> test\n"
 
+
 def test_add_level(writer):
     name = "L3V3L"
     icon = "[o]"
     level = 10
 
     logger.level(name, level, color="<red>", icon=icon)
-    logger.start(writer, format='{level.icon} <level>{level.name}</level> -> {level.no} -> {message}', colorize=True)
+    fmt = "{level.icon} <level>{level.name}</level> -> {level.no} -> {message}"
+    logger.start(writer, format=fmt, colorize=True)
 
     logger.log(name, "test")
     expected = am.parse("%s <red>%s</red> -> %d -> test" % (icon, name, level))
-    assert writer.read() == expected + '\n'
+    assert writer.read() == expected + "\n"
+
 
-@pytest.mark.parametrize('colorize, expected', [
-    (False, "foo | 10 | a"),
-    (True, am.parse("<red>foo | 10 | a</red>"))
-])
+@pytest.mark.parametrize(
+    "colorize, expected", [(False, "foo | 10 | a"), (True, am.parse("<red>foo | 10 | a</red>"))]
+)
 def test_add_level_after_start(writer, colorize, expected):
-    logger.start(writer, level="DEBUG", format='<level>{level.name} | {level.no} | {message}</level>', colorize=colorize)
+    fmt = "<level>{level.name} | {level.no} | {message}</level>"
+    logger.start(writer, level="DEBUG", format=fmt, colorize=colorize)
     logger.level("foo", 10, color="<red>")
     logger.log("foo", "a")
     assert writer.read() == expected + "\n"
 
+
 def test_add_level_then_log_with_int_value(writer):
     logger.level("foo", 16)
     logger.start(writer, level="foo", format="{level.name} {level.no} {message}", colorize=False)
@@ -46,35 +52,50 @@ def test_add_level_then_log_with_int_value(writer):
 
     assert writer.read() == "Level 16 16 test\n"
 
+
 def test_add_malicious_level(writer):
     name = "Level 15"
 
     logger.level(name, 45, color="<red>")
-    logger.start(writer, format='{level.name} & {level.no} & <level>{message}</level>', colorize=True)
+    fmt = "{level.name} & {level.no} & <level>{message}</level>"
+    logger.start(writer, format=fmt, colorize=True)
+
+    logger.log(15, " A ")
+    logger.log(name, " B ")
 
-    logger.log(15, ' A ')
-    logger.log(name, ' B ')
+    res = am.parse("Level 15 & 15 & <empty> A </empty>\n" "Level 15 & 45 & <red> B </red>\n")
+    assert writer.read() == res
 
-    assert writer.read() == (am.parse('Level 15 & 15 & <empty> A </empty>') + '\n' +
-                             am.parse('Level 15 & 45 & <red> B </red>') + '\n')
 
 def test_add_existing_level(writer):
     logger.level("INFO", 45, color="<red>")
-    logger.start(writer, format='{level.icon} + <level>{level.name}</level> + {level.no} = {message}', colorize=True)
+    fmt = "{level.icon} + <level>{level.name}</level> + {level.no} = {message}"
+    logger.start(writer, format=fmt, colorize=True)
 
     logger.info("a")
     logger.log("INFO", "b")
     logger.log(10, "c")
     logger.log(45, "d")
 
-    assert writer.read() == (am.parse('ℹ️ + <red>INFO</red> + 45 = a') + '\n' +
-                             am.parse('ℹ️ + <red>INFO</red> + 45 = b') + '\n' +
-                             am.parse('  + <empty>Level 10</empty> + 10 = c') + '\n' +
-                             am.parse('  + <empty>Level 45</empty> + 45 = d') + '\n')
+    assert writer.read() == am.parse(
+        "ℹ️ + <red>INFO</red> + 45 = a\n"
+        "ℹ️ + <red>INFO</red> + 45 = b\n"
+        "  + <empty>Level 10</empty> + 10 = c\n"
+        "  + <empty>Level 45</empty> + 45 = d\n"
+    )
+
+
+def test_blank_color(writer):
+    logger.level("INFO", color=" ")
+    logger.start(writer, level="DEBUG", format="<level>{message}</level>", colorize=True)
+    logger.info("Test")
+    assert writer.read() == am.parse("<empty>Test</empty>\n")
+
 
 def test_edit_level(writer):
     logger.level("info", no=0, color="<bold>", icon="[?]")
-    logger.start(writer, format="<level>->{level.no}, {level.name}, {level.icon}, {message}<-</level>", colorize=True)
+    fmt = "<level>->{level.no}, {level.name}, {level.icon}, {message}<-</level>"
+    logger.start(writer, format=fmt, colorize=True)
 
     logger.log("info", "nope")
 
@@ -87,32 +108,45 @@ def test_edit_level(writer):
     logger.level("info", color="<red>")
     logger.log("info", "c")
 
-    assert writer.read() == (ansimarkup.parse("<bold>->11, info, [?], a<-</bold>") + "\n" +
-                             ansimarkup.parse("<bold>->11, info, [!], b<-</bold>") + "\n" +
-                             ansimarkup.parse("<red>->11, info, [!], c<-</red>") + "\n")
+    assert writer.read() == ansimarkup.parse(
+        "<bold>->11, info, [?], a<-</bold>\n"
+        "<bold>->11, info, [!], b<-</bold>\n"
+        "<red>->11, info, [!], c<-</red>\n"
+    )
+
 
 def test_edit_existing_level(writer):
     logger.level("DEBUG", no=20, icon="!")
-    logger.start(writer, format="{level.no}, <level>{level.name}</level>, {level.icon}, {message}", colorize=False)
+    fmt = "{level.no}, <level>{level.name}</level>, {level.icon}, {message}"
+    logger.start(writer, format=fmt, colorize=False)
     logger.debug("a")
     assert writer.read() == "20, DEBUG, !, a\n"
 
+
 def test_get_level():
     level = (11, "<red>", "[!]")
     logger.level("lvl", *level)
     assert logger.level("lvl") == level
 
+
 def test_get_existing_level():
     assert logger.level("DEBUG") == (10, "<blue><bold>", "🐞")
 
+
 def test_start_custom_level(writer):
     logger.level("foo", 17, color="<yellow>")
-    logger.start(writer, level="foo", format='<level>{level.name} + {level.no} + {message}</level>', colorize=False)
+    logger.start(
+        writer,
+        level="foo",
+        format="<level>{level.name} + {level.no} + {message}</level>",
+        colorize=False,
+    )
 
     logger.debug("nope")
     logger.info("yes")
 
-    assert writer.read() == 'INFO + 20 + yes\n'
+    assert writer.read() == "INFO + 20 + yes\n"
+
 
 def test_updating_min_level(writer):
     logger.debug("Early exit -> no {error}", nope=None)
@@ -129,27 +163,32 @@ def test_updating_min_level(writer):
 
     logger.debug("Early exit -> no {error}", nope=None)
 
+
 @pytest.mark.parametrize("level", ["foo", -1, 3.4, object()])
 def test_log_invalid_level(writer, level):
     logger.start(writer)
     with pytest.raises(ValueError):
         logger.log(level, "test")
 
+
 @pytest.mark.parametrize("level_name", [10, object()])
 def test_add_invalid_level_name(level_name):
     with pytest.raises(ValueError):
         logger.level(level_name, 11)
 
+
 @pytest.mark.parametrize("level_value", ["1", -1, 3.4, object()])
 def test_add_invalid_level_value(level_value):
     with pytest.raises(ValueError):
         logger.level("test", level_value)
 
+
 @pytest.mark.parametrize("level", ["foo", 10, object()])
 def test_get_invalid_level(level):
     with pytest.raises(ValueError):
         logger.level(level)
 
+
 @pytest.mark.parametrize("level", ["foo", 10, object()])
 def test_edit_invalid_level(level):
     with pytest.raises(ValueError):