def test_is_subclass_of_not_classdefs():
node = astroid.extract_node("""
class OneClass: #@
pass
""")
assert not utils.is_subclass_of(None, node)
assert not utils.is_subclass_of(node, None)
assert not utils.is_subclass_of(None, None)
def test_is_subclass_of_not_classdefs():
node = astroid.extract_node(
"""
class OneClass: #@
pass
"""
)
assert not utils.is_subclass_of(None, node)
assert not utils.is_subclass_of(node, None)
assert not utils.is_subclass_of(None, None)
def _check_try_except_raise(self, node):
def gather_exceptions_from_handler(
handler, ) -> typing.Optional[typing.List[NodeNG]]:
exceptions = [] # type: typing.List[NodeNG]
if handler.type:
exceptions_in_handler = utils.safe_infer(handler.type)
if isinstance(exceptions_in_handler, astroid.Tuple):
exceptions = list({
exception
for exception in exceptions_in_handler.elts
if isinstance(exception, astroid.Name)
})
elif exceptions_in_handler:
exceptions = [exceptions_in_handler]
else:
# Break when we cannot infer anything reliably.
return None
return exceptions
bare_raise = False
handler_having_bare_raise = None
excs_in_bare_handler = []
for handler in node.handlers:
if bare_raise:
# check that subsequent handler is not parent of handler which had bare raise.
# since utils.safe_infer can fail for bare except, check it before.
# also break early if bare except is followed by bare except.
excs_in_current_handler = gather_exceptions_from_handler(
handler)
if not excs_in_current_handler:
bare_raise = False
break
if excs_in_bare_handler is None:
# It can be `None` when the inference failed
break
for exc_in_current_handler in excs_in_current_handler:
inferred_current = utils.safe_infer(exc_in_current_handler)
if any(
utils.is_subclass_of(
utils.safe_infer(exc_in_bare_handler),
inferred_current)
for exc_in_bare_handler in excs_in_bare_handler):
bare_raise = False
break
# `raise` as the first operator inside the except handler
if _is_raising([handler.body[0]]):
# flags when there is a bare raise
if handler.body[0].exc is None:
bare_raise = True
handler_having_bare_raise = handler
excs_in_bare_handler = gather_exceptions_from_handler(
handler)
else:
if bare_raise:
self.add_message("try-except-raise",
node=handler_having_bare_raise)
def _check_try_except_raise(self, node):
bare_raise = False
handler_having_bare_raise = None
handler_type_having_bare_raise = None
for handler in node.handlers:
if bare_raise:
# check that subsequent handler is not parent of handler which had bare raise.
# since utils.safe_infer can fail for bare except, check it before.
# also break early if bare except is followed by bare except.
if (not handler.type or
handler_type_having_bare_raise and
utils.is_subclass_of(handler_type_having_bare_raise,
utils.safe_infer(handler.type))):
bare_raise = False
break
# `raise` as the first operator inside the except handler
if utils.is_raising([handler.body[0]]):
# flags when there is a bare raise
if handler.body[0].exc is None:
bare_raise = True
handler_having_bare_raise = handler
if handler_having_bare_raise.type:
handler_type_having_bare_raise = utils.safe_infer(
handler_having_bare_raise.type)
if bare_raise:
self.add_message('try-except-raise', node=handler_having_bare_raise)
def test_is_subclass_of_node_b_not_derived_from_node_a():
nodes = astroid.extract_node("""
class OneClass: #@
pass
class AnotherClass: #@
pass
""")
assert not utils.is_subclass_of(nodes[1], nodes[0])
def test_is_subclass_of_node_b_derived_from_node_a():
nodes = astroid.extract_node("""
class Superclass: #@
pass
class Subclass(Superclass): #@
pass
""")
assert utils.is_subclass_of(nodes[1], nodes[0])
def test_is_subclass_of_node_b_not_derived_from_node_a() -> None:
code = astroid.extract_node("""
class OneClass: #@
pass
class AnotherClass: #@
pass
""")
assert not utils.is_subclass_of(code[1], code[0])
def test_is_subclass_of_node_b_derived_from_node_a() -> None:
code = astroid.extract_node("""
class Superclass: #@
pass
class Subclass(Superclass): #@
pass
""")
assert utils.is_subclass_of(code[1], code[0])
def test_is_subclass_of_node_b_not_derived_from_node_a():
nodes = astroid.extract_node(
"""
class OneClass: #@
pass
class AnotherClass: #@
pass
"""
)
assert not utils.is_subclass_of(nodes[1], nodes[0])
def test_is_subclass_of_node_b_derived_from_node_a():
nodes = astroid.extract_node(
"""
class Superclass: #@
pass
class Subclass(Superclass): #@
pass
"""
)
assert utils.is_subclass_of(nodes[1], nodes[0])
def _check_try_except_raise(self, node):
def gather_exceptions_from_handler(handler):
exceptions = []
if handler.type:
exceptions_in_handler = utils.safe_infer(handler.type)
if isinstance(exceptions_in_handler, astroid.Tuple):
exceptions = {
exception
for exception in exceptions_in_handler.elts
if isinstance(exception, astroid.Name)
}
elif exceptions_in_handler:
exceptions = [exceptions_in_handler]
return exceptions
bare_raise = False
handler_having_bare_raise = None
excs_in_bare_handler = []
for handler in node.handlers:
if bare_raise:
# check that subsequent handler is not parent of handler which had bare raise.
# since utils.safe_infer can fail for bare except, check it before.
# also break early if bare except is followed by bare except.
excs_in_current_handler = gather_exceptions_from_handler(
handler)
if not excs_in_current_handler:
bare_raise = False
break
for exc_in_current_handler in excs_in_current_handler:
inferred_current = utils.safe_infer(exc_in_current_handler)
if any(
utils.is_subclass_of(
utils.safe_infer(exc_in_bare_handler),
inferred_current)
for exc_in_bare_handler in excs_in_bare_handler):
bare_raise = False
break
# `raise` as the first operator inside the except handler
if utils.is_raising([handler.body[0]]):
# flags when there is a bare raise
if handler.body[0].exc is None:
bare_raise = True
handler_having_bare_raise = handler
excs_in_bare_handler = gather_exceptions_from_handler(
handler)
if bare_raise:
self.add_message('try-except-raise',
node=handler_having_bare_raise)
def _check_try_except_raise(self, node):
def gather_exceptions_from_handler(handler):
exceptions = []
if handler.type:
exceptions_in_handler = utils.safe_infer(handler.type)
if isinstance(exceptions_in_handler, astroid.Tuple):
exceptions = {
exception
for exception in exceptions_in_handler.elts
if isinstance(exception, astroid.Name)
}
elif exceptions_in_handler:
exceptions = [exceptions_in_handler]
return exceptions
bare_raise = False
handler_having_bare_raise = None
excs_in_bare_handler = []
for handler in node.handlers:
if bare_raise:
# check that subsequent handler is not parent of handler which had bare raise.
# since utils.safe_infer can fail for bare except, check it before.
# also break early if bare except is followed by bare except.
excs_in_current_handler = gather_exceptions_from_handler(handler)
if not excs_in_current_handler:
bare_raise = False
break
for exc_in_current_handler in excs_in_current_handler:
inferred_current = utils.safe_infer(exc_in_current_handler)
if any(
utils.is_subclass_of(
utils.safe_infer(exc_in_bare_handler), inferred_current
)
for exc_in_bare_handler in excs_in_bare_handler
):
bare_raise = False
break
# `raise` as the first operator inside the except handler
if _is_raising([handler.body[0]]):
# flags when there is a bare raise
if handler.body[0].exc is None:
bare_raise = True
handler_having_bare_raise = handler
excs_in_bare_handler = gather_exceptions_from_handler(handler)
if bare_raise:
self.add_message("try-except-raise", node=handler_having_bare_raise)
def _check_try_except_raise(self, node):
bare_raise = False
handler_having_bare_raise = None
for handler in node.handlers:
if bare_raise:
# check that subsequent handler is not parent of handler which had bare raise.
if utils.is_subclass_of(utils.safe_infer(handler_having_bare_raise.type),
utils.safe_infer(handler.type)):
bare_raise = False
# `raise` as the first operator inside the except handler
if utils.is_raising([handler.body[0]]):
# flags when there is a bare raise
if handler.body[0].exc is None:
bare_raise = True
handler_having_bare_raise = handler
if bare_raise:
self.add_message('try-except-raise', node=handler_having_bare_raise)
