def checkfiles(args):
"""Checks existence of files based on your criteria"""
from .query import Database
db = Database()
objects = db.objects()
# go through all files, check if they are available on the filesystem
good = {}
bad = {}
for file in objects:
if os.path.exists(file.make_path(args.directory, args.extension)):
good[file.id] = file
else:
bad[file.id] = file
# report
output = sys.stdout
if args.selftest:
output = utils.null()
if bad:
for id, file in bad.items():
output.write('Cannot find file "%s"\n' % (file.make_path(args.directory, args.extension),))
output.write('%d files (out of %d) were not found at "%s"\n' % \
(len(bad), len(objects), args.directory))
return 0
def checkfiles(args):
"""Checks the existence of the files based on your criteria"""
#from .__init__ import Database
from .query import Database
db = Database()
#objects = db.objects(groups=args.group, cls=args.cls, qualities=args.quality, types=args.attack_type)
objects = db.objects(quality=args.quality, instrument=args.attack_type, fold=args.fold, group=args.group, cls=args.cls)
# go through all files, check if they are available on the filesystem
good = []
bad = []
for obj in objects:
if os.path.exists(obj.make_path(directory=args.directory, extension=args.extension)): good.append(obj)
else: bad.append(obj)
# report
output = sys.stdout
if args.selftest:
from bob.db.base.utils import null
output = null()
if bad:
for obj in bad:
output.write('Cannot find file "%s"\n' % (obj.make_path(directory=args.directory, extension=args.extension),))
output.write('%d files (out of %d) were not found at "%s"\n' % \
(len(bad), len(objects), args.directory))
return 0
def dumplist(args):
"""Dumps lists of files based on your criteria"""
from .query import Database
db = Database()
model_ids = None
if args.models is not None:
if isinstance(args.models, (list, tuple)): model_ids = args.models
else: model_ids = (args.models,)
r = db.objects(
protocol=args.protocol,
purposes=args.purpose,
model_ids=model_ids,
groups=args.group,
classes=args.sclass
)
output = sys.stdout
if args.selftest:
from bob.db.base.utils import null
output = null()
for f in r:
output.write('%s\n' % (f.make_path(args.directory, args.extension),))
return 0
def checkfiles(args):
"""Checks existence of files based on your criteria"""
from .query import Database
db = Database()
r = db.objects(protocol=args.protocol)
# go through all files, check if they are available on the filesystem
good = []
bad = []
for f in r:
if os.path.exists(f.make_path(args.directory, args.extension)):
good.append(f)
else:
bad.append(f)
# report
output = sys.stdout
if args.selftest:
from bob.db.base.utils import null
output = null()
if bad:
for f in bad:
output.write('Cannot find file "%s"\n' %
(f.make_path(args.directory, args.extension), ))
output.write('%d files (out of %d) were not found at "%s"\n' % \
(len(bad), len(r), args.directory))
return 0
def __dump__(args):
"""Dumps the database to stdout.
Keyword arguments:
args
A argparse.Arguments object with options set. We use two of the options:
``cls`` for the class to be dumped (if None, then dump all data) and
``selftest``, which runs the internal test.
"""
d = data()
if args.cls: d = {args.cls: d[args.cls]}
output = sys.stdout
if args.selftest:
from bob.db.base.utils import null
output = null()
for k, v in d.items():
for array in v:
s = ','.join(['%.1f' % array[i] for i in range(array.shape[0])] + [k])
output.write('%s\n' % (s,))
return 0
def dumplist(args):
"""Dumps lists of files based on your criteria"""
from .query import Database
db = Database()
r = db.objects(
groups=args.group,
protocol=args.protocol,
purposes=args.purpose,
model_ids=args.client,
genders=args.gender,
ages=args.age,
lightings=args.lighting,
poses=args.pose,
expressions=args.expression,
accessories=args.accessory,
distances=args.distance,
sessions=args.session,
backgrounds=args.background
)
output = sys.stdout
if args.selftest:
from bob.db.base.utils import null
output = null()
for f in r:
output.write('%s\n' % (f.make_path(args.directory, args.extension),))
return 0
def dumplist(args):
"""Dumps lists of files based on your criteria"""
from .query import Database
db = Database()
r = db.objects(
groups=args.group,
protocol=args.protocol,
purposes=args.purpose,
model_ids=args.client,
sessions=args.session,
expressions=args.expression,
illuminations=args.illumination,
occlusions=args.occlusion)
output = sys.stdout
if args.selftest:
from bob.db.base.utils import null
output = null()
for f in r:
output.write('%s\n' % (f.make_path(args.directory, args.extension),))
return 0
def checkfiles(args):
"""Checks the existence of the files based on your criteria."""
from .__init__ import Database
db = Database()
r = db.objects()
# go through all files, check if they are available
good = {}
bad = {}
for f in r:
if os.path.exists(f.make_path(directory=args.directory, extension=args.extension)): good[f.id] = f.make_path(directory=args.directory, extension=args.extension)
else: bad[f.id] = f.make_path(directory=args.directory, extension=args.extension)
# report
output = sys.stdout
if args.selftest:
from bob.db.base.utils import null
output = null()
if bad:
for f in bad:
output.write('Cannot find file "%s"\n' % (f,))
output.write('%d files (out of %d) were not found at "%s"\n' % \
(len(bad), len(r), args.directory))
return 0
def checkfiles(args):
"""Checks existence of files based on your criteria"""
from .query import Database
db = Database()
objects = db.objects()
# go through all files, check if they are available on the filesystem
good = {}
bad = {}
for file in objects:
if os.path.exists(file.make_path(args.directory, args.extension)):
good[file.id] = file
else:
bad[file.id] = file
# report
output = sys.stdout
if args.selftest:
output = utils.null()
if bad:
for id, file in bad.items():
output.write('Cannot find file "%s"\n' %
(file.make_path(args.directory, args.extension), ))
output.write('%d files (out of %d) were not found at "%s"\n' % \
(len(bad), len(objects), args.directory))
return 0
def checkfiles(args):
"""Checks the existence of the files based on your criteria"""
db = Database()
objects = db.objects(protocol=args.protocol,
purposes=args.purposes,
groups=args.groups,
kinds=args.kinds)
# go through all files, check if they are available on the filesystem
good = []
bad = []
for obj in objects:
if os.path.exists(obj.make_path(directory=args.directory)):
good.append(obj)
else:
bad.append(obj)
# report
output = sys.stdout
if args.selftest:
from bob.db.base.utils import null
output = null()
if bad:
for obj in bad:
output.write('Cannot find file "%s"\n' %
obj.make_path(directory=args.directory))
output.write('%d files (out of %d) were not found at "%s"\n' % \
(len(bad), len(objects), args.directory))
return 0
def checkfiles(args):
"""Checks the existence of the files based on your criteria"""
#from .__init__ import Database
db = Database()
objects = db.objects(groups=args.group, cls=args.cls, qualities=args.quality, types=args.attack_type)
# go through all files, check if they are available on the filesystem
good = []
bad = []
for obj in objects:
if os.path.exists(obj.make_path(directory=args.directory, extension=args.extension)): good.append(obj)
else: bad.append(obj)
# report
output = sys.stdout
if args.selftest:
from bob.db.base.utils import null
output = null()
if bad:
for obj in bad:
output.write('Cannot find file "%s"\n' % (obj.make_path(directory=args.directory, extension=args.extension),))
output.write('%d files (out of %d) were not found at "%s"\n' % \
(len(bad), len(objects), args.directory))
return 0
def _checkfiles(args):
"""Checks the existence of the files based on your criteria."""
from . import Database
db = Database()
r = db.objects(group=args.group)
# go through all files, check if they are available
bad = [f for f in r if not os.path.exists(f.make_path(
directory=args.directory, extension=args.extension))]
# report
output = sys.stdout
if args.selftest:
from bob.db.base.utils import null
output = null()
if bad:
for f in bad:
output.write('Cannot find file "%s"\n' % f.make_path(
directory=args.directory, extension=args.extension))
output.write('%d files (out of %d) were not found at "%s"\n' %
(len(bad), len(r), args.directory))
return 0
def __dump__(args):
"""Dumps the database to stdout.
Keyword arguments:
args
A argparse.Arguments object with options set. We use two of the options:
``cls`` for the class to be dumped (if None, then dump all data) and
``selftest``, which runs the internal test.
"""
d = data()
if args.cls: d = {args.cls: d[args.cls]}
output = sys.stdout
if args.selftest:
from bob.db.base.utils import null
output = null()
for k, v in d.items():
for array in v:
s = ','.join(['%.1f' % array[i]
for i in range(array.shape[0])] + [k])
output.write('%s\n' % (s, ))
return 0
def checkfiles(args):
"""Checks lists of files based on your criteria"""
from .query import Database
db = Database()
# go through all files, check if they are available on the filesystem
good = {}
bad = {}
for protocol in db.m_valid_protocols:
r = db.objects(protocol=protocol)
for f in r:
if os.path.exists(f.make_path(args.directory, args.extension)):
good[f.id] = f
else:
bad[f.id] = f
# report
output = sys.stdout
if args.selftest:
from bob.db.base.utils import null
output = null()
if bad:
for id, f in bad.items():
output.write('Cannot find file "%s"\n' % f.make_path(args.directory, args.extension))
output.write('%d files (out of %d) were not found at "%s"\n' % \
(len(bad), len(r), args.directory))
return 0
def checkfiles(args):
"""Checks lists of files based on your criteria"""
from .query import Database
db = Database()
# go through all files, check if they are available on the filesystem
good = {}
bad = {}
for protocol in db.m_valid_protocols:
r = db.objects(protocol=protocol)
for f in r:
if os.path.exists(f.make_path(args.directory, args.extension)):
good[f.id] = f
else:
bad[f.id] = f
# report
output = sys.stdout
if args.selftest:
from bob.db.base.utils import null
output = null()
if bad:
for id, f in bad.items():
output.write('Cannot find file "%s"\n' %
f.make_path(args.directory, args.extension))
output.write('%d files (out of %d) were not found at "%s"\n' % \
(len(bad), len(r), args.directory))
return 0
def annotations(args):
"""Returns a list of file database identifiers given the path stems"""
from .query import Database
db = Database(args.directory)
output = sys.stdout
if args.selftest:
from bob.db.base.utils import null
output = null()
f = db.files([args.id])
if len(f) != 1:
output.write('Cannot find file with id "%d" in database\n' % args.id)
return 1
a = db.annotations(f[0])
k = sorted(a.keys(), key=lambda x: int(x.split('.')[1]))
for i in k:
output.write("\n%s " % i)
for f in a[i]:
output.write('%s : (%3.2f, %3.2f) ' % (f, a[i][f][0], a[i][f][1]))
output.write("\n")
if not a: return 1
return 0
def checkfiles(args):
"""Checks existence of files based on your criteria"""
from .query import FileListBioDatabase
db = FileListBioDatabase(args.list_directory, 'bio_filelist', use_dense_probe_file_list=False)
r = db.objects(protocol=args.protocol)
# go through all files, check if they are available on the filesystem
good = []
bad = []
for f in r:
if os.path.exists(f.make_path(args.directory, args.extension)):
good.append(f)
else:
bad.append(f)
# report
output = sys.stdout
if args.selftest:
from bob.db.base.utils import null
output = null()
if bad:
for f in bad:
output.write('Cannot find file "%s"\n' % f.make_path(args.directory, args.extension))
output.write('%d files (out of %d) were not found at "%s"\n' %
(len(bad), len(r), args.directory))
return 0
def _checkfiles(args):
"""Checks the existence of the files based on your criteria."""
from . import Database
db = Database()
r = db.objects(group=args.group)
# go through all files, check if they are available
bad = [
f for f in r if not os.path.exists(
f.make_path(directory=args.directory, extension=args.extension))
]
# report
output = sys.stdout
if args.selftest:
from bob.db.base.utils import null
output = null()
if bad:
for f in bad:
output.write('Cannot find file "%s"\n' % f.make_path(
directory=args.directory, extension=args.extension))
output.write('%d files (out of %d) were not found at "%s"\n' %
(len(bad), len(r), args.directory))
return 0
def reverse(args):
"""Returns a list of file database identifiers given the path stems"""
from .query import Database
db = Database()
output = sys.stdout
if args.selftest:
from bob.db.base.utils import null
output = null()
r = db.reverse(args.path)
for f in r: output.write('%d\n' % f.id)
if not r: return 1
return 0
def dumplist(args):
"""Dumps lists of files on the database, inputs your arguments"""
from . import Database
db = Database()
objects = db.objects()
output = sys.stdout
if args.selftest:
from bob.db.base.utils import null
output = null()
for obj in objects:
output.write('%s\n' % (obj.make_path(directory=args.directory, extension=args.extension),))
return 0
def path(args):
"""Returns a list of fully formed paths or stems given some file id"""
from .query import Database
db = Database()
output = sys.stdout
if args.selftest:
from bob.db.base.utils import null
output = null()
r = db.paths(args.id, prefix=args.directory, suffix=args.extension)
for path in r: output.write('%s\n' % path)
if not r: return 1
return 0
def dumplist(args):
"""Dumps lists of files based on your criteria"""
#from .__init__ import Database
db = Database()
objects = db.objects(groups=args.group, cls=args.cls, qualities=args.quality, types=args.attack_type)
output = sys.stdout
if args.selftest:
from bob.db.base.utils import null
output = null()
for obj in objects:
output.write('%s\n' % (obj.make_path(directory=args.directory, extension=args.extension),))
return 0
def reverse(args):
"""Returns a list of file database identifiers given the path stems"""
from .query import Database
db = Database()
output = sys.stdout
if args.selftest:
from bob.db.base.utils import null
output = null()
r = db.reverse(args.path)
for id in r: output.write('%d\n' % id)
if not r: return 1
return 0
def path(args):
"""Returns a list of fully formed paths or stems given some file id"""
from .query import Database
db = Database()
output = sys.stdout
if args.selftest:
from bob.db.base.utils import null
output = null()
r = db.paths(args.id, prefix=args.directory, suffix=args.extension)
for path in r: output.write('%s\n' % path)
if not r: return 1
return 0
def _dumplist(args):
"""Dumps lists of files based on your criteria."""
from .__init__ import Database
db = Database()
r = db.objects(group=args.group)
output = sys.stdout
if args.selftest:
from bob.db.base.utils import null
output = null()
for f in r:
output.write('%s\n' % f.make_path(
directory=args.directory, extension=args.extension))
return 0
def dumplist(args):
"""Dumps lists of files based on your criteria"""
from .query import Database
db = Database()
r = db.objects(protocol=args.protocol,
groups=args.group,
purposes=args.purpose)
output = sys.stdout
if args.selftest:
from bob.db.base.utils import null
output = null()
for f in r:
output.write('%s\n' % f.make_path(args.directory, args.extension))
return 0
def _dumplist(args):
"""Dumps lists of files based on your criteria."""
from .__init__ import Database
db = Database()
r = db.objects(group=args.group)
output = sys.stdout
if args.selftest:
from bob.db.base.utils import null
output = null()
for f in r:
output.write(
'%s\n' %
f.make_path(directory=args.directory, extension=args.extension))
return 0
def dumplist(args):
"""Dumps lists of files based on your criteria"""
from .query import Database
db = Database()
r = db.objects(groups=args.group,
subworld=args.subworld,
protocol=args.protocol,
purposes=args.purpose)
output = sys.stdout
if args.selftest:
output = utils.null()
for file in r:
output.write('%s\n' % file.make_path(args.directory, args.extension))
return 0
def dumplist(args):
"""Dumps lists of files based on your criteria"""
db = Database()
objects = db.objects(protocol=args.protocol,
purposes=args.purposes,
groups=args.groups,
kinds=args.kinds)
output = sys.stdout
if args.selftest:
from bob.db.base.utils import null
output = null()
for obj in objects:
output.write('%s\n' % obj.make_path(directory=args.directory))
return 0
def checkfiles(args):
"""Checks existence of files based on your criteria"""
from .query import Database
protocols = ['search_split%d' % s for s in range(1, 11)]
protocols.extend(['compare_split%d' % s for s in range(1, 11)])
for p in protocols:
db = Database()
r = db.objects(protocol=p)
good = {}
bad = {}
# go through all files, check if they are available on the filesystem
for f in r:
found = False
for e in args.extension:
if os.path.exists(f.make_path(args.directory, e)):
good[f.id] = f.make_path(args.directory, e)
found = True
break
if not found:
bad[f.id] = f.make_path(args.directory, args.extension[0])
# report
output = sys.stdout
if args.selftest:
from bob.db.base.utils import null
output = null()
if bad:
for id, f in bad.items():
output.write('Cannot find file "%s"\n' % f)
output.write('%d files (out of %d) were not found at "%s"\n' % \
(len(bad), len(r), args.directory))
else:
output.write('All files were found !!!')
return 0
def reverse(args):
"""Returns a list of file database identifiers given the path stems"""
from .query import Database
db = Database()
output = sys.stdout
if args.selftest:
from bob.db.base.utils import null
output = null()
try:
r = db.reverse(args.path)
except KeyError as err:
raise DatabaseError("One or more of the input paths wasn't found - original error message:\nKeyError: {}".format(err))
for f in r: output.write('%d\n' % f.id)
if not r: return 1
return 0
def dumplist(args):
"""Dumps lists of files based on your criteria"""
from .query import Database
db = Database()
r = db.objects(groups=args.group,
protocol=args.protocol,
model_ids=args.client,
emotions=args.emotion)
output = sys.stdout
if args.selftest:
from bob.db.base.utils import null
output = null()
for f in r:
output.write('%s\n' % (f.make_path(args.directory), ))
return 0
def dumplist(args):
"""Dumps lists of files based on your criteria"""
from . import Database
db = Database()
objects = db.objects(protocols=args.protocols,
groups=args.groups,
classes=args.classes)
output = sys.stdout
if args.selftest:
from bob.db.base.utils import null
output = null()
for obj in objects:
output.write('%s\n' % (obj.make_path(directory=args.directory,
extension=args.extension), ))
return 0
def dumplist(args):
"""Dumps lists of files based on your criteria"""
#from .__init__ import Database
from .query import Database
db = Database()
# objects = db.objects(group=args.group, cls=args.cls, quality=args.quality, types=args.attack_type)
objects = db.objects(quality=args.quality, instrument=args.attack_type, fold=args.fold, group=args.group, cls=args.cls)
output = sys.stdout
if args.selftest:
from bob.db.base.utils import null
output = null()
for obj in objects:
output.write('%s\n' % (obj.make_path(directory=args.directory, extension=args.extension),))
return 0
def dumplist(args):
"""Dumps lists of files based on your criteria"""
from .query import Database
db = Database()
r = db.objects(
groups=args.group,
subworld=args.subworld,
protocol=args.protocol,
purposes=args.purpose
)
output = sys.stdout
if args.selftest:
output = utils.null()
for file in r:
output.write('%s\n' % file.make_path(args.directory, args.extension))
return 0
def dumplist(args):
"""Dumps lists of files based on your criteria"""
from .query import Database
db = Database()
r = db.objects(
groups=args.group,
protocol=args.protocol,
model_ids=args.client,
emotions=args.emotion)
output = sys.stdout
if args.selftest:
from bob.db.base.utils import null
output = null()
for f in r:
output.write('%s\n' % (f.make_path(args.directory),))
return 0
def annotations(args):
"""Returns a list of file database identifiers given the path stems"""
from .query import Database
db = Database(annotation_type=args.annotation_type)
output = sys.stdout
if args.selftest:
from bob.db.base.utils import null
output = null()
f = db.files([args.id])
if len(f) != 1:
output.write('Cannot find file with id "%d" in database\n' % args.id)
return 1
a = db.annotations(f[0])
for f in a: output.write('%s : (%3.2f, %3.2f)\n' % (f, a[f][0], a[f][1]))
if not a: return 1
return 0
def dumppairs(args):
"""Dumps lists of pairs of files based on your criteria"""
from .query import Database
db = Database()
r = db.pairs(protocol=args.protocol,
groups=args.group,
classes=args.sclass)
output = sys.stdout
if args.selftest:
from bob.db.base.utils import null
output = null()
for p in r:
output.write('%s -> %s\n' %
(p.enroll_file.make_path(args.directory, args.extension),
p.probe_file.make_path(args.directory, args.extension)))
return 0
def dumppairs(args):
"""Dumps lists of pairs of files based on your criteria"""
from .query import Database
db = Database()
r = db.pairs(
protocol=args.protocol,
groups=args.group,
classes=args.sclass
)
output = sys.stdout
if args.selftest:
from bob.db.base.utils import null
output = null()
for p in r:
output.write('%s -> %s\n' % (p.enroll_directory.make_path(args.directory, args.extension), p.probe_directory.make_path(args.directory, args.extension)))
return 0
def dumplist(args):
"""Dumps lists of files based on your criteria"""
from .query import Database
db = Database()
r = db.objects(
protocol=args.protocol, purposes=args.purpose, model_ids=(args.client,), groups=args.group, classes=args.sclass
)
output = sys.stdout
if args.selftest:
from bob.db.base.utils import null
output = null()
for f in r:
output.write("%s\n" % (f.make_path(args.directory, args.extension),))
return 0
def annotations(args):
"""Returns a list of file database identifiers given the path stems"""
from .query import Database
db = Database(annotation_type=args.annotation_type)
output = sys.stdout
if args.selftest:
from bob.db.base.utils import null
output = null()
f = db.files([args.id])
if len(f) != 1:
output.write('Cannot find file with id "%d" in database\n' % args.id)
return 1
a = db.annotations(f[0])
for f in a:
output.write('%s : (%3.2f, %3.2f)\n' % (f, a[f][0], a[f][1]))
if not a: return 1
return 0
def dumplist(args):
"""Dumps lists of files based on your criteria"""
from .query import Database
db = Database()
r = db.objects(
groups=args.group,
protocol=args.protocol,
purposes=args.purpose,
model_ids=args.template_id
)
output = sys.stdout
if args.selftest:
from bob.db.base.utils import null
output = null()
for f in r:
output.write('%s\n' % (f.make_path(args.directory, args.extension, args.add_sighting_id),))
return 0
def checkfiles(args):
"""Checks existence files based on your criteria"""
from .query import Database
db = Database()
r = db.objects(
protocol=args.protocol,
support=args.support,
groups=args.group,
cls=args.cls,
devices=args.device,
sessions=args.sessions,
attackdevices=args.attackdevice,
clients=args.client,
)
# go through all files, check if they are available on the filesystem
good = []
bad = []
for f in r:
if os.path.exists(f.make_path(args.directory, args.extension)):
good.append(f)
else:
bad.append(f)
# report
output = sys.stdout
if args.selftest:
from bob.db.base.utils import null
output = null()
if bad:
for f in bad:
output.write('Cannot find file "%s"\n' % (f.make_path(args.directory, args.extension),))
output.write('%d files (out of %d) were not found at "%s"\n' % \
(len(bad), len(r), args.directory))
return 0
def dumplist(args):
"""Dumps lists of files based on your criteria"""
from .query import FileListBioDatabase
db = FileListBioDatabase(args.list_directory, 'bio_filelist', use_dense_probe_file_list=False)
r = db.objects(
purposes=args.purpose,
groups=args.group,
classes=args.sclass,
protocol=args.protocol
)
output = sys.stdout
if args.selftest:
from bob.db.base.utils import null
output = null()
for f in r:
output.write('%s\n' % f.make_path(directory=args.directory, extension=args.extension))
return 0
def dumplist(args):
"""Dumps lists of files based on your criteria"""
from .query import Database
db = Database(args.list_directory, use_dense_probe_file_list=False)
r = db.objects(purposes=args.purpose,
groups=args.group,
classes=args.sclass,
protocol=args.protocol)
output = sys.stdout
if args.selftest:
from bob.db.base.utils import null
output = null()
for f in r:
output.write(
'%s\n' %
f.make_path(directory=args.directory, extension=args.extension))
return 0
def dumplist(args):
"""Dumps lists of files based on your criteria"""
from .query import Database
db = Database()
r = db.objects(
protocol=args.protocol,
support=args.support,
groups=args.group,
cls=args.cls,
clients=args.client,
)
output = sys.stdout
if args.selftest:
from bob.db.base.utils import null
output = null()
for f in r:
output.write('%s\n' % (f.make_path(args.directory, args.extension),))
return 0
def dumplist(args):
"""Dumps lists of files based on your criteria"""
from .query import Database
db = Database()
r = db.objects(groups=args.group,
protocol=args.protocol,
purposes=args.purpose,
model_ids=args.client,
sessions=args.session,
expressions=args.expression,
illuminations=args.illumination,
occlusions=args.occlusion)
output = sys.stdout
if args.selftest:
from bob.db.base.utils import null
output = null()
for f in r:
output.write('%s\n' % (f.make_path(args.directory, args.extension), ))
return 0
def annotations(args):
"""Returns a list of file database identifiers given the path stems"""
from .query import Database
db = Database(args.directory)
output = sys.stdout
if args.selftest:
from bob.db.base.utils import null
output = null()
f = db.files([args.id])
if len(f) != 1:
output.write('Cannot find file with id "%d" in database\n' % args.id)
return 1
a = db.annotations(f[0])
k = sorted(a.keys(), key=lambda x : int(x.split('.')[1]))
for i in k:
output.write("\n%s "%i)
for f in a[i]: output.write('%s : (%3.2f, %3.2f) ' % (f, a[i][f][0], a[i][f][1]))
output.write("\n")
if not a: return 1
return 0
