We are currently solving the following issue within our repository. Here is the issue text:
--- BEGIN ISSUE ---
False positive for Z121 when using `_` for unused var names
# Bug report

## What's wrong

This code triggers `Z121`:

```python
def logo_and_user():
    user, _ = User.objects.get_or_create(username='sobolevn')
    logo, _ = Logo.objects.get_or_create(username='sobolevn')  # here
```

Log: `test.py:4:11: Z121 Found usage of a variable marked as unused: _`
But it should not, since these variables are unused.

## How is that should be

It should not raise any `Z121` violations here.

## System information

I am using `8.0.1`


--- END ISSUE ---

Below are some code segments, each from a relevant file. One or more of these files may contain bugs.
--- BEGIN FILES ---
Path: `wemake_python_styleguide/visitors/ast/comparisons.py`
Content:
```
1 # -*- coding: utf-8 -*-
2 
3 import ast
4 from typing import ClassVar, List, Optional, Sequence
5 
6 import astor
7 
8 from wemake_python_styleguide.logics.naming.name_nodes import is_same_variable
9 from wemake_python_styleguide.logics.nodes import is_literal
10 from wemake_python_styleguide.logics.operators import unwrap_unary_node
11 from wemake_python_styleguide.types import AnyIf, AnyNodes, final
12 from wemake_python_styleguide.violations.best_practices import (
13     SimplifiableIfViolation,
14 )
15 from wemake_python_styleguide.violations.consistency import (
16     ComparisonOrderViolation,
17     ConstantComparisonViolation,
18     MultipleInComparisonViolation,
19     RedundantComparisonViolation,
20     WrongConditionalViolation,
21 )
22 from wemake_python_styleguide.visitors.base import BaseNodeVisitor
23 from wemake_python_styleguide.visitors.decorators import alias
24 
25 
26 @final
27 class ComparisonSanityVisitor(BaseNodeVisitor):
28     """Restricts the comparison of literals."""
29 
30     def _has_multiple_in_comparisons(self, node: ast.Compare) -> bool:
31         count = 0
32         for op in node.ops:
33             if isinstance(op, ast.In):
34                 count += 1
35         return count > 1
36 
37     def _check_literal_compare(self, node: ast.Compare) -> None:
38         last_was_literal = is_literal(node.left)
39         for comparator in node.comparators:
40             next_is_literal = is_literal(comparator)
41             if last_was_literal and next_is_literal:
42                 self.add_violation(ConstantComparisonViolation(node))
43                 break
44             last_was_literal = next_is_literal
45 
46     def _check_redundant_compare(self, node: ast.Compare) -> None:
47         last_variable = node.left
48         for next_variable in node.comparators:
49             if is_same_variable(last_variable, next_variable):
50                 self.add_violation(RedundantComparisonViolation(node))
51                 break
52             last_variable = next_variable
53 
54     def _check_multiple_in_comparisons(self, node: ast.Compare) -> None:
55         if self._has_multiple_in_comparisons(node):
56             self.add_violation(MultipleInComparisonViolation(node))
57 
58     def visit_Compare(self, node: ast.Compare) -> None:
59         """
60         Ensures that compares are written correctly.
61 
62         Raises:
63             ConstantComparisonViolation
64             MultipleInComparisonViolation
65             RedundantComparisonViolation
66 
67         """
68         self._check_literal_compare(node)
69         self._check_redundant_compare(node)
70         self._check_multiple_in_comparisons(node)
71         self.generic_visit(node)
72 
73 
74 @final
75 class WrongComparisionOrderVisitor(BaseNodeVisitor):
76     """Restricts comparision where argument doesn't come first."""
77 
78     _allowed_left_nodes: ClassVar[AnyNodes] = (
79         ast.Name,
80         ast.Call,
81         ast.Attribute,
82     )
83 
84     _special_cases: ClassVar[AnyNodes] = (
85         ast.In,
86         ast.NotIn,
87     )
88 
89     def _is_special_case(self, node: ast.Compare) -> bool:
90         """
91         Operators ``in`` and ``not in`` are special cases.
92 
93         Why? Because it is perfectly fine to use something like:
94         ``if 'key' in some_dict: ...``
95         This should not be an issue.
96 
97         When there are multiple special operators it is still a separate issue.
98         """
99         return isinstance(node.ops[0], self._special_cases)
100 
101     def _is_left_node_valid(self, left: ast.AST) -> bool:
102         if isinstance(left, self._allowed_left_nodes):
103             return True
104         if isinstance(left, ast.BinOp):
105             left_node = self._is_left_node_valid(left.left)
106             right_node = self._is_left_node_valid(left.right)
107             return left_node or right_node
108         return False
109 
110     def _has_wrong_nodes_on_the_right(
111         self,
112         comparators: Sequence[ast.AST],
113     ) -> bool:
114         for right in comparators:
115             if isinstance(right, self._allowed_left_nodes):
116                 return True
117             if isinstance(right, ast.BinOp):
118                 return self._has_wrong_nodes_on_the_right([
119                     right.left, right.right,
120                 ])
121         return False
122 
123     def _check_ordering(self, node: ast.Compare) -> None:
124         if self._is_left_node_valid(node.left):
125             return
126 
127         if self._is_special_case(node):
128             return
129 
130         if len(node.comparators) > 1:
131             return
132 
133         if not self._has_wrong_nodes_on_the_right(node.comparators):
134             return
135 
136         self.add_violation(ComparisonOrderViolation(node))
137 
138     def visit_Compare(self, node: ast.Compare) -> None:
139         """
140         Forbids comparision where argument doesn't come first.
141 
142         Raises:
143             ComparisonOrderViolation
144 
145         """
146         self._check_ordering(node)
147         self.generic_visit(node)
148 
149 
150 @alias('visit_any_if', (
151     'visit_If',
152     'visit_IfExp',
153 ))
154 class WrongConditionalVisitor(BaseNodeVisitor):
155     """Finds wrong conditional arguments."""
156 
157     _forbidden_nodes: ClassVar[AnyNodes] = (
158         # Constants:
159         ast.Num,
160         ast.Str,
161         ast.Bytes,
162         ast.NameConstant,
163 
164         # Collections:
165         ast.List,
166         ast.Set,
167         ast.Dict,
168         ast.Tuple,
169     )
170 
171     def visit_any_if(self, node: AnyIf) -> None:
172         """
173         Ensures that if statements are using valid conditionals.
174 
175         Raises:
176             WrongConditionalViolation
177 
178         """
179         if isinstance(node, ast.If):
180             self._check_simplifiable_if(node)
181         else:
182             self._check_simplifiable_ifexpr(node)
183 
184         self._check_if_statement_conditional(node)
185         self.generic_visit(node)
186 
187     def _is_simplifiable_assign(
188         self,
189         node_body: List[ast.stmt],
190     ) -> Optional[str]:
191         wrong_length = len(node_body) != 1
192         if wrong_length or not isinstance(node_body[0], ast.Assign):
193             return None
194         if len(node_body[0].targets) != 1:
195             return None
196         if not isinstance(node_body[0].value, ast.NameConstant):
197             return None
198         if node_body[0].value.value is None:
199             return None
200         return astor.to_source(node_body[0].targets[0]).strip()
201 
202     def _check_if_statement_conditional(self, node: AnyIf) -> None:
203         real_node = unwrap_unary_node(node.test)
204         if isinstance(real_node, self._forbidden_nodes):
205             self.add_violation(WrongConditionalViolation(node))
206 
207     def _check_simplifiable_if(self, node: ast.If) -> None:
208         chain = getattr(node, 'wps_chain', None)
209         chained = getattr(node, 'wps_chained', None)
210         if chain is None and chained is None:
211             body_var = self._is_simplifiable_assign(node.body)
212             else_var = self._is_simplifiable_assign(node.orelse)
213             if body_var and body_var == else_var:
214                 self.add_violation(SimplifiableIfViolation(node))
215 
216     def _check_simplifiable_ifexpr(self, node: ast.IfExp) -> None:
217         conditions = set()
218         if isinstance(node.body, ast.NameConstant):
219             conditions.add(node.body.value)
220         if isinstance(node.orelse, ast.NameConstant):
221             conditions.add(node.orelse.value)
222 
223         if conditions == {True, False}:
224             self.add_violation(SimplifiableIfViolation(node))
225
```
--- END FILES ---

