def _init_mpl_mainprocess(verbose=VERBOSE_MPLINIT):
global __IS_INITIALIZED__
global __WHO_INITIALIZED__
import matplotlib as mpl
# mpl.interactive(True)
current_backend = mpl.get_backend()
target_backend = get_target_backend()
if __IS_INITIALIZED__ is True:
if verbose:
print(
'[!plottool] matplotlib has already been initialized. backend=%r'
% current_backend
)
print('[!plottool] Initially initialized by %r' % __WHO_INITIALIZED__)
print(
'[!plottool] Trying to be init by %r'
% (ut.get_caller_name(N=range(0, 5)))
)
return False
__IS_INITIALIZED__ = True
if verbose:
print('[plottool] matplotlib initialized by %r' % __WHO_INITIALIZED__)
__WHO_INITIALIZED__ = ut.get_caller_name(N=range(0, 5))
if verbose:
print('--- INIT MPL---')
print('[pt] current backend is: %r' % current_backend)
print('[pt] mpl.use(%r)' % target_backend)
if current_backend != target_backend:
_mpl_set_backend(target_backend)
_init_mpl_rcparams()
def _init_mpl_mainprocess(verbose=VERBOSE_MPLINIT):
global __IS_INITIALIZED__
global __WHO_INITIALIZED__
import matplotlib as mpl
#mpl.interactive(True)
current_backend = mpl.get_backend()
target_backend = get_target_backend()
if __IS_INITIALIZED__ is True:
if verbose:
print('[!plottool] matplotlib has already been initialized. backend=%r' % current_backend)
print('[!plottool] Initially initialized by %r' % __WHO_INITIALIZED__)
print('[!plottool] Trying to be init by %r' % (ut.get_caller_name(N=range(0, 5))))
return False
__IS_INITIALIZED__ = True
if verbose:
print('[plottool] matplotlib initialized by %r' % __WHO_INITIALIZED__)
__WHO_INITIALIZED__ = ut.get_caller_name(N=range(0, 5))
if verbose:
print('--- INIT MPL---')
print('[pt] current backend is: %r' % current_backend)
print('[pt] mpl.use(%r)' % target_backend)
if current_backend != target_backend:
_mpl_set_backend(target_backend)
_init_mpl_rcparams()
def utool_print(*args):
""" debugging utool print function """
import utool as ut
utool_flush()
endline = '\n'
__UTOOL_ROOT_LOGGER__.info('\n\n----------')
__UTOOL_ROOT_LOGGER__.info(ut.get_caller_name(range(0, 20)))
return __UTOOL_ROOT_LOGGER__.info(', '.join(map(six.text_type, args)) + endline)
def utool_print(*args):
""" debugging utool print function """
import utool as ut
utool_flush()
endline = '\n'
__UTOOL_ROOT_LOGGER__.info('\n\n----------')
__UTOOL_ROOT_LOGGER__.info(ut.get_caller_name(range(0, 20)))
return __UTOOL_ROOT_LOGGER__.info(
', '.join(map(six.text_type, args)) + endline)
def ishow_image(ibs, gid, sel_aids=[], fnum=None, select_callback=None,
**kwargs):
if ut.VERBOSE:
print(ut.get_caller_name(range(9)))
print('[interact_image] gid=%r fnum=%r' % (gid, fnum,))
if fnum is None:
fnum = df2.next_fnum()
# TODO: change to class based structure
self = ut.DynStruct()
self.fnum = fnum
fig = ih.begin_interaction('image', fnum)
#printDBG(utool.func_str(interact_image, [], locals()))
kwargs['draw_lbls'] = kwargs.get('draw_lbls', True)
def _image_view(sel_aids=sel_aids, **_kwargs):
try:
viz.show_image(ibs, gid, sel_aids=sel_aids, fnum=self.fnum, **_kwargs)
df2.set_figtitle('Image View')
except TypeError as ex:
ut.printex(ex, ut.dict_str(_kwargs))
raise
# Create callback wrapper
def _on_image_click(event):
printDBG('[inter] clicked image')
if ih.clicked_outside_axis(event):
# Toggle draw lbls
kwargs['draw_lbls'] = not kwargs.get('draw_lbls', True)
_image_view(**kwargs)
else:
ax = event.inaxes
viztype = vh.get_ibsdat(ax, 'viztype')
annotation_centers = vh.get_ibsdat(ax, 'annotation_centers', default=[])
printDBG(' annotation_centers=%r' % annotation_centers)
printDBG(' viztype=%r' % viztype)
if len(annotation_centers) == 0:
print(' ...no chips exist to click')
return
x, y = event.xdata, event.ydata
# Find ANNOTATION center nearest to the clicked point
aid_list = vh.get_ibsdat(ax, 'aid_list', default=[])
centx, _dist = ut.nearest_point(x, y, annotation_centers)
aid = aid_list[centx]
print(' ...clicked aid=%r' % aid)
if select_callback is not None:
# HACK, should just implement this correctly here
select_callback(gid, sel_aids=[aid], fnum=self.fnum)
else:
_image_view(sel_aids=[aid])
viz.draw()
_image_view(**kwargs)
viz.draw()
ih.connect_callback(fig, 'button_press_event', _on_image_click)
def wrp_setter(*args, **kwargs):
if DEBUG_SETTERS or VERB_CONTROL:
print("+------")
print("[SET]: " + get_funcname(func))
print("[SET]: called by: " + ut.get_caller_name(range(1, 7)))
funccall_str = ut.func_str(func, args, kwargs, packed=True)
print("\n" + funccall_str + "\n")
print("L------")
# builtins.print('\n' + funccall_str + '\n')
# print('set: funcname=%r, args=%r, kwargs=%r' % (get_funcname(func), args, kwargs))
return func_(*args, **kwargs)
def wrp_setter(*args, **kwargs):
if DEBUG_SETTERS or VERB_CONTROL:
print('+------')
print('[SET]: ' + get_funcname(func))
print('[SET]: called by: ' + ut.get_caller_name(range(1, 7)))
funccall_str = ut.func_str(func, args, kwargs, packed=True)
print('\n' + funccall_str + '\n')
print('L------')
#builtins.print('\n' + funccall_str + '\n')
#print('set: funcname=%r, args=%r, kwargs=%r' % (get_funcname(func), args, kwargs))
return func_(*args, **kwargs)
def _run_benchmark(setup_, func_list, argstr, number=1000):
import timeit
setup = GLOBAL_SETUP + '\n' + setup_
print('----------')
print('BENCHMARK: ' + utool.get_caller_name())
for func in func_list:
funcname = func if isinstance(func, str) else get_funcname(func)
print('Running: %s' % funcname)
stmt = funcname + argstr
try:
total_time = timeit.timeit(stmt=stmt, setup=setup, number=number)
except ImportError as ex:
utool.printex(ex, iswarning=True)
except Exception as ex:
utool.printex(ex, iswarning=False)
raise
print(' * timed: %r seconds in %s' % (total_time, funcname))
return locals()
def _run_benchmark(setup_, func_list, argstr, number=1000):
import timeit
setup = GLOBAL_SETUP + "\n" + setup_
print("----------")
print("BENCHMARK: " + utool.get_caller_name())
for func in func_list:
funcname = func if isinstance(func, str) else get_funcname(func)
print("Running: %s" % funcname)
stmt = funcname + argstr
try:
total_time = timeit.timeit(stmt=stmt, setup=setup, number=number)
except ImportError as ex:
utool.printex(ex, iswarning=True)
except Exception as ex:
utool.printex(ex, iswarning=False)
raise
print(" * timed: %r seconds in %s" % (total_time, funcname))
return locals()
def set(db, tblname, colnames, val_iter, id_iter, id_colname='rowid', **kwargs):
""" setter """
assert isinstance(colnames, tuple)
#if isinstance(colnames, (str, unicode)):
# colnames = (colnames,)
val_list = list(val_iter) # eager evaluation
id_list = list(id_iter) # eager evaluation
if not QUIET and VERBOSE:
print('[sql] SETTER: ' + utool.get_caller_name())
print('[sql] * tblname=%r' % (tblname,))
print('[sql] * val_list=%r' % (val_list,))
print('[sql] * id_list=%r' % (id_list,))
print('[sql] * id_colname=%r' % (id_colname,))
try:
num_val = len(val_list)
num_id = len(id_list)
assert num_val == num_id, 'list inputs have different lengths'
except AssertionError as ex:
utool.printex(ex, key_list=['num_val', 'num_id'])
raise
fmtdict = {
'tblname_str' : tblname,
'assign_str' : ',\n'.join(['%s=?' % name for name in colnames]),
'where_clause' : (id_colname + '=?'),
}
operation_fmt = '''
UPDATE {tblname_str}
SET {assign_str}
WHERE {where_clause}
'''
# TODO: The flattenize can be removed if we pass in val_lists instead
params_iter = utool.flattenize(list(zip(val_list, id_list)))
#params_iter = list(zip(val_list, id_list))
return db._executemany_operation_fmt(operation_fmt, fmtdict,
params_iter=params_iter, **kwargs)
def ishow_image(ibs,
gid,
sel_aids=[],
fnum=None,
select_callback=None,
**kwargs):
if ut.VERBOSE:
print(ut.get_caller_name(range(9)))
print('[interact_image] gid=%r fnum=%r' % (gid, fnum))
if fnum is None:
fnum = df2.next_fnum()
# TODO: change to class based structure
self = ut.DynStruct()
self.fnum = fnum
fig = ih.begin_interaction('image', fnum)
# printDBG(utool.func_str(interact_image, [], locals()))
kwargs['draw_lbls'] = kwargs.get('draw_lbls', True)
def _image_view(sel_aids=sel_aids, **_kwargs):
try:
viz.show_image(ibs,
gid,
sel_aids=sel_aids,
fnum=self.fnum,
**_kwargs)
df2.set_figtitle('Image View')
except TypeError as ex:
ut.printex(ex, ut.repr2(_kwargs))
raise
# Create callback wrapper
def _on_image_click(event):
print('[inter] clicked image')
if ih.clicked_outside_axis(event):
# Toggle draw lbls
kwargs['draw_lbls'] = not kwargs.get('draw_lbls', True)
_image_view(**kwargs)
else:
ax = event.inaxes
viztype = vh.get_ibsdat(ax, 'viztype')
annotation_centers = vh.get_ibsdat(ax,
'annotation_centers',
default=[])
print(' annotation_centers=%r' % annotation_centers)
print(' viztype=%r' % viztype)
if len(annotation_centers) == 0:
print(' ...no chips exist to click')
return
x, y = event.xdata, event.ydata
# Find ANNOTATION center nearest to the clicked point
aid_list = vh.get_ibsdat(ax, 'aid_list', default=[])
import vtool as vt
centx, _dist = vt.nearest_point(x, y, annotation_centers)
aid = aid_list[centx]
print(' ...clicked aid=%r' % aid)
if select_callback is not None:
# HACK, should just implement this correctly here
select_callback(gid, sel_aids=[aid], fnum=self.fnum)
else:
_image_view(sel_aids=[aid])
viz.draw()
_image_view(**kwargs)
viz.draw()
ih.connect_callback(fig, 'button_press_event', _on_image_click)
def ensure_correct_version(ibs, db, version_expected, schema_spec,
dobackup=True,
verbose=ut.NOT_QUIET):
"""
FIXME: AN SQL HELPER FUNCTION SHOULD BE AGNOSTIC TO CONTROLER OBJECTS
ensure_correct_version
Args:
ibs (IBEISController):
db (SQLController):
version_expected (str): version you want to be at
schema_spec (module): schema module
dobackup (bool):
Example:
>>> from ibeis.control._sql_helpers import * # NOQA
>>> ibs = '?'
>>> db = ibs.db
>>> version_expected = ibs.db_version_expected
>>> schema_spec = DB_SCHEMA
>>> dobackup = True
>>> result = ensure_correct_version(ibs, db, version_expected, schema_spec, dobackup)
>>> print(result)
Args:
schema_spec (module): module of schema specifications
"""
from ibeis import constants as const
from ibeis import params
#print('[SQL_] ensure_correct_version')
force_incremental = params.args.force_incremental_db_update
want_base_version = version_expected == const.BASE_DATABASE_VERSION
if want_base_version:
print('[SQL_] base version expected... returning')
# Nothing to do. autogenerated file is pointless
return
version = db.get_db_version()
# NEW DATABASE CONDITION
is_base_version = (version == const.BASE_DATABASE_VERSION)
# <DEBUG>
#if ut.get_flag('--verbsql') or ut.VERBOSE or True:
# key_list = locals().keys()
# keystr_list = sorted(ut.parse_locals_keylist(locals(), key_list))
# print('KEYLIST:' + ut.indentjoin(keystr_list, '\n * '))
# </DEBUG>
#+-----------------------------------
# SKIP TO CURRENT VERSION IF POSSIBLE
#+-----------------------------------
can_skip = is_base_version and not force_incremental
if can_skip:
#print('[SQL_] we can skip')
# Check to see if a prebuilt current schema_spec module exists
current_schema_exists = (schema_spec.UPDATE_CURRENT is not None and
schema_spec.VERSION_CURRENT is not None)
if current_schema_exists:
# check to see if more than the metadata table exists
is_newdb = db.get_table_names() == [const.METADATA_TABLE]
current_schema_compatible = (
is_newdb and schema_spec.VERSION_CURRENT <= version_expected)
if current_schema_compatible:
# Since this is a new database, we do not have to worry about backinng up the
# current database. The subsequent update functions (if needed) will handle
# this for us.
if verbose:
print('[_SQL] New database and a current schema found')
schema_spec.UPDATE_CURRENT(db, ibs=ibs)
db.set_db_version(schema_spec.VERSION_CURRENT)
if verbose:
print('[_SQL] Database version updated (skipped) to %r ' % (schema_spec.VERSION_CURRENT))
else:
print('[_SQL] Current database is not compatible, updating incrementally...')
else:
print('[_SQL] New database but current version not exported, updating incrementally...')
#+--------------------------------------
# INCREMENTAL UPDATE TO EXPECTED VERSION
#+--------------------------------------
# Check version again for sanity's sake, update if exported current is behind expected
version = db.get_db_version()
if verbose:
print('[_SQL.%s] Database version: %r | Expected version: %r ' %
(ut.get_caller_name(), version, version_expected))
if version < version_expected:
print('[_SQL] Database version behind, updating...')
update_schema_version(ibs, db, schema_spec, version, version_expected,
dobackup=dobackup)
db.set_db_version(version_expected)
print('[_SQL] Database version updated (incrementally) to %r' %
(version_expected))
elif version > version_expected:
msg = (('[_SQL] ERROR: '
'Expected database version behind. expected: %r. got: %r') %
(version_expected, version))
raise AssertionError(msg)
def lazy_checks(model):
if model.lazy_updater is not None:
print('[model] lazy update %r caller %r: ' %
(model.name, ut.get_caller_name(N=range(4))))
model.lazy_updater()
model.lazy_updater = None
def invindex_dbgstr(invindex):
"""
>>> from ibeis.algo.hots.smk.smk_debug import * # NOQA
>>> ibs, annots_df, daids, qaids, invindex = testdata_raw_internals0()
>>> invindex_dbgstr(invindex)
"""
print('+--- INVINDEX DBGSTR ---')
print('called by %r' % (ut.get_caller_name(),))
locals_ = {'invindex': invindex}
#print(dictinfo(invindex.wx2_fxs))
key_list = [
'invindex.words.shape',
'invindex.words.dtype',
'invindex.daids.dtype',
'invindex.idx2_dvec.shape',
'invindex.idx2_dvec.dtype',
'invindex.idx2_daid.shape',
'invindex.idx2_daid.dtype',
'invindex.idx2_dfx.shape',
(dictinfo, 'invindex.daid2_sccw'),
(dictinfo, 'invindex.wx2_drvecs'),
(dictinfo, 'invindex.wx2_dmaws'),
(dictinfo, 'invindex.wx2_dflags'),
(dictinfo, 'invindex.wx2_idf'),
(dictinfo, 'invindex.wx2_aids'),
(dictinfo, 'invindex.wx2_fxs'),
(dictinfo, 'invindex.wx2_idxs'),
]
keystr_list = ut.parse_locals_keylist(locals_, key_list)
append = keystr_list.append
def stats_(arr):
return wx_len_stats(arr)
append('lenstats(invindex.wx2_idxs) = ' + stats_(invindex.wx2_idxs))
#append('lenstats(invindex.wx2_idf) = ' + stats_(invindex.wx2_idf))
append('lenstats(invindex.wx2_drvecs) = ' + stats_(invindex.wx2_drvecs))
append('lenstats(invindex.wx2_aids) = ' + stats_(invindex.wx2_aids))
def mapval(func, dict_):
if isinstance(dict_, dict):
return map(func, six.itervalues(dict_))
else:
return map(func, dict_)
def isunique(aids):
return len(set(aids)) == len(aids)
if invindex.wx2_aids is not None:
wx_series = list(invindex.wx2_aids.keys())
aids_list = list(invindex.wx2_aids.values())
nAids_list = map(len, aids_list)
invindex.wx2_aids
append('sum(mapval(len, invindex.wx2_aids))) = ' + str(sum(nAids_list)))
probably_asmk = all(mapval(isunique, invindex.wx2_aids))
if probably_asmk:
append('All wx2_aids are unique. aggregate probably is True')
else:
append('Some wx2_aids are duplicates. aggregate probably is False')
maxkey = wx_series[np.array(nAids_list).argmax()]
print('wx2_aids[maxkey=%r] = \n' % (maxkey,) + str(invindex.wx2_aids[maxkey]))
dbgstr = '\n'.join(keystr_list)
print(dbgstr)
print('L--- END INVINDEX DBGSTR ---')
def invindex_dbgstr(invindex):
"""
>>> from ibeis.algo.hots.smk.smk_debug import * # NOQA
>>> ibs, annots_df, daids, qaids, invindex = testdata_raw_internals0()
>>> invindex_dbgstr(invindex)
"""
print('+--- INVINDEX DBGSTR ---')
print('called by %r' % (ut.get_caller_name(), ))
locals_ = {'invindex': invindex}
#print(dictinfo(invindex.wx2_fxs))
key_list = [
'invindex.words.shape',
'invindex.words.dtype',
'invindex.daids.dtype',
'invindex.idx2_dvec.shape',
'invindex.idx2_dvec.dtype',
'invindex.idx2_daid.shape',
'invindex.idx2_daid.dtype',
'invindex.idx2_dfx.shape',
(dictinfo, 'invindex.daid2_sccw'),
(dictinfo, 'invindex.wx2_drvecs'),
(dictinfo, 'invindex.wx2_dmaws'),
(dictinfo, 'invindex.wx2_dflags'),
(dictinfo, 'invindex.wx2_idf'),
(dictinfo, 'invindex.wx2_aids'),
(dictinfo, 'invindex.wx2_fxs'),
(dictinfo, 'invindex.wx2_idxs'),
]
keystr_list = ut.parse_locals_keylist(locals_, key_list)
append = keystr_list.append
def stats_(arr):
return wx_len_stats(arr)
append('lenstats(invindex.wx2_idxs) = ' + stats_(invindex.wx2_idxs))
#append('lenstats(invindex.wx2_idf) = ' + stats_(invindex.wx2_idf))
append('lenstats(invindex.wx2_drvecs) = ' + stats_(invindex.wx2_drvecs))
append('lenstats(invindex.wx2_aids) = ' + stats_(invindex.wx2_aids))
def mapval(func, dict_):
if isinstance(dict_, dict):
return map(func, six.itervalues(dict_))
else:
return map(func, dict_)
def isunique(aids):
return len(set(aids)) == len(aids)
if invindex.wx2_aids is not None:
wx_series = list(invindex.wx2_aids.keys())
aids_list = list(invindex.wx2_aids.values())
nAids_list = map(len, aids_list)
invindex.wx2_aids
append('sum(mapval(len, invindex.wx2_aids))) = ' +
str(sum(nAids_list)))
probably_asmk = all(mapval(isunique, invindex.wx2_aids))
if probably_asmk:
append('All wx2_aids are unique. aggregate probably is True')
else:
append('Some wx2_aids are duplicates. aggregate probably is False')
maxkey = wx_series[np.array(nAids_list).argmax()]
print('wx2_aids[maxkey=%r] = \n' % (maxkey, ) +
str(invindex.wx2_aids[maxkey]))
dbgstr = '\n'.join(keystr_list)
print(dbgstr)
print('L--- END INVINDEX DBGSTR ---')
