returns all lines that do not contain what
        :param lines: 
        :param what: 
        :return:
972484
def remove_line_with(cls, lines, what):
        
        result = []
        for line in lines:
            if what not in line:
                result = result + [line]
        return result
510737
private boolean contains(Line line) { 
         return contains(line.getX1(), line.getY1()) && contains(line.getX2(), line.getY2()); 
    }
1145061
def strip_units_from_lines(lines):
    
    for line in lines:
        for unit in ALL_UNITS:
            if line.endswith(" %s" % unit):
                line = line[:-1-len(unit)]
        yield line
1369724
def parse(self, lines):
        ''''''
        if self.type == 'msdos':
            return self.parse_msdos(lines)
        elif self.type == 'unix':
            return self.parse_unix(lines)
        elif self.type == 'nlst':
            return self.parse_nlst(lines)
        else:
            raise UnknownListingError('Unsupported listing type.')
661390
def find_in_line(line):  # type: (str) -> Optional[str]
    
    if not line:
        return None

    for method in [find_by_ast, find_version_by_string_lib, find_version_by_regex]:
        by = method(line)
        by = validate_string(by)
        if by:
            return by
    return None
1202821
def __remove_leading_empty_lines(lines):
        
        tmp = list()
        empty = True
        for i in range(0, len(lines)):
            empty = empty and lines[i] == ''
            if not empty:
                tmp.append(lines[i])

        return tmp
183676
def inspect(lines):
    
    labels = set()
    count = 0
    exp = re.compile(r">.*?<([\w ]+)>")  # Space should be accepted
    valid = False
    for line in lines:
        if line.startswith("M  END\n"):
            valid = True
        elif line.startswith("$$$$"):
            count += 1
            valid = False
        else:
            result = exp.match(line)
            if result:
                labels.add(result.group(1))
    if valid:
        count += 1
    return list(labels), count
1268917
def _skip_lines(self, n):
        ''''''
        for i in range(n):
            self.line = next(self.output)
        return self.line
1314590
def _combine_lines(self, lines):
        
        lines = filter(None, map(lambda x: x.strip(), lines))
        return '[' + ','.join(lines) + ']'
729098
private boolean fileIncludesLine(File file, String matches) throws IOException {
        for (String line: Files.readLines(file)) {
            String trimmed = line.trim();
            if (trimmed.equals(matches)) {
                return true;
            }
        }
        return false;
    }
821702
def _line_parse(line):
    
    if line[-2:] in ['\r\n', b'\r\n']:
        return line[:-2], True
    elif line[-1:] in ['\r', '\n', b'\r', b'\n']:
        return line[:-1], True
    return line, False
559551
def read_lines lines, options = {}
      table_apply = TableApply.new(options)

      header = table_apply.parse_header(lines[0], options)
      Validator::valid_header?(header, @header)  # compare against older header when merging
      column_index,header = table_apply.column_index(header) # we may rewrite the header
      @header = header if not @header
 
      newheader = @header[1..-1]
      # parse the rest
      prev_line = newheader
      (lines[1..-1]).each_with_index do | line, line_num |
        rowname, data_fields = table_apply.parse_row(line_num, line, newheader, column_index, prev_line, options)
        if data_fields
          @rownames << rowname if not options[:with_rownames] # otherwise doubles rownames
          @rows << data_fields if data_fields
        end
        prev_line = data_fields
      end
      return @rownames,@rows
    end
756374
def get_lines(self):
        
        with open(self.path, "r") as data:
            self.lines = data.readlines()  # store data in arrays

        return self.lines
774
def filter_assert_nodes(nodes: List[ast.stmt], min_line_number: int) -> List[ast.stmt]:
    
    return [node for node in nodes if node.lineno > min_line_number]
594002
def matching_text_element_lines(re, exclude_nested=[:a])
      matches = []
      find_type_elements_except(:text, exclude_nested).each do |e|
        first_line = e.options[:location]
        # We'll error out if kramdown doesn't have location information for
        # the current element. It's better to just not match in these cases
        # rather than crash.
        next if first_line.nil?
        lines = e.value.split("\n")
        lines.each_with_index do |l, i|
          matches << first_line + i if re.match(l)
        end
      end
      matches
    end
1204778
public function filterEmptyLines(array $lines)
    {
        return array_filter($lines, function ($line) {
            $line = trim($line);

            return $line !== '*' ? $line : false;
        });
    }
223955
def get_noqa_suppressions(file_contents):
    
    ignore_whole_file = False
    ignore_lines = set()
    for line_number, line in enumerate(file_contents):
        if _FLAKE8_IGNORE_FILE.search(line):
            ignore_whole_file = True
        if _PEP8_IGNORE_LINE.search(line):
            ignore_lines.add(line_number + 1)
    return ignore_whole_file, ignore_lines