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)