fix: Don't remove parenthesis around long dictionary values

src/black/lines.py

@@ -954,6 +954,20 @@ def can_omit_invisible_parens(
         ):
             closing_bracket = leaf
 
+    if (
+        # Keep parenthesized dictionary values
+        len(rhs.head.leaves) >= 2
+        and rhs.head.leaves[-1].type == token.LPAR
+        and rhs.head.leaves[-2].type == token.COLON
+        # Unless key is a function call with trailing comma
+        and not(
+            len(rhs.head.leaves) >= 4
+            and rhs.head.leaves[-3].type == token.RPAR
+            and rhs.head.leaves[-4].type == token.COMMA
+        )
+    ):
+        return False
+
     bt = line.bracket_tracker
     if not bt.delimiters:
         # Without delimiters the optional parentheses are useless.

src/black/trans.py

@@ -886,6 +886,7 @@ class StringParenStripper(StringTransformer):
         The line contains a string which is surrounded by parentheses and:
             - The target string is NOT the only argument to a function call.
             - The target string is NOT a "pointless" string.
+            - The target string is NOT a dictionary value.
             - If the target string contains a PERCENT, the brackets are not
               preceded or followed by an operator with higher precedence than
               PERCENT.
@@ -933,11 +934,14 @@ def do_match(self, line: Line) -> TMatchResult:
             ):
                 continue
 
-            # That LPAR should NOT be preceded by a function name or a closing
-            # bracket (which could be a function which returns a function or a
-            # list/dictionary that contains a function)...
+            # That LPAR should NOT be preceded by a colon (which could be a
+            # dictionary value), function name, or a closing bracket (which
+            # could be a function returning a function or a list/dictionary
+            # containing a function)...
             if is_valid_index(idx - 2) and (
-                LL[idx - 2].type == token.NAME or LL[idx - 2].type in CLOSING_BRACKETS
+                LL[idx - 2].type == token.COLON
+                or LL[idx - 2].type == token.NAME
+                or LL[idx - 2].type in CLOSING_BRACKETS
             ):
                 continue
 
