---
source: crates/ruff_linter/src/rules/pycodestyle/mod.rs
---
E231 [*] Missing whitespace after `,`
 --> E23.py:2:7
  |
1 | #: E231
2 | a = (1,2)
  |       ^
3 | #: E231
4 | a[b1,:]
  |
help: Add missing whitespace
  |
1 | #: E231
  - a = (1,2)
2 + a = (1, 2)
3 | #: E231
  |

E231 [*] Missing whitespace after `,`
 --> E23.py:4:5
  |
2 | a = (1,2)
3 | #: E231
4 | a[b1,:]
  |     ^
5 | #: E231
6 | a = [{'a':''}]
  |
help: Add missing whitespace
  |
3 | #: E231
  - a[b1,:]
4 + a[b1, :]
5 | #: E231
  |

E231 [*] Missing whitespace after `:`
 --> E23.py:6:10
  |
4 | a[b1,:]
5 | #: E231
6 | a = [{'a':''}]
  |          ^
7 | #: Okay
8 | a = (4,)
  |
help: Add missing whitespace
  |
5 | #: E231
  - a = [{'a':''}]
6 + a = [{'a': ''}]
7 | #: Okay
  |

E231 [*] Missing whitespace after `,`
  --> E23.py:19:10
   |
17 | def foo() -> None:
18 |     #: E231
19 |     if (1,2):
   |          ^
20 |         pass
   |
help: Add missing whitespace
   |
18 |     #: E231
   -     if (1,2):
19 +     if (1, 2):
20 |         pass
   |

E231 [*] Missing whitespace after `:`
  --> E23.py:29:20
   |
27 | mdtypes_template = {
28 |     'tag_full': [('mdtype', 'u4'), ('byte_count', 'u4')],
29 |     'tag_smalldata':[('byte_count_mdtype', 'u4'), ('data', 'S4')],
   |                    ^
30 | }
   |
help: Add missing whitespace
   |
28 |     'tag_full': [('mdtype', 'u4'), ('byte_count', 'u4')],
   -     'tag_smalldata':[('byte_count_mdtype', 'u4'), ('data', 'S4')],
29 +     'tag_smalldata': [('byte_count_mdtype', 'u4'), ('data', 'S4')],
30 | }
   |

E231 [*] Missing whitespace after `,`
  --> E23.py:33:6
   |
32 | # E231
33 | f"{(a,b)}"
   |      ^
34 |
35 | # Okay because it's hard to differentiate between the usages of a colon in a f-string
   |
help: Add missing whitespace
   |
32 | # E231
   - f"{(a,b)}"
33 + f"{(a, b)}"
34 |
   |

E231 [*] Missing whitespace after `:`
  --> E23.py:47:37
   |
46 | #: E231
47 | {len(f's3://{self.s3_bucket_name}/'):1}
   |                                     ^
48 |
49 | #: Okay
   |
help: Add missing whitespace
   |
46 | #: E231
   - {len(f's3://{self.s3_bucket_name}/'):1}
47 + {len(f's3://{self.s3_bucket_name}/'): 1}
48 |
   |

E231 [*] Missing whitespace after `:`
  --> E23.py:60:13
   |
58 |     results = {
59 |         "k1": [1],
60 |         "k2":[2],
   |             ^
61 |     }
62 |     results_in_tuple = (
   |
help: Add missing whitespace
   |
59 |         "k1": [1],
   -         "k2":[2],
60 +         "k2": [2],
61 |     }
   |

E231 [*] Missing whitespace after `:`
  --> E23.py:65:17
   |
63 |         {
64 |             "k1": [1],
65 |             "k2":[2],
   |                 ^
66 |         },
67 |     )
   |
help: Add missing whitespace
   |
64 |             "k1": [1],
   -             "k2":[2],
65 +             "k2": [2],
66 |         },
   |

E231 [*] Missing whitespace after `:`
  --> E23.py:71:17
   |
69 |         {
70 |             "k1": [1],
71 |             "k2":[2],
   |                 ^
72 |         }
73 |     ]
   |
help: Add missing whitespace
   |
