def _flat_assign_names(self, nodes: List[AnyAssign]) -> Container[str]: flat_assigns = [] for attribute in nodes: targets = get_assign_targets(attribute) flat_assigns.extend( [at.id for at in targets if isinstance(at, ast.Name)]) return set(flat_assigns)
def _contains_slots_assign(self, node: AnyAssign) -> bool: targets = get_assign_targets(node) for target in targets: if isinstance(target, ast.Name) and target.id == '__slots__': return True return False
def check_attribute_name(self, node: ast.ClassDef) -> None: top_level_assigns = [ sub_node for sub_node in node.body if isinstance(sub_node, AssignNodes) ] for assignment in top_level_assigns: for target in get_assign_targets(assignment): self._ensure_case(target)
def check_attribute_name(self, node: ast.ClassDef) -> None: top_level_assigns = [ sub for sub in ast.walk(node) if isinstance(sub, AssignNodes) and nodes.get_context(sub) is node ] for assignment in top_level_assigns: for target in get_assign_targets(assignment): self._ensure_case(target)
def check_attribute_names(self, node: ast.ClassDef) -> None: class_attributes, _ = classes.get_attributes( node, include_annotated=True, ) for assign in class_attributes: for target in get_assign_targets(assign): for attr_name in name_nodes.get_variables_from_node(target): self._ensure_case(assign, attr_name)
def _check_metadata(self, node: AnyAssign) -> None: if not isinstance(nodes.get_parent(node), ast.Module): return targets = get_assign_targets(node) for target_node in targets: target_node_id = _get_name_from_node(target_node) if target_node_id in MODULE_METADATA_VARIABLES_BLACKLIST: self.add_violation( WrongModuleMetadataViolation(node, text=target_node_id), )
def _check_assignment(self, node: AnyAssign) -> None: target_names = self._create_target_names(get_assign_targets(node), ) if isinstance(node.value, ast.Tuple): node_values = node.value.elts values_names = tuple( _get_name_from_node(node_value) for node_value in node_values) else: values_names = _get_name_from_node(node.value) # type: ignore has_repeatable_values = len(target_names) != len(set(target_names)) if values_names in target_names or has_repeatable_values: self.add_violation(ReassigningVariableToItselfViolation(node))
def check_attribute_name(self, node: ast.ClassDef) -> None: top_level_assigns = [ sub_node for sub_node in node.body if isinstance(sub_node, AssignNodes) ] for assignment in top_level_assigns: for target in get_assign_targets(assignment): if not isinstance(target, ast.Name): continue name = _get_name_from_node(target) if name and logical.is_upper_case_name(name): self._error_callback( naming.UpperCaseAttributeViolation(target, text=name), )
def _is_simplifiable_assign( self, node_body: List[ast.stmt], ) -> Optional[str]: wrong_length = len(node_body) != 1 if wrong_length or not isinstance(node_body[0], AssignNodes): return None if not isinstance(node_body[0].value, ast.NameConstant): return None if node_body[0].value.value is None: return None targets = get_assign_targets(node_body[0]) if len(targets) != 1: return None return source.node_to_string(targets[0])
def _check_metadata(self, node: AnyAssign) -> None: if not isinstance(nodes.get_parent(node), ast.Module): return targets = get_assign_targets(node) for target_node in targets: if not isinstance(target_node, ast.Name): continue if target_node.id not in MODULE_METADATA_VARIABLES_BLACKLIST: continue self.add_violation( best_practices.WrongModuleMetadataViolation( node, text=target_node.id, ), )
def flat_variable_names(nodes: Iterable[AnyAssignWithWalrus]) -> Iterable[str]: """ Returns flat variable names from several nodes. Use this function when you need to get list of string variable names from assign nodes. Here's an example: >>> import ast >>> tree = ast.parse('x: int = 0') >>> node = tree.body[0] >>> list(flat_variable_names([node])) ['x'] >>> tree = ast.parse('z = y = 0') >>> node = tree.body[0] >>> list(flat_variable_names([node])) ['z', 'y'] """ return itertools.chain.from_iterable( (get_variables_from_node(target) for node in nodes for target in get_assign_targets(node)))
def _is_assigned_target(self, node: ast.Subscript) -> bool: parent = nodes.get_parent(node) if not isinstance(parent, (*AssignNodes, ast.AugAssign)): return False return any(node == target for target in get_assign_targets(parent))