Return songs that have the fingerprinted flag set TRUE (1).
767220
def get_songs()->Iterator:
    
    with session_withcommit() as session:
        val = session.query(songs).all()
        for row in val:
            yield row
201979
private boolean matchesFingerprint(byte[] buffer, Pattern fingerprint)
   {
      return fingerprint.matcher(m_charset == null ? new String(buffer) : new String(buffer, m_charset)).matches();
   }
1179663
function findPublicKey(context) {
    var fingerprints = context.resPQ.server_public_key_fingerprints.getList();
    if (logger.isDebugEnabled()) {
        logger.debug('Public keys fingerprints from server: %s', fingerprints);
    }
    for (var i = 0; i < fingerprints.length; i++) {
        var fingerprint = fingerprints[i];
        if (logger.isDebugEnabled()) {
            logger.debug('Searching fingerprint %s in store', fingerprint);
        }
        var publicKey = security.PublicKey.retrieveKey(fingerprint);
        if (publicKey) {
            if (logger.isDebugEnabled()) {
                logger.debug('Fingerprint %s found in keyStore.', fingerprint);
            }
            context.fingerprint = fingerprint;
            context.publicKey = publicKey;
            return context;
        }
    }
    throw createError('Fingerprints from server not found in keyStore.', 'EFINGERNOTFOUND');
}
608503
def file_fingerprint(fullpath):
    
    stat = os.stat(fullpath)
    return ','.join([str(value) for value in [stat.st_ino, stat.st_mtime, stat.st_size] if value])
316424
public static String fingerprint(Class cl, String methodName) {
		return fingerprint(cl.getCanonicalName() + "." + methodName);
	}
1283043
def song(self):
        """"""
        if self._song is None:
            self._song = Song(self._song_data)

        return self._song
1333675
public boolean hasChordNames() {
		MusicElement currentScoreEl;
		Iterator it = iterator();
		while (it.hasNext()) {
			currentScoreEl = (MusicElement) it.next();
			if (currentScoreEl instanceof NoteAbstract) {
				if (((NoteAbstract) currentScoreEl).getChordName() != null)
					return true;
			}
		}
		return false;
	}
847033
public List<String> getFingerprints() {
        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
            SibTr.entry(this, tc, "getFingerprints");
        List<String> ids = (List<String>) getHdr2().getField(JsHdr2Access.FINGERPRINTS_RFPLIST_ID);
        if (ids != null) {
            // Don't return the actual JSVaryingListImpl contained in the message.
            ids = new ArrayList<String>(ids);
        }
        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
            SibTr.exit(this, tc, "getFingerprints", ids);
        return ids;
    }
509136
private boolean matchesFingerprint(byte[] buffer, byte[] fingerprint)
   {
      return Arrays.equals(fingerprint, Arrays.copyOf(buffer, fingerprint.length));
   }
293326
def fingerprint(blob):
    
    digest = hashlib.md5(blob).digest()
    return ':'.join('{:02x}'.format(c) for c in bytearray(digest))
538679
def gpg_fingerprint(key):
    """"""
    if (len(key) == 8 and re.match(r'^[0-9A-F]{8}$', key)) or \
       (len(key) == 40 and re.match(r'^[0-9A-F]{40}$', key)):
        return

    raise aomi.exceptions.Validation('Invalid GPG Fingerprint')
489706
def get_flagged_names():
    """"""

    l = []
    for w in _widget_cache.values():
        if w.flagged:
            l.append(w.get_node().get_value())
    return l
1098627
function getFingerprintsForAnimal(animalDir) {
	if (!fs.existsSync(animalDir) || !fs.statSync(animalDir).isDirectory()) {
		return false;
	}

	var fgpFiles = fs.readdirSync(animalDir).filter(function (entry) {
		return entry.split('.').pop().toLowerCase() == 'fgp';
	});

	var fgps = [];
	fgpFiles.forEach(function (fgpFile) {
		fgpFile = path.join(animalDir, fgpFile);
		var fgpData = fgpReader(fgpFile);
		fgps.push({
			id: path.basename(fgpFile, '.fgp'),
			fgp: fgpData,
			img64: 'data:image/jpeg;base64,' + fs.readFileSync(getFGPImageName(fgpFile)).toString('base64')
		});
	});
	return fgps;
}
870129
def fingerprint_from_file(filename):
    """"""
    cmd = flatten([gnupg_bin(), gnupg_home(), filename])
    outp = stderr_output(cmd).split('\n')
    if not outp[0].startswith('pub'):
        raise CryptoritoError('probably an invalid gpg key')

    return outp[1].strip()
1013856
def songs(self, *, uploaded=True, purchased=True):
		

		if not uploaded and not purchased:
			raise ValueError("'uploaded' and 'purchased' cannot both be False.")

		if purchased and uploaded:
			song_list = []
			for chunk in self.songs_iter(export_type=1):
				song_list.extend(chunk)
		elif purchased:
			song_list = []
			for chunk in self.songs_iter(export_type=2):
				song_list.extend(chunk)
		elif uploaded:
			purchased_songs = []
			for chunk in self.songs_iter(export_type=2):
				purchased_songs.extend(chunk)

			song_list = [
				song
				for chunk in self.songs_iter(export_type=1)
				for song in chunk
				if song not in purchased_songs
			]

		return song_list
276042
function getFingerprintForURL(url) {
	var domain = getDomain(url);
	var found = global.requestSSLFingerprints[domain];
	debug('getFingerprintForURL %s -> %s=%s',url,domain,found);
	if (!found) {
		// try a wildcard search
		var u = urlib.parse(domain),
			tokens = (u && u.host || domain).split('.');
		domain = '*.'+tokens.splice(tokens.length > 1 ? 0 : 1).join('.');
		found = global.requestSSLFingerprints[domain];
		debug('getFingerprintForURL (wildcard) %s -> %s=%s',url,domain,found);
	}
	return found;
}
778630
def fingerprint_from_keybase(fingerprint, kb_obj):
    """"""
    if 'public_keys' in kb_obj and \
       'pgp_public_keys' in kb_obj['public_keys']:
        for key in kb_obj['public_keys']['pgp_public_keys']:
            keyprint = fingerprint_from_var(key).lower()
            fingerprint = fingerprint.lower()
            if fingerprint == keyprint or \
               keyprint.startswith(fingerprint) or \
               keyprint.endswith(fingerprint):
                return {
                    'fingerprint': keyprint,
                    'bundle': key
                }

    return None