70 |             "k1": [1],
   -             "k2":[2],
71 +             "k2": [2],
72 |         }
   |

E231 [*] Missing whitespace after `:`
  --> E23.py:76:17
   |
74 |     results_in_list_first = [
75 |         {
76 |             "k2":[2],
   |                 ^
77 |         }
78 |     ]
   |
help: Add missing whitespace
   |
75 |         {
   -             "k2":[2],
76 +             "k2": [2],
77 |         }
   |

E231 [*] Missing whitespace after `:`
  --> E23.py:82:13
   |
80 | x = [
81 |     {
82 |         "k1":[2], # E231
   |             ^
83 |         "k2": x[2:4],
84 |         "k3":[2],  # E231
   |
help: Add missing whitespace
   |
81 |     {
   -         "k1":[2], # E231
82 +         "k1": [2], # E231
83 |         "k2": x[2:4],
   |

E231 [*] Missing whitespace after `:`
  --> E23.py:84:13
   |
82 |         "k1":[2], # E231
83 |         "k2": x[2:4],
84 |         "k3":[2],  # E231
   |             ^
85 |         "k4": [2],
86 |         "k5": [2],
   |
help: Add missing whitespace
   |
83 |         "k2": x[2:4],
   -         "k3":[2],  # E231
84 +         "k3": [2],  # E231
85 |         "k4": [2],
   |

E231 [*] Missing whitespace after `,`
  --> E23.py:87:26
   |
85 |         "k4": [2],
86 |         "k5": [2],
87 |         "k6": [1, 2, 3, 4,5,6,7]  # E231
   |                          ^
88 |     },
89 |     {
   |
help: Add missing whitespace
   |
86 |         "k5": [2],
   -         "k6": [1, 2, 3, 4,5,6,7]  # E231
87 +         "k6": [1, 2, 3, 4, 5,6,7]  # E231
88 |     },
   |

E231 [*] Missing whitespace after `,`
  --> E23.py:87:28
   |
85 |         "k4": [2],
86 |         "k5": [2],
87 |         "k6": [1, 2, 3, 4,5,6,7]  # E231
   |                            ^
88 |     },
89 |     {
   |
help: Add missing whitespace
   |
86 |         "k5": [2],
   -         "k6": [1, 2, 3, 4,5,6,7]  # E231
87 +         "k6": [1, 2, 3, 4,5, 6,7]  # E231
88 |     },
   |

E231 [*] Missing whitespace after `,`
  --> E23.py:87:30
   |
85 |         "k4": [2],
86 |         "k5": [2],
87 |         "k6": [1, 2, 3, 4,5,6,7]  # E231
   |                              ^
88 |     },
89 |     {
   |
help: Add missing whitespace
   |
86 |         "k5": [2],
   -         "k6": [1, 2, 3, 4,5,6,7]  # E231
87 +         "k6": [1, 2, 3, 4,5,6, 7]  # E231
88 |     },
   |

E231 [*] Missing whitespace after `:`
  --> E23.py:92:21
   |
