Skips applying transforms if data is not geographic.
169614
def skip(cb, msg, attributes):
    
    if not all(a in msg for a in attributes):
        return True
    plot = get_cb_plot(cb)
    return (not getattr(plot, 'geographic', False) or
            not hasattr(plot.current_frame, 'crs'))
912820
def ignore(mapping):
    
    if isinstance(mapping, Mapping):
        return AsDict(mapping)
    elif isinstance(mapping, list):
        return [ignore(item) for item in mapping]
    return mapping
72567
def skip(self, ns):
        
        return ns in (None, Namespace.default, Namespace.xsdns, Namespace.xsins, Namespace.xmlns)
811820
static public int skipWhiteSpace(byte[] data, int start) {
        int index = start + 1;
        while (index < data.length && BNFHeaders.SPACE == data[index]) {
            index++;
        }
        return index;
    }
1128782
def skip(mapping):
    
    found = set()
    for m in mapping:
        matched_atoms = set(m.values())
        if found.intersection(matched_atoms):
            continue
        found.update(matched_atoms)
        yield m
619267
private static boolean skipImport(File dir) {
        String[] files = dir.list();
        if (files != null) {
            for (String name : files) {
                if (".skipimport".equals(name)) {
                    return true;
                }
            }
        }

        return false;
    }
972861
def skip(type_name, filename):
    """"""
    report = ['Skipping {} file: {}'.format(type_name, filename)]
    report_stats = ReportStats(filename, report=report)
    return report_stats
246149
function skipIndex() {
		if( childType && childType.indexOf('[]') === childType.length-2 ) {
			childType = childType.substring(0, childType.length-2);
		}
	}
406120
public static void skip(DataInput in) throws IOException {
        int length = WritableUtils.readVInt(in);
        WritableUtils.skipFully(in, length);
    }
34675
def scrub(data, units=False):
    
    units = [i.unit if hasattr(i, 'unit') else 1 for i in data]
    data = [np.asarray(i.value if hasattr(i, 'unit') else i, dtype=np.float32) for i in data if
            isinstance(i, np.ndarray)]
    data = [i[np.where(~np.isinf(data[1]))] for i in data]
    data = [i[np.where(np.logical_and(data[1] > 0, ~np.isnan(data[1])))] for i in data]
    data = [i[np.unique(data[0], return_index=True)[1]] for i in data]
    return [i[np.lexsort([data[0]])] * Q for i, Q in zip(data, units)] if units else [i[np.lexsort([data[0]])] for i in
                                                                                      data]
244573
private void skip() throws IOException, KriptonRuntimeException {
		while (position < limit || fillBuffer(1)) {
			int c = buffer[position];
			if (c > ' ') {
				break;
			}
			position++;
		}
	}
1327439
def skip( index, start )
      if @index == index
        Lookup.new @p.lookup( start, @stride ), @index, @stride
      else
        Lookup.new @p.skip( index, start ), @index, @stride
      end
    end
1140902
def _skip_whitespace(self):
        """"""
        i = 0
        while self._cur_token['type'] is TT.ws and not self._finished:
            self._increment()
            i += 1

        return i
6013
private int skipLineSpace(int index) {
		while (index < tokens.size() && isLineSpace(tokens.get(index))) {
			index++;
		}
		return index;
	}
967106
def _skip_to_nonblank(f, spacegroup, setting):
    """"""
    while True:
        line1 = f.readline()
        if not line1:
            raise SpacegroupNotFoundError(
                'invalid spacegroup %s, setting %i not found in data base' %
                ( spacegroup, setting ) )
        line1.strip()
        if line1 and not line1.startswith('#'):
            line2 = f.readline()
            break
    return line1, line2
338884
def omit_deep(omit_props, dct):
    

    omit_partial = omit_deep(omit_props)

    if isinstance(dict, dct):
        # Filter out keys and then recurse on each value that wasn't filtered out
        return map_dict(omit_partial, compact_dict(omit(omit_props, dct)))
    if isinstance((list, tuple), dct):
        # run omit_deep on each value
        return map(omit_partial, dct)
    # scalar
    return dct
979124
private void skipWhitespaces(final XMLEventReader paramReader) throws XMLStreamException {
        while (paramReader.peek().getEventType() == XMLStreamConstants.CHARACTERS
            && paramReader.peek().asCharacters().isWhiteSpace()) {
            paramReader.nextEvent();
        }
    }