Please first localize the bug based on the issue statement, and then generate a patch according to the `git diff` format fenced by three backticks.

Here is an example:

```diff
diff --git a/examples/server_async.py b/examples/server_async.py
--- a/examples/server_async.py
+++ b/examples/server_async.py
@@ -313,4 +313,4 @@
 
 
 if __name__ == "__main__":
-    asyncio.run(run_async_server("."), debug=True)
+    asyncio.run(run_async_server(), debug=True)
diff --git a/examples/server_sync.py b/examples/server_sync.py
--- a/examples/server_sync.py
+++ b/examples/server_sync.py
@@ -313,5 +313,5 @@
 
 
 if __name__ == "__main__":
-    server = run_sync_server(".")
+    server = run_sync_server()
     server.shutdown()

```

diff --git a/wemake_python_styleguide/visitors/ast/comparisons.py b/wemake_python_styleguide/visitors/ast/comparisons.py
--- a/wemake_python_styleguide/visitors/ast/comparisons.py
+++ b/wemake_python_styleguide/visitors/ast/comparisons.py
@@ -79,6 +79,7 @@
         ast.Name,
         ast.Call,
         ast.Attribute,
+        ast.Subscript,
     )
 
     _special_cases: ClassVar[AnyNodes] = (

{"golden_diff": "diff --git a/wemake_python_styleguide/visitors/ast/comparisons.py b/wemake_python_styleguide/visitors/ast/comparisons.py\n--- a/wemake_python_styleguide/visitors/ast/comparisons.py\n+++ b/wemake_python_styleguide/visitors/ast/comparisons.py\n@@ -79,6 +79,7 @@\n         ast.Name,\n         ast.Call,\n         ast.Attribute,\n+        ast.Subscript,\n     )\n \n     _special_cases: ClassVar[AnyNodes] = (\n", "issue": "False positive for Z121 when using `_` for unused var names\n# Bug report\r\n\r\n## What's wrong\r\n\r\nThis code triggers `Z121`:\r\n\r\n```python\r\ndef logo_and_user():\r\n    user, _ = User.objects.get_or_create(username='sobolevn')\r\n    logo, _ = Logo.objects.get_or_create(username='sobolevn')  # here\r\n```\r\n\r\nLog: `test.py:4:11: Z121 Found usage of a variable marked as unused: _`\r\nBut it should not, since these variables are unused.\r\n\r\n## How is that should be\r\n\r\nIt should not raise any `Z121` violations here.\r\n\r\n## System information\r\n\r\nI am using `8.0.1`\r\n\n", "before_files": [{"content": "# -*- coding: utf-8 -*-\n\nimport ast\nfrom typing import ClassVar, List, Optional, Sequence\n\nimport astor\n\nfrom wemake_python_styleguide.logics.naming.name_nodes import is_same_variable\nfrom wemake_python_styleguide.logics.nodes import is_literal\nfrom wemake_python_styleguide.logics.operators import unwrap_unary_node\nfrom wemake_python_styleguide.types import AnyIf, AnyNodes, final\nfrom wemake_python_styleguide.violations.best_practices import (\n    SimplifiableIfViolation,\n)\nfrom wemake_python_styleguide.violations.consistency import (\n    ComparisonOrderViolation,\n    ConstantComparisonViolation,\n    MultipleInComparisonViolation,\n    RedundantComparisonViolation,\n    WrongConditionalViolation,\n)\nfrom wemake_python_styleguide.visitors.base import BaseNodeVisitor\nfrom wemake_python_styleguide.visitors.decorators import alias\n\n\n@final\nclass ComparisonSanityVisitor(BaseNodeVisitor):\n    \"\"\"Restricts the comparison of literals.\"\"\"\n\n    def _has_multiple_in_comparisons(self, node: ast.Compare) -> bool:\n        count = 0\n        for op in node.ops:\n            if isinstance(op, ast.In):\n                count += 1\n        return count > 1\n\n    def _check_literal_compare(self, node: ast.Compare) -> None:\n        last_was_literal = is_literal(node.left)\n        for comparator in node.comparators:\n            next_is_literal = is_literal(comparator)\n            if last_was_literal and next_is_literal:\n                self.add_violation(ConstantComparisonViolation(node))\n                break\n            last_was_literal = next_is_literal\n\n    def _check_redundant_compare(self, node: ast.Compare) -> None:\n        last_variable = node.left\n        for next_variable in node.comparators:\n            if is_same_variable(last_variable, next_variable):\n                self.add_violation(RedundantComparisonViolation(node))\n                break\n            last_variable = next_variable\n\n    def _check_multiple_in_comparisons(self, node: ast.Compare) -> None:\n        if self._has_multiple_in_comparisons(node):\n            self.add_violation(MultipleInComparisonViolation(node))\n\n    def visit_Compare(self, node: ast.Compare) -> None:\n        \"\"\"\n        Ensures that compares are written correctly.\n\n        Raises:\n            ConstantComparisonViolation\n            MultipleInComparisonViolation\n            RedundantComparisonViolation\n\n        \"\"\"\n        self._check_literal_compare(node)\n        self._check_redundant_compare(node)\n        self._check_multiple_in_comparisons(node)\n        self.generic_visit(node)\n\n\n@final\nclass WrongComparisionOrderVisitor(BaseNodeVisitor):\n    \"\"\"Restricts comparision where argument doesn't come first.\"\"\"\n\n    _allowed_left_nodes: ClassVar[AnyNodes] = (\n        ast.Name,\n        ast.Call,\n        ast.Attribute,\n    )\n\n    _special_cases: ClassVar[AnyNodes] = (\n        ast.In,\n        ast.NotIn,\n    )\n\n    def _is_special_case(self, node: ast.Compare) -> bool:\n        \"\"\"\n        Operators ``in`` and ``not in`` are special cases.\n\n        Why? Because it is perfectly fine to use something like:\n        ``if 'key' in some_dict: ...``\n        This should not be an issue.\n\n        When there are multiple special operators it is still a separate issue.\n        \"\"\"\n        return isinstance(node.ops[0], self._special_cases)\n\n    def _is_left_node_valid(self, left: ast.AST) -> bool:\n        if isinstance(left, self._allowed_left_nodes):\n            return True\n        if isinstance(left, ast.BinOp):\n            left_node = self._is_left_node_valid(left.left)\n            right_node = self._is_left_node_valid(left.right)\n            return left_node or right_node\n        return False\n\n    def _has_wrong_nodes_on_the_right(\n        self,\n        comparators: Sequence[ast.AST],\n    ) -> bool:\n        for right in comparators:\n            if isinstance(right, self._allowed_left_nodes):\n                return True\n            if isinstance(right, ast.BinOp):\n                return self._has_wrong_nodes_on_the_right([\n                    right.left, right.right,\n                ])\n        return False\n\n    def _check_ordering(self, node: ast.Compare) -> None:\n        if self._is_left_node_valid(node.left):\n            return\n\n        if self._is_special_case(node):\n            return\n\n        if len(node.comparators) > 1:\n            return\n\n        if not self._has_wrong_nodes_on_the_right(node.comparators):\n            return\n\n        self.add_violation(ComparisonOrderViolation(node))\n\n    def visit_Compare(self, node: ast.Compare) -> None:\n        \"\"\"\n        Forbids comparision where argument doesn't come first.\n\n        Raises:\n            ComparisonOrderViolation\n\n        \"\"\"\n        self._check_ordering(node)\n        self.generic_visit(node)\n\n\n@alias('visit_any_if', (\n    'visit_If',\n    'visit_IfExp',\n))\nclass WrongConditionalVisitor(BaseNodeVisitor):\n    \"\"\"Finds wrong conditional arguments.\"\"\"\n\n    _forbidden_nodes: ClassVar[AnyNodes] = (\n        # Constants:\n        ast.Num,\n        ast.Str,\n        ast.Bytes,\n        ast.NameConstant,\n\n        # Collections:\n        ast.List,\n        ast.Set,\n        ast.Dict,\n        ast.Tuple,\n    )\n\n    def visit_any_if(self, node: AnyIf) -> None:\n        \"\"\"\n        Ensures that if statements are using valid conditionals.\n\n        Raises:\n            WrongConditionalViolation\n\n        \"\"\"\n        if isinstance(node, ast.If):\n            self._check_simplifiable_if(node)\n        else:\n            self._check_simplifiable_ifexpr(node)\n\n        self._check_if_statement_conditional(node)\n        self.generic_visit(node)\n\n    def _is_simplifiable_assign(\n        self,\n        node_body: List[ast.stmt],\n    ) -> Optional[str]:\n        wrong_length = len(node_body) != 1\n        if wrong_length or not isinstance(node_body[0], ast.Assign):\n            return None\n        if len(node_body[0].targets) != 1:\n            return None\n        if not isinstance(node_body[0].value, ast.NameConstant):\n            return None\n        if node_body[0].value.value is None:\n            return None\n        return astor.to_source(node_body[0].targets[0]).strip()\n\n    def _check_if_statement_conditional(self, node: AnyIf) -> None:\n        real_node = unwrap_unary_node(node.test)\n        if isinstance(real_node, self._forbidden_nodes):\n            self.add_violation(WrongConditionalViolation(node))\n\n    def _check_simplifiable_if(self, node: ast.If) -> None:\n        chain = getattr(node, 'wps_chain', None)\n        chained = getattr(node, 'wps_chained', None)\n        if chain is None and chained is None:\n            body_var = self._is_simplifiable_assign(node.body)\n            else_var = self._is_simplifiable_assign(node.orelse)\n            if body_var and body_var == else_var:\n                self.add_violation(SimplifiableIfViolation(node))\n\n    def _check_simplifiable_ifexpr(self, node: ast.IfExp) -> None:\n        conditions = set()\n        if isinstance(node.body, ast.NameConstant):\n            conditions.add(node.body.value)\n        if isinstance(node.orelse, ast.NameConstant):\n            conditions.add(node.orelse.value)\n\n        if conditions == {True, False}:\n            self.add_violation(SimplifiableIfViolation(node))\n", "path": "wemake_python_styleguide/visitors/ast/comparisons.py"}], "after_files": [{"content": "# -*- coding: utf-8 -*-\n\nimport ast\nfrom typing import ClassVar, List, Optional, Sequence\n\nimport astor\n\nfrom wemake_python_styleguide.logics.naming.name_nodes import is_same_variable\nfrom wemake_python_styleguide.logics.nodes import is_literal\nfrom wemake_python_styleguide.logics.operators import unwrap_unary_node\nfrom wemake_python_styleguide.types import AnyIf, AnyNodes, final\nfrom wemake_python_styleguide.violations.best_practices import (\n    SimplifiableIfViolation,\n)\nfrom wemake_python_styleguide.violations.consistency import (\n    ComparisonOrderViolation,\n    ConstantComparisonViolation,\n    MultipleInComparisonViolation,\n    RedundantComparisonViolation,\n    WrongConditionalViolation,\n)\nfrom wemake_python_styleguide.visitors.base import BaseNodeVisitor\nfrom wemake_python_styleguide.visitors.decorators import alias\n\n\n@final\nclass ComparisonSanityVisitor(BaseNodeVisitor):\n    \"\"\"Restricts the comparison of literals.\"\"\"\n\n    def _has_multiple_in_comparisons(self, node: ast.Compare) -> bool:\n        count = 0\n        for op in node.ops:\n            if isinstance(op, ast.In):\n                count += 1\n        return count > 1\n\n    def _check_literal_compare(self, node: ast.Compare) -> None:\n        last_was_literal = is_literal(node.left)\n        for comparator in node.comparators:\n            next_is_literal = is_literal(comparator)\n            if last_was_literal and next_is_literal:\n                self.add_violation(ConstantComparisonViolation(node))\n                break\n            last_was_literal = next_is_literal\n\n    def _check_redundant_compare(self, node: ast.Compare) -> None:\n        last_variable = node.left\n        for next_variable in node.comparators:\n            if is_same_variable(last_variable, next_variable):\n                self.add_violation(RedundantComparisonViolation(node))\n                break\n            last_variable = next_variable\n\n    def _check_multiple_in_comparisons(self, node: ast.Compare) -> None:\n        if self._has_multiple_in_comparisons(node):\n            self.add_violation(MultipleInComparisonViolation(node))\n\n    def visit_Compare(self, node: ast.Compare) -> None:\n        \"\"\"\n        Ensures that compares are written correctly.\n\n        Raises:\n            ConstantComparisonViolation\n            MultipleInComparisonViolation\n            RedundantComparisonViolation\n\n        \"\"\"\n        self._check_literal_compare(node)\n        self._check_redundant_compare(node)\n        self._check_multiple_in_comparisons(node)\n        self.generic_visit(node)\n\n\n@final\nclass WrongComparisionOrderVisitor(BaseNodeVisitor):\n    \"\"\"Restricts comparision where argument doesn't come first.\"\"\"\n\n    _allowed_left_nodes: ClassVar[AnyNodes] = (\n        ast.Name,\n        ast.Call,\n        ast.Attribute,\n        ast.Subscript,\n    )\n\n    _special_cases: ClassVar[AnyNodes] = (\n        ast.In,\n        ast.NotIn,\n    )\n\n    def _is_special_case(self, node: ast.Compare) -> bool:\n        \"\"\"\n        Operators ``in`` and ``not in`` are special cases.\n\n        Why? Because it is perfectly fine to use something like:\n        ``if 'key' in some_dict: ...``\n        This should not be an issue.\n\n        When there are multiple special operators it is still a separate issue.\n        \"\"\"\n        return isinstance(node.ops[0], self._special_cases)\n\n    def _is_left_node_valid(self, left: ast.AST) -> bool:\n        if isinstance(left, self._allowed_left_nodes):\n            return True\n        if isinstance(left, ast.BinOp):\n            left_node = self._is_left_node_valid(left.left)\n            right_node = self._is_left_node_valid(left.right)\n            return left_node or right_node\n        return False\n\n    def _has_wrong_nodes_on_the_right(\n        self,\n        comparators: Sequence[ast.AST],\n    ) -> bool:\n        for right in comparators:\n            if isinstance(right, self._allowed_left_nodes):\n                return True\n            if isinstance(right, ast.BinOp):\n                return self._has_wrong_nodes_on_the_right([\n                    right.left, right.right,\n                ])\n        return False\n\n    def _check_ordering(self, node: ast.Compare) -> None:\n        if self._is_left_node_valid(node.left):\n            return\n\n        if self._is_special_case(node):\n            return\n\n        if len(node.comparators) > 1:\n            return\n\n        if not self._has_wrong_nodes_on_the_right(node.comparators):\n            return\n\n        self.add_violation(ComparisonOrderViolation(node))\n\n    def visit_Compare(self, node: ast.Compare) -> None:\n        \"\"\"\n        Forbids comparision where argument doesn't come first.\n\n        Raises:\n            ComparisonOrderViolation\n\n        \"\"\"\n        self._check_ordering(node)\n        self.generic_visit(node)\n\n\n@alias('visit_any_if', (\n    'visit_If',\n    'visit_IfExp',\n))\nclass WrongConditionalVisitor(BaseNodeVisitor):\n    \"\"\"Finds wrong conditional arguments.\"\"\"\n\n    _forbidden_nodes: ClassVar[AnyNodes] = (\n        # Constants:\n        ast.Num,\n        ast.Str,\n        ast.Bytes,\n        ast.NameConstant,\n\n        # Collections:\n        ast.List,\n        ast.Set,\n        ast.Dict,\n        ast.Tuple,\n    )\n\n    def visit_any_if(self, node: AnyIf) -> None:\n        \"\"\"\n        Ensures that if statements are using valid conditionals.\n\n        Raises:\n            WrongConditionalViolation\n\n        \"\"\"\n        if isinstance(node, ast.If):\n            self._check_simplifiable_if(node)\n        else:\n            self._check_simplifiable_ifexpr(node)\n\n        self._check_if_statement_conditional(node)\n        self.generic_visit(node)\n\n    def _is_simplifiable_assign(\n        self,\n        node_body: List[ast.stmt],\n    ) -> Optional[str]:\n        wrong_length = len(node_body) != 1\n        if wrong_length or not isinstance(node_body[0], ast.Assign):\n            return None\n        if len(node_body[0].targets) != 1:\n            return None\n        if not isinstance(node_body[0].value, ast.NameConstant):\n            return None\n        if node_body[0].value.value is None:\n            return None\n        return astor.to_source(node_body[0].targets[0]).strip()\n\n    def _check_if_statement_conditional(self, node: AnyIf) -> None:\n        real_node = unwrap_unary_node(node.test)\n        if isinstance(real_node, self._forbidden_nodes):\n            self.add_violation(WrongConditionalViolation(node))\n\n    def _check_simplifiable_if(self, node: ast.If) -> None:\n        chain = getattr(node, 'wps_chain', None)\n        chained = getattr(node, 'wps_chained', None)\n        if chain is None and chained is None:\n            body_var = self._is_simplifiable_assign(node.body)\n            else_var = self._is_simplifiable_assign(node.orelse)\n            if body_var and body_var == else_var:\n                self.add_violation(SimplifiableIfViolation(node))\n\n    def _check_simplifiable_ifexpr(self, node: ast.IfExp) -> None:\n        conditions = set()\n        if isinstance(node.body, ast.NameConstant):\n            conditions.add(node.body.value)\n        if isinstance(node.orelse, ast.NameConstant):\n            conditions.add(node.orelse.value)\n\n        if conditions == {True, False}:\n            self.add_violation(SimplifiableIfViolation(node))\n", "path": "wemake_python_styleguide/visitors/ast/comparisons.py"}]}