90 |         "k1": [
91 |             {
92 |                 "ka":[2,3],  # E231
   |                     ^
93 |             },
94 |             {
   |
help: Add missing whitespace
   |
91 |             {
   -                 "ka":[2,3],  # E231
92 +                 "ka": [2,3],  # E231
93 |             },
   |

E231 [*] Missing whitespace after `,`
  --> E23.py:92:24
   |
90 |         "k1": [
91 |             {
92 |                 "ka":[2,3],  # E231
   |                        ^
93 |             },
94 |             {
   |
help: Add missing whitespace
   |
91 |             {
   -                 "ka":[2,3],  # E231
92 +                 "ka":[2, 3],  # E231
93 |             },
   |

E231 [*] Missing whitespace after `,`
  --> E23.py:95:25
   |
93 |             },
94 |             {
95 |                 "kb": [2,3],  # E231
   |                         ^
96 |             },
97 |             {
   |
help: Add missing whitespace
   |
94 |             {
   -                 "kb": [2,3],  # E231
95 +                 "kb": [2, 3],  # E231
96 |             },
   |

E231 [*] Missing whitespace after `:`
   --> E23.py:98:21
    |
 96 |             },
 97 |             {
 98 |                 "ka":[2, 3],  # E231
    |                     ^
 99 |                 "kb": [2, 3],  # Ok
100 |                 "kc": [2, 3],  # Ok
    |
help: Add missing whitespace
   |
97 |             {
   -                 "ka":[2, 3],  # E231
98 +                 "ka": [2, 3],  # E231
99 |                 "kb": [2, 3],  # Ok
   |

E231 [*] Missing whitespace after `,`
   --> E23.py:101:25
    |
 99 |                 "kb": [2, 3],  # Ok
100 |                 "kc": [2, 3],  # Ok
101 |                 "kd": [2,3],  # E231
    |                         ^
102 |                 "ke":[2,3],  # E231
103 |             },
    |
help: Add missing whitespace
    |
100 |                 "kc": [2, 3],  # Ok
    -                 "kd": [2,3],  # E231
101 +                 "kd": [2, 3],  # E231
102 |                 "ke":[2,3],  # E231
    |

E231 [*] Missing whitespace after `:`
   --> E23.py:102:21
    |
100 |                 "kc": [2, 3],  # Ok
101 |                 "kd": [2,3],  # E231
102 |                 "ke":[2,3],  # E231
    |                     ^
103 |             },
104 |         ]
    |
help: Add missing whitespace
    |
101 |                 "kd": [2,3],  # E231
    -                 "ke":[2,3],  # E231
102 +                 "ke": [2,3],  # E231
103 |             },
    |

E231 [*] Missing whitespace after `,`
   --> E23.py:102:24
    |
100 |                 "kc": [2, 3],  # Ok
101 |                 "kd": [2,3],  # E231
102 |                 "ke":[2,3],  # E231
    |                        ^
103 |             },
104 |         ]
    |
help: Add missing whitespace
    |
101 |                 "kd": [2,3],  # E231
    -                 "ke":[2,3],  # E231
102 +                 "ke":[2, 3],  # E231
103 |             },
    |

E231 [*] Missing whitespace after `:`
   --> E23.py:109:18
    |