@@ -2263,12 +2267,12 @@ def do_transform(
             elif right_leaves and right_leaves[-1].type == token.RPAR:
                 # Special case for lambda expressions as dict's value, e.g.:
                 #     my_dict = {
-                #        "key": lambda x: f"formatted: {x},
+                #        "key": lambda x: f"formatted: {x}",
                 #     }
                 # After wrapping the dict's value with parentheses, the string is
                 # followed by a RPAR but its opening bracket is lambda's, not
                 # the string's:
-                #        "key": (lambda x: f"formatted: {x}),
+                #        "key": (lambda x: f"formatted: {x}"),
                 opening_bracket = right_leaves[-1].opening_bracket
                 if opening_bracket is not None and opening_bracket in left_leaves:
                     index = left_leaves.index(opening_bracket)

tests/data/cases/preview_long_dict_values_2.py

@@ -0,0 +1,147 @@
+# flags: --unstable
+
+x = {
+    "xx_xxxxx_xxxxxxxxxx_xxxxxxxxx_xx": (
+        "xx:xxxxxxxxxxxxxxxxx_xxxxx_xxxxxxx_xxxxxxxxxxx{xx}xxx_xxxxx_xxxxxxxxx_xxxxxxxxxxxx_xxxx"
+    )
+}
+x = {
+    "xx_xxxxx_xxxxxxxxxx_xxxxxxxxx_xx": "xx:xxxxxxxxxxxxxxxxx_xxxxx_xxxxxxx_xxxxxxxxxxx{xx}xxx_xxxxx_xxxxxxxxx_xxxxxxxxxxxx_xxxx",
+}
+x = {
+    "foo": (bar),
+    "foo": bar,
+    "foo": xx_xxxxxxxxxxxxxxxxx_xxxxx_xxxxxxx_xxxxxxxxxxxxxx_xxxxx_xxxxxxxxx_xxxxxxxxxxxx_xxxx,
+}
+x = {
+    "xx_xxxxx_xxxxxxxxxx_xxxxxxxxx_xx": (
+        "xx:xxxxxxxxxxxxxxxxx_xxxxx_xxxxxxx_xxxxxxxxxx"
+    )
+}
+
+# Function calls as keys
+tasks = {
+    get_key_name(foo, bar, baz,): src,
+    loop.run_in_executor(): src,
+    loop.run_in_executor(xx_xxxxxxxxxxxxxxxxx_xxxxx_xxxxxxx_xxxxxxxxxxxxxx): src,
+    loop.run_in_executor(xx_xxxxxxxxxxxxxxxxx_xxxxx_xxxxxxx_xxxxxxxxxxxxxx_xxxxx_xxxxx): src,
+    loop.run_in_executor(): xx_xxxxxxxxxxxxxxxxx_xxxxx_xxxxxxx_xxxxxxxxxxxxxx_xxxxx_xxxxxxxxx_xxxxxxxxxxxx_xxxx
+}
+
+# Dictionary comprehensions
+tasks = {
+    key_name: xx_xxxxxxxxxxxxxxxxx_xxxxx_xxxxxxx_xxxxxxxxxxxxxx_xxxxx_xxxxxxxxx_xxxxxxxxxxxx_xxxx
+    for src in sources
+}
+tasks = {key_name: foobar for src in sources}
+tasks = {get_key_name(foo, bar, baz,): src for src in sources}
+tasks = {
+    get_key_name(): xx_xxxxxxxxxxxxxxxxx_xxxxx_xxxxxxx_xxxxxxxxxxxxxx_xxxxx_xxxxxxxxx_xxxxxxxxxxxx_xxxx
+    for src in sources
+}
+tasks = {
+    get_key_name(): foobar
+    for src in sources
+}
+
+# Delimiters inside the value
+def foo():
+    def bar():
+        x = {
+            common.models.DateTimeField: (
+                datetime(2020, 1, 31, tzinfo=utc) + timedelta(days=i)
+            ),
+        }
+        x = {
+            common.models.DateTimeField: datetime(2020, 1, 31, tzinfo=utc) + timedelta(
+                days=i
+            ),
+        }
+        x = {
+            "foobar": (
+                123 + 456
+            ),
+        }
+
+
+# output
+
+x = {
+    "xx_xxxxx_xxxxxxxxxx_xxxxxxxxx_xx": (
+        "xx:xxxxxxxxxxxxxxxxx_xxxxx_xxxxxxx_xxxxxxxxxxx{xx}xxx_xxxxx_xxxxxxxxx_xxxxxxxxxxxx_xxxx"
+    )
+}
+x = {
+    "xx_xxxxx_xxxxxxxxxx_xxxxxxxxx_xx": (
+        "xx:xxxxxxxxxxxxxxxxx_xxxxx_xxxxxxx_xxxxxxxxxxx{xx}xxx_xxxxx_xxxxxxxxx_xxxxxxxxxxxx_xxxx"
+    ),
+}
+x = {
+    "foo": bar,
+    "foo": bar,
+    "foo": (
+        xx_xxxxxxxxxxxxxxxxx_xxxxx_xxxxxxx_xxxxxxxxxxxxxx_xxxxx_xxxxxxxxx_xxxxxxxxxxxx_xxxx
+    ),
+}
+x = {
+    "xx_xxxxx_xxxxxxxxxx_xxxxxxxxx_xx": "xx:xxxxxxxxxxxxxxxxx_xxxxx_xxxxxxx_xxxxxxxxxx"
+}
+
+# Function calls as keys
+tasks = {
+    get_key_name(
+        foo,
+        bar,
+        baz,
+    ): src,
+    loop.run_in_executor(): src,
+    loop.run_in_executor(xx_xxxxxxxxxxxxxxxxx_xxxxx_xxxxxxx_xxxxxxxxxxxxxx): src,
+    loop.run_in_executor(
+        xx_xxxxxxxxxxxxxxxxx_xxxxx_xxxxxxx_xxxxxxxxxxxxxx_xxxxx_xxxxx
+    ): src,
+    loop.run_in_executor(): (
+        xx_xxxxxxxxxxxxxxxxx_xxxxx_xxxxxxx_xxxxxxxxxxxxxx_xxxxx_xxxxxxxxx_xxxxxxxxxxxx_xxxx
+    ),
+}
+
+# Dictionary comprehensions
+tasks = {
+    key_name: (
+        xx_xxxxxxxxxxxxxxxxx_xxxxx_xxxxxxx_xxxxxxxxxxxxxx_xxxxx_xxxxxxxxx_xxxxxxxxxxxx_xxxx
+    )
+    for src in sources
+}
+tasks = {key_name: foobar for src in sources}
+tasks = {
+    get_key_name(
+        foo,
+        bar,
+        baz,
+    ): src
+    for src in sources
+}
+tasks = {
+    get_key_name(): (
+        xx_xxxxxxxxxxxxxxxxx_xxxxx_xxxxxxx_xxxxxxxxxxxxxx_xxxxx_xxxxxxxxx_xxxxxxxxxxxx_xxxx
+    )
+    for src in sources
+}
+tasks = {get_key_name(): foobar for src in sources}
+
+
+# Delimiters inside the value
+def foo():
+    def bar():
+        x = {
+            common.models.DateTimeField: (
+                datetime(2020, 1, 31, tzinfo=utc) + timedelta(days=i)
+            ),
+        }
+        x = {
+            common.models.DateTimeField: (
+                datetime(2020, 1, 31, tzinfo=utc) + timedelta(days=i)
+            ),
+        }
+        x = {
+            "foobar": 123 + 456,
+        }