108 | # Should be E231 errors on all of these type parameters and function parameters, but not on their (strange) defaults
109 | def pep_696_bad[A:object="foo"[::-1], B:object =[[["foo", "bar"]]], C:object= bytes](
    |                  ^
110 |     x:A = "foo"[::-1],
111 |     y:B = [[["foo", "bar"]]],
    |
help: Add missing whitespace
    |
108 | # Should be E231 errors on all of these type parameters and function parameters, but not on their (strange) defaults
    - def pep_696_bad[A:object="foo"[::-1], B:object =[[["foo", "bar"]]], C:object= bytes](
109 + def pep_696_bad[A: object="foo"[::-1], B:object =[[["foo", "bar"]]], C:object= bytes](
110 |     x:A = "foo"[::-1],
    |

E231 [*] Missing whitespace after `:`
   --> E23.py:109:40
    |
108 | # Should be E231 errors on all of these type parameters and function parameters, but not on their (strange) defaults
109 | def pep_696_bad[A:object="foo"[::-1], B:object =[[["foo", "bar"]]], C:object= bytes](
    |                                        ^
110 |     x:A = "foo"[::-1],
111 |     y:B = [[["foo", "bar"]]],
    |
help: Add missing whitespace
    |
108 | # Should be E231 errors on all of these type parameters and function parameters, but not on their (strange) defaults
    - def pep_696_bad[A:object="foo"[::-1], B:object =[[["foo", "bar"]]], C:object= bytes](
109 + def pep_696_bad[A:object="foo"[::-1], B: object =[[["foo", "bar"]]], C:object= bytes](
110 |     x:A = "foo"[::-1],
    |

E231 [*] Missing whitespace after `:`
   --> E23.py:109:70
    |
108 | # Should be E231 errors on all of these type parameters and function parameters, but not on their (strange) defaults
109 | def pep_696_bad[A:object="foo"[::-1], B:object =[[["foo", "bar"]]], C:object= bytes](
    |                                                                      ^
110 |     x:A = "foo"[::-1],
111 |     y:B = [[["foo", "bar"]]],
    |
help: Add missing whitespace
    |
108 | # Should be E231 errors on all of these type parameters and function parameters, but not on their (strange) defaults
    - def pep_696_bad[A:object="foo"[::-1], B:object =[[["foo", "bar"]]], C:object= bytes](
109 + def pep_696_bad[A:object="foo"[::-1], B:object =[[["foo", "bar"]]], C: object= bytes](
110 |     x:A = "foo"[::-1],
    |

E231 [*] Missing whitespace after `:`
   --> E23.py:110:6
    |
108 | # Should be E231 errors on all of these type parameters and function parameters, but not on their (strange) defaults
109 | def pep_696_bad[A:object="foo"[::-1], B:object =[[["foo", "bar"]]], C:object= bytes](
110 |     x:A = "foo"[::-1],
    |      ^
111 |     y:B = [[["foo", "bar"]]],
112 |     z:object = "fooo",
    |
help: Add missing whitespace
    |
109 | def pep_696_bad[A:object="foo"[::-1], B:object =[[["foo", "bar"]]], C:object= bytes](
    -     x:A = "foo"[::-1],
110 +     x: A = "foo"[::-1],
111 |     y:B = [[["foo", "bar"]]],
    |

E231 [*] Missing whitespace after `:`
   --> E23.py:111:6
    |
109 | def pep_696_bad[A:object="foo"[::-1], B:object =[[["foo", "bar"]]], C:object= bytes](
110 |     x:A = "foo"[::-1],
111 |     y:B = [[["foo", "bar"]]],
    |      ^
112 |     z:object = "fooo",
113 | ):
    |
help: Add missing whitespace
    |
110 |     x:A = "foo"[::-1],
    -     y:B = [[["foo", "bar"]]],
111 +     y: B = [[["foo", "bar"]]],
112 |     z:object = "fooo",
    |

E231 [*] Missing whitespace after `:`
   --> E23.py:112:6
    |
110 |     x:A = "foo"[::-1],
111 |     y:B = [[["foo", "bar"]]],
112 |     z:object = "fooo",
    |      ^
113 | ):
114 |     pass
    |
help: Add missing whitespace
    |
111 |     y:B = [[["foo", "bar"]]],
    -     z:object = "fooo",
112 +     z: object = "fooo",
113 | ):
    |

E231 [*] Missing whitespace after `:`
   --> E23.py:116:18
    |
114 |     pass
115 |
116 | class PEP696Bad[A:object="foo"[::-1], B:object =[[["foo", "bar"]]], C:object= bytes]:
    |                  ^
117 |     def pep_696_bad_method[A:object="foo"[::-1], B:object =[[["foo", "bar"]]], C:object= bytes](
118 |         self,
    |
help: Add missing whitespace
    |
115 |
    - class PEP696Bad[A:object="foo"[::-1], B:object =[[["foo", "bar"]]], C:object= bytes]:
116 + class PEP696Bad[A: object="foo"[::-1], B:object =[[["foo", "bar"]]], C:object= bytes]:
117 |     def pep_696_bad_method[A:object="foo"[::-1], B:object =[[["foo", "bar"]]], C:object= bytes](
    |

E231 [*] Missing whitespace after `:`
   --> E23.py:116:40
    |
114 |     pass
115 |
116 | class PEP696Bad[A:object="foo"[::-1], B:object =[[["foo", "bar"]]], C:object= bytes]:
    |                                        ^
117 |     def pep_696_bad_method[A:object="foo"[::-1], B:object =[[["foo", "bar"]]], C:object= bytes](
118 |         self,
    |
help: Add missing whitespace
    |
115 |
    - class PEP696Bad[A:object="foo"[::-1], B:object =[[["foo", "bar"]]], C:object= bytes]:
116 + class PEP696Bad[A:object="foo"[::-1], B: object =[[["foo", "bar"]]], C:object= bytes]:
117 |     def pep_696_bad_method[A:object="foo"[::-1], B:object =[[["foo", "bar"]]], C:object= bytes](
    |

E231 [*] Missing whitespace after `:`
   --> E23.py:116:70
    |
114 |     pass
115 |
116 | class PEP696Bad[A:object="foo"[::-1], B:object =[[["foo", "bar"]]], C:object= bytes]:
    |                                                                      ^
117 |     def pep_696_bad_method[A:object="foo"[::-1], B:object =[[["foo", "bar"]]], C:object= bytes](
118 |         self,
    |
help: Add missing whitespace
    |
115 |
    - class PEP696Bad[A:object="foo"[::-1], B:object =[[["foo", "bar"]]], C:object= bytes]:
116 + class PEP696Bad[A:object="foo"[::-1], B:object =[[["foo", "bar"]]], C: object= bytes]:
117 |     def pep_696_bad_method[A:object="foo"[::-1], B:object =[[["foo", "bar"]]], C:object= bytes](
    |

E231 [*] Missing whitespace after `:`
   --> E23.py:117:29
    |
116 | class PEP696Bad[A:object="foo"[::-1], B:object =[[["foo", "bar"]]], C:object= bytes]:
117 |     def pep_696_bad_method[A:object="foo"[::-1], B:object =[[["foo", "bar"]]], C:object= bytes](
    |                             ^
118 |         self,
119 |         x:A = "foo"[::-1],
    |
help: Add missing whitespace
    |
116 | class PEP696Bad[A:object="foo"[::-1], B:object =[[["foo", "bar"]]], C:object= bytes]:
    -     def pep_696_bad_method[A:object="foo"[::-1], B:object =[[["foo", "bar"]]], C:object= bytes](
117 +     def pep_696_bad_method[A: object="foo"[::-1], B:object =[[["foo", "bar"]]], C:object= bytes](
118 |         self,
    |

E231 [*] Missing whitespace after `:`
   --> E23.py:117:51
    |
116 | class PEP696Bad[A:object="foo"[::-1], B:object =[[["foo", "bar"]]], C:object= bytes]:
117 |     def pep_696_bad_method[A:object="foo"[::-1], B:object =[[["foo", "bar"]]], C:object= bytes](
    |                                                   ^
118 |         self,
119 |         x:A = "foo"[::-1],
    |
help: Add missing whitespace
    |
116 | class PEP696Bad[A:object="foo"[::-1], B:object =[[["foo", "bar"]]], C:object= bytes]:
    -     def pep_696_bad_method[A:object="foo"[::-1], B:object =[[["foo", "bar"]]], C:object= bytes](
117 +     def pep_696_bad_method[A:object="foo"[::-1], B: object =[[["foo", "bar"]]], C:object= bytes](
118 |         self,
    |

E231 [*] Missing whitespace after `:`
   --> E23.py:117:81
    |
116 | class PEP696Bad[A:object="foo"[::-1], B:object =[[["foo", "bar"]]], C:object= bytes]:
117 |     def pep_696_bad_method[A:object="foo"[::-1], B:object =[[["foo", "bar"]]], C:object= bytes](
    |                                                                                 ^
118 |         self,
119 |         x:A = "foo"[::-1],
    |
help: Add missing whitespace
    |
116 | class PEP696Bad[A:object="foo"[::-1], B:object =[[["foo", "bar"]]], C:object= bytes]:
    -     def pep_696_bad_method[A:object="foo"[::-1], B:object =[[["foo", "bar"]]], C:object= bytes](
117 +     def pep_696_bad_method[A:object="foo"[::-1], B:object =[[["foo", "bar"]]], C: object= bytes](
118 |         self,
    |

E231 [*] Missing whitespace after `:`
   --> E23.py:119:10
    |
117 |     def pep_696_bad_method[A:object="foo"[::-1], B:object =[[["foo", "bar"]]], C:object= bytes](
118 |         self,
119 |         x:A = "foo"[::-1],
    |          ^
120 |         y:B = [[["foo", "bar"]]],
121 |         z:object = "fooo",
    |
help: Add missing whitespace
    |
118 |         self,
    -         x:A = "foo"[::-1],
119 +         x: A = "foo"[::-1],
120 |         y:B = [[["foo", "bar"]]],
    |

E231 [*] Missing whitespace after `:`
   --> E23.py:120:10
    |
118 |         self,
119 |         x:A = "foo"[::-1],
120 |         y:B = [[["foo", "bar"]]],
    |          ^
121 |         z:object = "fooo",
122 |     ):
    |
help: Add missing whitespace
    |
119 |         x:A = "foo"[::-1],
    -         y:B = [[["foo", "bar"]]],
120 +         y: B = [[["foo", "bar"]]],
121 |         z:object = "fooo",
    |

E231 [*] Missing whitespace after `:`
   --> E23.py:121:10
    |
119 |         x:A = "foo"[::-1],
120 |         y:B = [[["foo", "bar"]]],
121 |         z:object = "fooo",
    |          ^
122 |     ):
123 |         pass
    |
help: Add missing whitespace
    |
120 |         y:B = [[["foo", "bar"]]],
    -         z:object = "fooo",
121 +         z: object = "fooo",
122 |     ):
    |

E231 [*] Missing whitespace after `:`
   --> E23.py:125:32
    |
123 |         pass
124 |
125 | class PEP696BadWithEmptyBases[A:object="foo"[::-1], B:object =[[["foo", "bar"]]], C:object= bytes]():
    |                                ^
126 |     class IndentedPEP696BadWithNonEmptyBases[A:object="foo"[::-1], B:object =[[["foo", "bar"]]], C:object= bytes](object, something_d…
127 |         pass
    |
help: Add missing whitespace
    |
124 |
    - class PEP696BadWithEmptyBases[A:object="foo"[::-1], B:object =[[["foo", "bar"]]], C:object= bytes]():
125 + class PEP696BadWithEmptyBases[A: object="foo"[::-1], B:object =[[["foo", "bar"]]], C:object= bytes]():
126 |     class IndentedPEP696BadWithNonEmptyBases[A:object="foo"[::-1], B:object =[[["foo", "bar"]]], C:object= bytes](object, something_dynamic[x::-1]):
    |

E231 [*] Missing whitespace after `:`
   --> E23.py:125:54
    |
123 |         pass
124 |
125 | class PEP696BadWithEmptyBases[A:object="foo"[::-1], B:object =[[["foo", "bar"]]], C:object= bytes]():
    |                                                      ^
126 |     class IndentedPEP696BadWithNonEmptyBases[A:object="foo"[::-1], B:object =[[["foo", "bar"]]], C:object= bytes](object, something_d…
127 |         pass
    |
help: Add missing whitespace
    |
124 |
    - class PEP696BadWithEmptyBases[A:object="foo"[::-1], B:object =[[["foo", "bar"]]], C:object= bytes]():
125 + class PEP696BadWithEmptyBases[A:object="foo"[::-1], B: object =[[["foo", "bar"]]], C:object= bytes]():
126 |     class IndentedPEP696BadWithNonEmptyBases[A:object="foo"[::-1], B:object =[[["foo", "bar"]]], C:object= bytes](object, something_dynamic[x::-1]):
    |

E231 [*] Missing whitespace after `:`
   --> E23.py:125:84
    |
123 |         pass
124 |
125 | class PEP696BadWithEmptyBases[A:object="foo"[::-1], B:object =[[["foo", "bar"]]], C:object= bytes]():
    |                                                                                    ^
126 |     class IndentedPEP696BadWithNonEmptyBases[A:object="foo"[::-1], B:object =[[["foo", "bar"]]], C:object= bytes](object, something_d…
127 |         pass
    |
help: Add missing whitespace
    |
124 |
    - class PEP696BadWithEmptyBases[A:object="foo"[::-1], B:object =[[["foo", "bar"]]], C:object= bytes]():
125 + class PEP696BadWithEmptyBases[A:object="foo"[::-1], B:object =[[["foo", "bar"]]], C: object= bytes]():
126 |     class IndentedPEP696BadWithNonEmptyBases[A:object="foo"[::-1], B:object =[[["foo", "bar"]]], C:object= bytes](object, something_dynamic[x::-1]):
    |

E231 [*] Missing whitespace after `:`
   --> E23.py:126:47
    |
125 | class PEP696BadWithEmptyBases[A:object="foo"[::-1], B:object =[[["foo", "bar"]]], C:object= bytes]():
126 |     class IndentedPEP696BadWithNonEmptyBases[A:object="foo"[::-1], B:object =[[["foo", "bar"]]], C:object= bytes](object, something_d…
    |                                               ^
127 |         pass
    |
help: Add missing whitespace
    |
125 | class PEP696BadWithEmptyBases[A:object="foo"[::-1], B:object =[[["foo", "bar"]]], C:object= bytes]():
    -     class IndentedPEP696BadWithNonEmptyBases[A:object="foo"[::-1], B:object =[[["foo", "bar"]]], C:object= bytes](object, something_dynamic[x::-1]):
126 +     class IndentedPEP696BadWithNonEmptyBases[A: object="foo"[::-1], B:object =[[["foo", "bar"]]], C:object= bytes](object, something_dynamic[x::-1]):
127 |         pass
    |

E231 [*] Missing whitespace after `:`
   --> E23.py:126:69
    |
125 | class PEP696BadWithEmptyBases[A:object="foo"[::-1], B:object =[[["foo", "bar"]]], C:object= bytes]():
126 |     class IndentedPEP696BadWithNonEmptyBases[A:object="foo"[::-1], B:object =[[["foo", "bar"]]], C:object= bytes](object, something_d…
    |                                                                     ^
127 |         pass
    |
help: Add missing whitespace
    |
125 | class PEP696BadWithEmptyBases[A:object="foo"[::-1], B:object =[[["foo", "bar"]]], C:object= bytes]():
    -     class IndentedPEP696BadWithNonEmptyBases[A:object="foo"[::-1], B:object =[[["foo", "bar"]]], C:object= bytes](object, something_dynamic[x::-1]):
126 +     class IndentedPEP696BadWithNonEmptyBases[A:object="foo"[::-1], B: object =[[["foo", "bar"]]], C:object= bytes](object, something_dynamic[x::-1]):
127 |         pass
    |

E231 [*] Missing whitespace after `:`
   --> E23.py:126:99
    |
125 | class PEP696BadWithEmptyBases[A:object="foo"[::-1], B:object =[[["foo", "bar"]]], C:object= bytes]():
126 |     class IndentedPEP696BadWithNonEmptyBases[A:object="foo"[::-1], B:object =[[["foo", "bar"]]], C:object= bytes](object, something_d…
    |                                                                                                   ^
127 |         pass
    |
help: Add missing whitespace
    |
125 | class PEP696BadWithEmptyBases[A:object="foo"[::-1], B:object =[[["foo", "bar"]]], C:object= bytes]():
    -     class IndentedPEP696BadWithNonEmptyBases[A:object="foo"[::-1], B:object =[[["foo", "bar"]]], C:object= bytes](object, something_dynamic[x::-1]):
126 +     class IndentedPEP696BadWithNonEmptyBases[A:object="foo"[::-1], B:object =[[["foo", "bar"]]], C: object= bytes](object, something_dynamic[x::-1]):
127 |         pass
    |

E231 [*] Missing whitespace after `,`
   --> E23.py:147:6
    |
146 | # E231
147 | t"{(a,b)}"
    |      ^
148 |
149 | # Okay because it's hard to differentiate between the usages of a colon in a t-string
    |
help: Add missing whitespace
    |
146 | # E231
    - t"{(a,b)}"
147 + t"{(a, b)}"
148 |
    |

E231 [*] Missing whitespace after `:`
   --> E23.py:161:37
    |
160 | #: E231
161 | {len(t's3://{self.s3_bucket_name}/'):1}
    |                                     ^
    |
help: Add missing whitespace
    |
160 | #: E231
    - {len(t's3://{self.s3_bucket_name}/'):1}
161 + {len(t's3://{self.s3_bucket_name}/'): 1}
    |
