def copy(src, dst, overwrite=True, verbose=True): import utool as ut if ut.isiterable(src) and not ut.isiterable(dst): ut.copy_files_to(src, dst, overwrite=overwrite, verbose=verbose) # list to non list pass else: return copy_single(src, dst, overwrite=overwrite, verbose=verbose)
def get_match_status(ibs, aid_pair): """ Data role for status column """ aid1, aid2 = aid_pair assert not ut.isiterable(aid1), 'aid1=%r, aid2=%r' % (aid1, aid2) assert not ut.isiterable(aid2), 'aid1=%r, aid2=%r' % (aid1, aid2) text = ibs.get_match_text(aid1, aid2) if text is None: raise AssertionError('impossible state id_review_api') return text
def get_pair_tags(edge): aid1, aid2 = edge assert not ut.isiterable(aid1), 'aid1=%r, aid2=%r' % (aid1, aid2) assert not ut.isiterable(aid2), 'aid1=%r, aid2=%r' % (aid1, aid2) am_rowids = ibs.get_annotmatch_rowid_from_undirected_superkey( [aid1], [aid2]) tag_text = ibs.get_annotmatch_tag_text(am_rowids)[0] if tag_text is None: tag_text = '' return str(tag_text)
def ensure_flatiterable(input_): if isinstance(input_, six.string_types): input_ = ut.fuzzy_int(input_) if isinstance(input_, int) or not ut.isiterable(input_): return [input_] elif isinstance(input_, (list, tuple)): #print(input_) if len(input_) > 0 and ut.isiterable(input_[0]): return ut.flatten(input_) return input_ else: raise TypeError('cannot ensure %r input_=%r is iterable', (type(input_), input_))
def get_status(ibs, aid_pair): """ Data role for status column FIXME: no other function in this project takes a tuple of scalars as an argument. Everything else is written in the context of lists, This function should follow the same paradigm, but CustomAPI will have to change. """ aid1, aid2 = aid_pair assert not utool.isiterable(aid1), 'aid1=%r, aid2=%r' % (aid1, aid2) assert not utool.isiterable(aid2), 'aid1=%r, aid2=%r' % (aid1, aid2) #text = ibsfuncs.vsstr(aid1, aid2) text = ibs.get_match_text(aid1, aid2) if text is None: raise AssertionError('impossible state inspect_gui') return text
def get_reviewed_status(ibs, aid_pair): """ Data role for status column """ aid1, aid2 = aid_pair assert not ut.isiterable(aid1), 'aid1=%r, aid2=%r' % (aid1, aid2) assert not ut.isiterable(aid2), 'aid1=%r, aid2=%r' % (aid1, aid2) # FIXME: use new api state = ibs.get_annot_pair_is_reviewed([aid1], [aid2])[0] state_to_text = { None: 'Unreviewed', 2: 'Auto-reviewed', 1: 'User-reviewed', } default = '??? unknown mode %r' % (state,) text = state_to_text.get(state, default) return text
def get_annot_texts(ibs, aid_list, **kwargs): """ Add each type of text_list to the strings list """ try: ibsfuncs.assert_valid_aids(ibs, aid_list) assert utool.isiterable(aid_list), 'input must be iterable' assert all([isinstance(aid, int) for aid in aid_list]), 'invalid input' except AssertionError as ex: utool.printex(ex, 'invalid input', 'viz', key_list=['aid_list']) raise texts_list = [] # list of lists of texts if kwargs.get('show_aidstr', True): aidstr_list = get_aidstrs(aid_list) texts_list.append(aidstr_list) if kwargs.get('show_gname', False): gname_list = ibs.get_annot_gnames(aid_list) texts_list.append(['gname=%s' % gname for gname in gname_list]) if kwargs.get('show_name', True): name_list = ibs.get_annot_names(aid_list) texts_list.append(['name=%s' % name for name in name_list]) if kwargs.get('show_exemplar', True): flag_list = ibs.get_annot_exemplar_flag(aid_list) texts_list.append(['EX' if flag else '' for flag in flag_list]) # zip them up to get a tuple for each chip and join the fields if len(texts_list) > 0: annotation_text_list = [', '.join(tup) for tup in izip(*texts_list)] else: # no texts were specified return empty string for each input annotation_text_list = [''] * len(aid_list) return annotation_text_list
def view(self, rowids): """ returns a view of a view that uses the same per-item cache Example: >>> # ENABLE_DOCTEST >>> from ibeis._ibeis_object import * # NOQA >>> import ibeis >>> ibs = ibeis.opendb(defaultdb='testdb1') >>> aids = ibs.get_valid_aids() >>> annots = ibs.annots(aids) >>> self = annots.view(annots._rowids) >>> v1 = self.view([1, 1, 2, 3, 1, 2]) >>> v2 = self.view([3, 4, 5]) >>> v3 = self.view([1, 4]) >>> v4 = self.view(3) >>> lazy4 = v4._make_lazy_dict() >>> assert v1.vecs[0] is v3.vecs[0] >>> assert v2._cache is self._cache >>> assert v2._cache is v1._cache """ if ut.isiterable(rowids): childview = self.__class__(rowids, obj1d=self._obj1d, cache=self._cache) else: childview = self.__class__([rowids], obj1d=self._obj1d, cache=self._cache) childview = ObjectScalar0D(childview) return childview
def shallowcopy(qreq_, qaids=None): """ Creates a copy of qreq with the same qparams object and a subset of the qx and dx objects. used to generate chunks of vsmany queries CommandLine: python -m wbia.algo.hots.query_request QueryRequest.shallowcopy Example: >>> # ENABLE_DOCTEST >>> from wbia.algo.hots.query_request import * # NOQA >>> import wbia >>> qreq_ = wbia.testdata_qreq_(default_qaids=[1, 2]) >>> qreq2_ = qreq_.shallowcopy(qaids=1) >>> assert qreq_.daids is qreq2_.daids, 'should be the same' >>> assert len(qreq_.qaids) != len(qreq2_.qaids), 'should be diff' >>> #assert qreq_.metadata is not qreq2_.metadata """ # qreq2_ = copy.copy(qreq_) # copy calls setstate and getstate qreq2_ = QueryRequest() qreq2_.__dict__.update(qreq_.__dict__) qaids = [qaids] if not ut.isiterable(qaids) else qaids _intersect = np.intersect1d(qaids, qreq2_.qaids) assert len(_intersect) == len(qaids), 'not a subset' qreq2_.set_external_qaids(qaids) # The shallow copy does not bring over output / query data qreq2_.indexer = None # qreq2_.metadata = {} qreq2_.hasloaded = False return qreq2_
def __getitem__(self, idx): if isinstance(idx, slice): idxs = list(range(*idx.indices(len(self)))) return self.take(idxs) if not ut.isiterable(idx): obj0d_ = self.take([idx]) obj0d = ObjectScalar0D(obj0d_) return obj0d if not isinstance(idx, slice): raise AssertionError('only slice supported currently') return self.take(idx)
def overwrite_annot_case_tags(ibs, aid_list, tag_list): """ Completely replaces annotation tags. BE VERY CAREFUL WITH THIS FUNCTION """ assert all([ut.isiterable(tag) for tag in tag_list]) # text_list = ibs.get_annot_tag_text(aid_list) # orig_tags_list = [[] if note is None else _parse_tags(note) for note in text_list] new_tags_list = tag_list new_text_list = [';'.join(tags) for tags in new_tags_list] ibs.set_annot_tag_text(aid_list, new_text_list)
def set_part_quality_texts(ibs, part_rowid_list, quality_text_list): r""" Auto-docstr for 'set_part_quality_texts' RESTful: Method: PUT URL: /api/part/quality/text/ """ if not ut.isiterable(part_rowid_list): part_rowid_list = [part_rowid_list] if isinstance(quality_text_list, six.string_types): quality_text_list = [quality_text_list] quality_list = ut.dict_take(const.QUALITY_TEXT_TO_INT, quality_text_list) ibs.set_part_qualities(part_rowid_list, quality_list)
def cast_into_qt(data): """ Casts python data into a representation suitable for QT (usually a string) """ if SIMPLE_CASTING: if ut.is_str(data): return __STR__(data) elif ut.is_float(data): # qnumber = QString.number(float(data), format='g', precision=8) return locale_float(data) elif ut.is_bool(data): return bool(data) elif ut.is_int(data): return int(data) elif isinstance(data, uuid.UUID): return __STR__(data) elif ut.isiterable(data): return ', '.join(map(__STR__, data)) else: return __STR__(data) if ut.is_str(data): return __STR__(data) elif ut.is_float(data): # qnumber = QString.number(float(data), format='g', precision=8) return locale_float(data) elif ut.is_bool(data): return bool(data) elif ut.is_int(data): return int(data) elif isinstance(data, uuid.UUID): return __STR__(data) elif ut.isiterable(data): return ', '.join(map(__STR__, data)) elif data is None: return 'None' else: return 'Unknown qtype: %r for data=%r' % (type(data), data)
def cast_into_qt(data): """ Casts python data into a representation suitable for QT (usually a string) """ if SIMPLE_CASTING: if ut.is_str(data): return __STR__(data) elif ut.is_float(data): #qnumber = QString.number(float(data), format='g', precision=8) return locale_float(data) elif ut.is_bool(data): return bool(data) elif ut.is_int(data): return int(data) elif isinstance(data, uuid.UUID): return __STR__(data) elif ut.isiterable(data): return ', '.join(map(__STR__, data)) else: return __STR__(data) if ut.is_str(data): return __STR__(data) elif ut.is_float(data): #qnumber = QString.number(float(data), format='g', precision=8) return locale_float(data) elif ut.is_bool(data): return bool(data) elif ut.is_int(data): return int(data) elif isinstance(data, uuid.UUID): return __STR__(data) elif ut.isiterable(data): return ', '.join(map(__STR__, data)) elif data is None: return 'None' else: return 'Unknown qtype: %r for data=%r' % (type(data), data)
def generate_class_images(dream, target_labels): """ import plottool as pt fnum = None kw = dict(init='gauss', niters=500, update_rate=.05, weight_decay=1e-4) target_labels = list(range(model.output_dims)) dream = draw_net.Dream(model, **kw) target_labels = 8 images = list(dream.generate_class_images(target_labels)) vid = vt.make_video(images, 'dynimg.pimj', fps=1, is_color=False, format='PIM1') vid = vt.make_video2(images, 'dynimg') import matplotlib.pyplot as plt ims = [] for img in imgs: im = plt.imshow(img[:, :, 0], interpolation='nearest', cmap='gray') ims.append([im]) import matplotlib.animation as animation fig = plt.figure() ani = animation.ArtistAnimation(fig, ims, interval=50, blit=True, repeat_delay=1000) ani.save('dynamic_images.mp4') ut.startfile('dynamic_images.mp4') plt.show() """ import ibeis_cnn.__THEANO__ as theano from ibeis_cnn.__THEANO__ import tensor as T # NOQA import utool as ut input_shape = dream.model.input_shape b, c, w, h = input_shape was_scalar = not ut.isiterable(target_labels) target_labels = ut.ensure_iterable(target_labels) assert len(target_labels) <= b, 'batch size too small' initial_state = dream._make_init_state() shared_images = theano.shared(initial_state.astype(np.float32)) step_fn = dream._make_objective(shared_images, target_labels) out = dream._postprocess_class_image(shared_images, target_labels, was_scalar) yield out for _ in ut.ProgIter(range(dream.niters), lbl='class dream', bs=True): step_fn() # objective = step_fn() # print('objective = %r' % (objective,)) out = dream._postprocess_class_image(shared_images, target_labels, was_scalar) yield out
def param_distribution(param_pdf, rng=rng): if param_pdf is None: param = 0 elif not ut.isiterable(param_pdf): max_param = param_pdf if scalar_anchor == 'reflect': min_param = -max_param elif scalar_anchor == 0: min_param = 0 param = rng.uniform(min_param, max_param) elif isinstance(param_pdf, tuple): min_param, max_param = param_pdf param = rng.uniform(min_param, max_param) else: assert False return param
def get(self, column, row): """ getters always receive primary rowids, rectify if col_ider is specified (row might be a row_pair) """ index = self._infer_index(column, row) column_getter = self.col_getter_list[column] # Columns might be getter funcs indexable read/write arrays try: return utool.general_get(column_getter, index) except Exception: # FIXME: There may be an issue on tuple-key getters when row input is # vectorized. Hack it away if utool.isiterable(row): row_list = row return [self.get(column, row_) for row_ in row_list] else: raise
def get_textformat_tag_flags(prop, text_list): """ general text tag getter hack """ tags_list = [ None if note is None else _parse_tags(note) for note in text_list ] if ut.isiterable(prop): props_ = [p.lower() for p in prop] flags_list = [[ None if tags is None else int(prop_ in tags) for tags in tags_list ] for prop_ in props_] return flags_list else: prop = prop.lower() flag_list = [ None if tags is None else int(prop in tags) for tags in tags_list ] return flag_list
def get(self, column, row, **kwargs): """ getters always receive primary rowids, rectify if col_ider is specified (row might be a row_pair) """ index = self._infer_index(column, row) column_getter = self.col_getter_list[column] # Columns might be getter funcs indexable read/write arrays try: return self._general_get(column_getter, index, **kwargs) except Exception: # FIXME: There may be an issue on tuple-key getters when row input is # vectorized. Hack it away if ut.isiterable(row): row_list = row return [self.get(column, row_, **kwargs) for row_ in row_list] else: raise
def shallowcopy(qreq_, qaids=None, qx=None, dx=None): """ Creates a copy of qreq with the same qparams object and a subset of the qx and dx objects. used to generate chunks of vsone and vsmany queries CommandLine: python -m ibeis.algo.hots.query_request --exec-shallowcopy Example: >>> # ENABLE_DOCTEST >>> from ibeis.algo.hots.query_request import * # NOQA >>> import ibeis >>> qreq_, ibs = testdata_qreq() >>> qreq2_ = qreq_.shallowcopy(qx=0) >>> assert qreq_.get_external_daids() is qreq2_.get_external_daids() >>> assert len(qreq_.get_external_qaids()) != len(qreq2_.get_external_qaids()) >>> #assert qreq_.metadata is not qreq2_.metadata """ #qreq2_ = copy.copy(qreq_) # copy calls setstate and getstate qreq2_ = QueryRequest() qreq2_.__dict__.update(qreq_.__dict__) if qx is not None: qaid_list = qreq2_.get_external_qaids() qaid_list = qaid_list[qx:qx + 1] qreq2_.set_external_qaids(qaid_list) # , quuid_list) elif qaids is not None: assert qx is None, 'cannot specify both qx and qaids' qaids = [qaids] if not ut.isiterable(qaids) else qaids _intersect = np.intersect1d(qaids, qreq2_.get_external_qaids()) assert len(_intersect) == len(qaids), 'not a subset' qreq2_.set_external_qaids(qaids) # , quuid_list) if dx is not None: daid_list = qreq2_.get_external_daids() daid_list = daid_list[dx:dx + 1] #duuid_list = qreq2_.get_external_duuids() #duuid_list = duuid_list[dx:dx + 1] qreq2_.set_external_daids(daid_list) # The shallow copy does not bring over output / query data qreq2_.indexer = None #qreq2_.metadata = {} qreq2_.hasloaded = False return qreq2_
def load_cached_chipmatch(qreq_, qaid=None): """ DEPRICATE in favor of chipmatch convinience function for loading a query that has already been cached """ if qaid is None: qaid = qreq_.get_external_qaids() shallow_qreq_ = qreq_.shallowcopy() is_scalar = not ut.isiterable(qaid) qaid_list = [qaid] if is_scalar else qaid shallow_qreq_.set_external_qaids(qaid_list) cm_list = shallow_qreq_.ibs.query_chips( qaid_list, qreq_.get_external_daids(), use_cache=True, use_bigcache=False, qreq_=shallow_qreq_) if is_scalar: return cm_list[0] else: return cm_list
def make_class_images(dream, target_labels): import ibeis_cnn.__THEANO__ as theano from ibeis_cnn.__THEANO__ import tensor as T # NOQA import utool as ut was_scalar = not ut.isiterable(target_labels) target_labels = ut.ensure_iterable(target_labels) if True: # We are forcing a batch size for this visualization input_shape = (len(target_labels),) + dream.model.input_shape[1:] else: # Maybe some cnn layers cant take variable batches? input_shape = dream.model.input_shape b, c, w, h = input_shape assert len(target_labels) <= b, 'batch size too small' initial_state = dream._make_init_state() # make image a shared variable that you can update if dream.shared_images is None: dream.shared_images = theano.shared(initial_state) else: dream.shared_images.set_value(initial_state) if dream.step_fn is None: dream.step_fn = dream._make_objective(dream.shared_images, target_labels) # Optimize objective via backpropogation for a few iterations for _ in ut.ProgIter(range(dream.niters), lbl='making class model img', bs=True): dream.step_fn() #print('objective = %r' % (objective,)) out = dream._postprocess_class_image(dream.shared_images, target_labels, was_scalar) return out
def get_aidstrs(aid_list, **kwargs): if ut.isiterable(aid_list): return [ibsfuncs.aidstr(aid, **kwargs) for aid in aid_list] else: return ibsfuncs.aidstr(aid_list, **kwargs)
def wrapper(input_): if not ut.isiterable(input_): return func(si_func(input_)) else: return list(map(func, si_func(input_)))
def interpolate_replbounds(xdata, ydata, pt): """ xdata = np.array([.1, .2, .3, .4, .5]) ydata = np.array([.1, .2, .3, .4, .5]) pt = .35 FIXME: if duplicate xdata is given bad things happen. BUG: in scipy.interpolate.interp1d If there is a duplicate xdata, then assume_sorted=False will sort ydata by xdata, but xdata should retain its initial ordering in places of ambuguity. Currently it does not. Args: xdata (ndarray): ydata (ndarray): pt (ndarray): Returns: float: interp_vals CommandLine: python -m vtool.confusion --exec-interpolate_replbounds Example: >>> # DISABLE_DOCTEST >>> from vtool.confusion import * # NOQA >>> xdata = np.array([0.7, 0.8, 0.8, 0.9, 0.9, 0.9]) >>> ydata = np.array([34, 26, 23, 22, 19, 17]) >>> pt = np.array([.85, 1.0, -1.0]) >>> interp_vals = interpolate_replbounds(xdata, ydata, pt) >>> result = ('interp_vals = %s' % (str(interp_vals),)) >>> print(result) interp_vals = [ 22.5 17. 34. ] """ if not ut.issorted(xdata): raise AssertionError('need to sort xdata and ydata in function') sortx = np.lexsort(np.vstack([np.arange(len(xdata)), xdata])) xdata = xdata.take(sortx, axis=0) ydata = ydata.take(sortx, axis=0) is_scalar = not ut.isiterable(pt) #print('----') #print('xdata = %r' % (xdata,)) #print('ydata = %r' % (ydata,)) if is_scalar: pt = np.array([pt]) #ut.ensure_iterable(pt) minval = xdata.min() maxval = xdata.max() argx_min_list = np.argwhere(xdata == minval) argx_max_list = np.argwhere(xdata == maxval) argx_min = argx_min_list.min() argx_max = argx_max_list.max() lower_mask = pt < xdata[argx_min] upper_mask = pt > xdata[argx_max] interp_mask = ~np.logical_or(lower_mask, upper_mask) #if isinstance(pt, np.ndarray): dtype = np.result_type(np.float32, ydata.dtype) interp_vals = np.empty(pt.shape, dtype=dtype) interp_vals[lower_mask] = ydata[argx_min] interp_vals[upper_mask] = ydata[argx_max] if np.any(interp_mask): # FIXME: allow assume_sorted = False func = scipy.interpolate.interp1d(xdata, ydata, kind='linear', assume_sorted=True) interp_vals[interp_mask] = func(pt[interp_mask]) if is_scalar: interp_vals = interp_vals[0] # interpolate to target recall #right_index = indicies[0] #right_recall = self.recall[right_index] #left_index = right_index - 1 #left_recall = self.recall[left_index] #stepsize = right_recall - left_recall #alpha = (target_recall - left_recall) / stepsize #left_fpr = self.fpr[left_index] #right_fpr = self.fpr[right_index] #interp_fpp = (left_fpr * (1 - alpha)) + (right_fpr * (alpha)) return interp_vals
def new_cpd(self, parents=None, pmf_func=None): """ Makes a new random variable that is an instance of this tempalte parents : only used to define the name of this node. """ if pmf_func is None: pmf_func = self.pmf_func # --- MAKE VARIABLE ID def _getid(obj): if isinstance(obj, int): return str(obj) elif isinstance(obj, six.string_types): return obj else: return obj._template_id if not ut.isiterable(parents): parents = [parents] template_ids = [_getid(cpd) for cpd in parents] HACK_SAME_IDS = True # TODO: keep track of parent index inheritence # then rectify uniqueness based on that if HACK_SAME_IDS and ut.allsame(template_ids): _id = template_ids[0] else: _id = ''.join(template_ids) variable = ''.join([self.varpref, _id]) # variable = '_'.join([self.varpref, '{' + _id + '}']) # variable = '$%s$' % (variable,) evidence_cpds = [cpd for cpd in parents if hasattr(cpd, 'ttype')] if len(evidence_cpds) == 0: evidence_cpds = None variable_card = len(self.basis) statename_dict = { variable: self.basis, } if self.evidence_ttypes is not None: if any(cpd.ttype != tcpd.ttype for cpd, tcpd in zip(evidence_cpds, evidence_cpds)): raise ValueError('Evidence is not of appropriate type') evidence_bases = [cpd.variable_statenames for cpd in evidence_cpds] evidence_card = list(map(len, evidence_bases)) evidence_states = list(ut.iprod(*evidence_bases)) for cpd in evidence_cpds: _dict = ut.dict_subset(cpd.statename_dict, [cpd.variable]) statename_dict.update(_dict) evidence = [cpd.variable for cpd in evidence_cpds] else: if evidence_cpds is not None: raise ValueError('Gave evidence for evidence-less template') evidence = None evidence_card = None # --- MAKE TABLE VALUES if pmf_func is not None: if isinstance(pmf_func, list): values = np.array(pmf_func) else: values = np.array([[ pmf_func(vstate, *estates) for estates in evidence_states ] for vstate in self.basis]) ensure_normalized = True if ensure_normalized: values = values / values.sum(axis=0) else: # assume uniform fill_value = 1.0 / variable_card if evidence_card is None: values = np.full((1, variable_card), fill_value) else: values = np.full([variable_card] + list(evidence_card), fill_value) try: cpd = pgmpy.factors.TabularCPD( variable=variable, variable_card=variable_card, values=values, evidence=evidence, evidence_card=evidence_card, # statename_dict=statename_dict, state_names=statename_dict, ) except Exception as ex: ut.printex( ex, 'Failed to create TabularCPD', keys=[ 'variable', 'variable_card', 'statename_dict', 'evidence_card', 'evidence', 'values.shape', ], ) ut.embed() raise cpd.ttype = self.ttype cpd._template_ = self cpd._template_id = _id return cpd
def new_cpd(self, parents=None, pmf_func=None): """ Makes a new random variable that is an instance of this tempalte parents : only used to define the name of this node. """ if pmf_func is None: pmf_func = self.pmf_func # --- MAKE VARIABLE ID def _getid(obj): if isinstance(obj, int): return str(obj) elif isinstance(obj, six.string_types): return obj else: return obj._template_id if not ut.isiterable(parents): parents = [parents] template_ids = [_getid(cpd) for cpd in parents] HACK_SAME_IDS = True # TODO: keep track of parent index inheritence # then rectify uniqueness based on that if HACK_SAME_IDS and ut.list_allsame(template_ids): _id = template_ids[0] else: _id = ''.join(template_ids) variable = ''.join([self.varpref, _id]) #variable = '_'.join([self.varpref, '{' + _id + '}']) #variable = '$%s$' % (variable,) evidence_cpds = [cpd for cpd in parents if hasattr(cpd, 'ttype')] if len(evidence_cpds) == 0: evidence_cpds = None variable_card = len(self.basis) statename_dict = { variable: self.basis, } if self.evidence_ttypes is not None: if any(cpd.ttype != tcpd.ttype for cpd, tcpd in zip(evidence_cpds, evidence_cpds)): raise ValueError('Evidence is not of appropriate type') evidence_bases = [cpd.variable_statenames for cpd in evidence_cpds] evidence_card = list(map(len, evidence_bases)) evidence_states = list(ut.iprod(*evidence_bases)) for cpd in evidence_cpds: _dict = ut.dict_subset(cpd.statename_dict, [cpd.variable]) statename_dict.update(_dict) evidence = [cpd.variable for cpd in evidence_cpds] else: if evidence_cpds is not None: raise ValueError('Gave evidence for evidence-less template') evidence = None evidence_card = None # --- MAKE TABLE VALUES if pmf_func is not None: if isinstance(pmf_func, list): values = np.array(pmf_func) else: values = np.array([ [pmf_func(vstate, *estates) for estates in evidence_states] for vstate in self.basis ]) ensure_normalized = True if ensure_normalized: values = values / values.sum(axis=0) else: # assume uniform fill_value = 1.0 / variable_card if evidence_card is None: values = np.full((1, variable_card), fill_value) else: values = np.full([variable_card] + list(evidence_card), fill_value) try: cpd = pgmpy.factors.TabularCPD( variable=variable, variable_card=variable_card, values=values, evidence=evidence, evidence_card=evidence_card, statename_dict=statename_dict, ) except Exception as ex: ut.printex(ex, 'Failed to create TabularCPD', keys=[ 'variable', 'variable_card', 'statename_dict', 'evidence_card', 'evidence', 'values.shape', ]) raise cpd.ttype = self.ttype cpd._template_ = self cpd._template_id = _id return cpd
def _annotate_kpts(kpts_, sel_fx=None, **kwargs): r""" Args: kpts_ (ndarray): keypoints sel_fx (None): Keywords: color: 3/4-tuple, ndarray, or str Returns: None Example: >>> from plottool.viz_keypoints import * # NOQA >>> sel_fx = None >>> kpts = np.array([[ 92.9246, 17.5453, 7.8103, -3.4594, 10.8566, 0. ], ... [ 76.8585, 24.7918, 11.4412, -3.2634, 9.6287, 0. ], ... [ 140.6303, 24.9027, 10.4051, -10.9452, 10.5991, 0. ],]) """ if len(kpts_) == 0: print('len(kpts_) == 0...') return #color = kwargs.get('color', 'distinct' if sel_fx is None else df2.ORANGE) color = kwargs.get('color', 'scale' if sel_fx is None else df2.ORANGE) if color == 'distinct': # hack for distinct colors color = df2.distinct_colors(len(kpts_)) # , randomize=True) elif color == 'scale': # hack for distinct colors import vtool as vt #color = df2.scores_to_color(vt.get_scales(kpts_), cmap_='inferno', score_range=(0, 50)) color = df2.scores_to_color(vt.get_scales(kpts_), cmap_='viridis', score_range=(5, 30), cmap_range=None) #df2.distinct_colors(len(kpts_)) # , randomize=True) # Keypoint drawing kwargs drawkpts_kw = { 'ell': True, 'pts': False, 'ell_alpha': .4, 'ell_linewidth': 2, 'ell_color': color, } drawkpts_kw.update(kwargs) # draw all keypoints if sel_fx is None: df2.draw_kpts2(kpts_, **drawkpts_kw) else: # dont draw the selected keypoint in this batch nonsel_kpts_ = np.vstack((kpts_[0:sel_fx], kpts_[sel_fx + 1:])) # Draw selected keypoint sel_kpts = kpts_[sel_fx:sel_fx + 1] import utool as ut if ut.isiterable(color) and ut.isiterable(color[0]): # hack for distinct colors drawkpts_kw['ell_color'] = color[0:sel_fx] + color[sel_fx + 1:] drawkpts_kw drawkpts_kw2 = drawkpts_kw.copy() drawkpts_kw2.update({ 'ell_color': df2.BLUE, 'eig': True, 'rect': True, 'ori': True, }) df2.draw_kpts2(nonsel_kpts_, **drawkpts_kw) df2.draw_kpts2(sel_kpts, **drawkpts_kw2)
def interpolate_replbounds(xdata, ydata, pt): """ xdata = np.array([.1, .2, .3, .4, .5]) ydata = np.array([.1, .2, .3, .4, .5]) pt = .35 FIXME: if duplicate xdata is given bad things happen. BUG: in scipy.interpolate.interp1d If there is a duplicate xdata, then assume_sorted=False will sort ydata by xdata, but xdata should retain its initial ordering in places of ambuguity. Currently it does not. Args: xdata (ndarray): ydata (ndarray): pt (ndarray): Returns: float: interp_vals CommandLine: python -m vtool.confusion --exec-interpolate_replbounds Example: >>> # DISABLE_DOCTEST >>> from vtool.confusion import * # NOQA >>> xdata = np.array([0.7, 0.8, 0.8, 0.9, 0.9, 0.9]) >>> ydata = np.array([34, 26, 23, 22, 19, 17]) >>> pt = np.array([.85, 1.0, -1.0]) >>> interp_vals = interpolate_replbounds(xdata, ydata, pt) >>> result = ('interp_vals = %s' % (str(interp_vals),)) >>> print(result) interp_vals = [ 22.5 17. 34. ] """ if not ut.issorted(xdata): raise AssertionError("need to sort xdata and ydata in function") sortx = np.lexsort(np.vstack([np.arange(len(xdata)), xdata])) xdata = xdata.take(sortx, axis=0) ydata = ydata.take(sortx, axis=0) is_scalar = not ut.isiterable(pt) # print('----') # print('xdata = %r' % (xdata,)) # print('ydata = %r' % (ydata,)) if is_scalar: pt = np.array([pt]) # ut.ensure_iterable(pt) minval = xdata.min() maxval = xdata.max() argx_min_list = np.argwhere(xdata == minval) argx_max_list = np.argwhere(xdata == maxval) argx_min = argx_min_list.min() argx_max = argx_max_list.max() lower_mask = pt < xdata[argx_min] upper_mask = pt > xdata[argx_max] interp_mask = ~np.logical_or(lower_mask, upper_mask) # if isinstance(pt, np.ndarray): dtype = np.result_type(np.float32, ydata.dtype) interp_vals = np.empty(pt.shape, dtype=dtype) interp_vals[lower_mask] = ydata[argx_min] interp_vals[upper_mask] = ydata[argx_max] if np.any(interp_mask): # FIXME: allow assume_sorted = False func = scipy.interpolate.interp1d(xdata, ydata, kind="linear", assume_sorted=True) interp_vals[interp_mask] = func(pt[interp_mask]) if is_scalar: interp_vals = interp_vals[0] # interpolate to target recall # right_index = indicies[0] # right_recall = self.recall[right_index] # left_index = right_index - 1 # left_recall = self.recall[left_index] # stepsize = right_recall - left_recall # alpha = (target_recall - left_recall) / stepsize # left_fpr = self.fpr[left_index] # right_fpr = self.fpr[right_index] # interp_fpp = (left_fpr * (1 - alpha)) + (right_fpr * (alpha)) return interp_vals
def get_table_rows(cur, tablename, colnames, where=None, params=None, unpack=True): import utool as ut want_single_column = isinstance(colnames, six.string_types) want_single_param = params is not None and not ut.isiterable(params) #isinstance(params, six.string_types) if want_single_column: colnames = (colnames,) if colnames is not None and colnames != '*': assert isinstance(colnames, tuple), 'colnames must be a tuple' colnames_str = ', '.join(colnames) else: colnames_str = '*' #if isinstance(colnames, six.string_types): # colnames = (colnames,) fmtdict = { 'tablename' : tablename, 'colnames' : colnames_str, 'orderby' : '', } #ORDER BY rowid ASC if where is None: operation_fmt = ''' SELECT {colnames} FROM {tablename} {orderby} ''' else: fmtdict['where_clause'] = where operation_fmt = ''' SELECT {colnames} FROM {tablename} WHERE {where_clause} {orderby} ''' operation_str = operation_fmt.format(**fmtdict) if params is None: cur.execute(operation_str) val_list = cur.fetchall() elif want_single_param: cur.execute(operation_str, (params,)) val_list = cur.fetchall() else: # Execute many def executemany_scalar_generator(operation_str, params): for param in params: cur.execute(operation_str, param) vals = cur.fetchall() #assert len(vals) == 1, 'vals=%r, len(vals)=%r' % (vals, len(vals)) yield vals val_list = list(executemany_scalar_generator(operation_str, params)) if unpack: if want_single_column: # want a single value per parameter val_list = [val[0] for val in val_list] if want_single_param: # wants a single parameter assert len(val_list) == 1 val_list = val_list[0] return val_list
def get_annot_texts(ibs, aid_list, **kwargs): """ Add each type of text_list to the strings list Args: ibs (IBEISController): wbia controller object aid_list (int): list of annotation ids Returns: list: annotation_text_list CommandLine: python -m wbia.viz.viz_helpers --test-get_annot_texts Example: >>> # ENABLE_DOCTEST >>> from wbia.viz.viz_helpers import * # NOQA >>> import wbia >>> import collections >>> ibs = wbia.opendb('testdb1') >>> # Default all kwargs to true >>> class KwargsProxy(object): ... def get(self, a, b): ... return True >>> kwargs_proxy = KwargsProxy() >>> aid_list = ibs.get_valid_aids()[::3] >>> # execute function >>> annotation_text_list = get_annot_texts(ibs, aid_list, kwargs_proxy=kwargs_proxy) >>> # verify results >>> result = ut.repr2(annotation_text_list, nl=1) >>> print(result) [ 'aid1, gname=easy1.JPG, name=____, nid=-1, , nGt=0, quality=UNKNOWN, view=left', 'aid4, gname=hard1.JPG, name=____, nid=-4, , nGt=0, quality=UNKNOWN, view=left', 'aid7, gname=jeff.png, name=jeff, nid=3, EX, nGt=0, quality=UNKNOWN, view=unknown', 'aid10, gname=occl2.JPG, name=occl, nid=5, EX, nGt=0, quality=UNKNOWN, view=left', 'aid13, gname=zebra.jpg, name=zebra, nid=7, EX, nGt=0, quality=UNKNOWN, view=unknown', ] """ # HACK FOR TEST if 'kwargs_proxy' in kwargs: kwargs = kwargs['kwargs_proxy'] try: ibsfuncs.assert_valid_aids(ibs, aid_list) assert ut.isiterable(aid_list), 'input must be iterable' assert all([isinstance(aid, ut.VALID_INT_TYPES) for aid in aid_list]), 'invalid input' except AssertionError as ex: ut.printex(ex, 'invalid input', 'viz', key_list=['aid_list']) raise texts_list = [] # list of lists of texts if kwargs.get('show_aidstr', True): aidstr_list = get_aidstrs(aid_list) texts_list.append(aidstr_list) if kwargs.get('show_gname', False): gname_list = ibs.get_annot_image_names(aid_list) texts_list.append(['gname=%s' % gname for gname in gname_list]) if kwargs.get('show_name', True): name_list = ibs.get_annot_names(aid_list) texts_list.append(['name=%s' % name for name in name_list]) if kwargs.get('show_nid', False): nid_list = ibs.get_annot_name_rowids(aid_list) texts_list.append(['nid=%d' % nid for nid in nid_list]) if kwargs.get('show_exemplar', True): flag_list = ibs.get_annot_exemplar_flags(aid_list) texts_list.append(['EX' if flag else '' for flag in flag_list]) if kwargs.get('show_num_gt', True): # FIXME: This should be num_groundtruth with respect to the currently # allowed annotations nGt_list = ibs.get_annot_num_groundtruth(aid_list) texts_list.append(['nGt=%r' % nGt for nGt in nGt_list]) if kwargs.get('show_quality_text', False): qualtext_list = ibs.get_annot_quality_texts(aid_list) texts_list.append( list(map(lambda text: 'quality=%s' % text, qualtext_list))) if kwargs.get('show_viewcode', False): # FIXME: This should be num_groundtruth with respect to the currently # allowed annotations viewcode_list = ibs.get_annot_viewpoint_code(aid_list) texts_list.append( list(map(lambda text: 'view=%s' % text, viewcode_list))) # zip them up to get a tuple for each chip and join the fields if len(texts_list) > 0: annotation_text_list = [', '.join(tup) for tup in zip(*texts_list)] else: # no texts were specified return empty string for each input annotation_text_list = [''] * len(aid_list) return annotation_text_list
def get_all_descendant_rowids(depc, tablename, root_rowids, config=None, ensure=True, eager=True, nInput=None, recompute=False, recompute_all=False, levels_up=None, _debug=False): r""" Connects `root_rowids` to rowids in `tablename`, and computes all values needed along the way. This is the main workhorse function for dependency computations. Args: tablename (str): table to compute dependencies to root_rowids (list): rowids for ``tablename`` config (dict): config applicable for all tables (default = None) ensure (bool): eager evaluation if True(default = True) eager (bool): (default = True) nInput (None): (default = None) recompute (bool): (default = False) recompute_all (bool): (default = False) levels_up (int): only partially compute dependencies (default = 0) _debug (bool): (default = False) CommandLine: python -m dtool.depcache_control --exec-get_all_descendant_rowids:0 python -m dtool.depcache_control --exec-get_all_descendant_rowids:1 Example: >>> # DISABLE_DOCTEST >>> from dtool.depcache_control import * # NOQA >>> from dtool.example_depcache import testdata_depc >>> depc = testdata_depc() >>> tablename = 'spam' >>> root_rowids = [1, 2] >>> config1 = {'dim_size': 500} >>> config2 = {'dim_size': 100} >>> config3 = {'dim_size': 500, 'adapt_shape': False} >>> ensure, eager, nInput = True, True, None >>> _debug = True >>> rowid_dict1 = depc.get_all_descendant_rowids( >>> tablename, root_rowids, config1, ensure, eager, nInput, _debug=_debug) >>> rowid_dict2 = depc.get_all_descendant_rowids( >>> tablename, root_rowids, config2, ensure, eager, nInput, _debug=_debug) >>> rowid_dict3 = depc.get_all_descendant_rowids( >>> tablename, root_rowids, config3, ensure, eager, nInput, _debug=_debug) >>> result1 = 'rowid_dict1 = ' + ut.repr3(rowid_dict1, nl=1) >>> result2 = 'rowid_dict2 = ' + ut.repr3(rowid_dict2, nl=1) >>> result3 = 'rowid_dict3 = ' + ut.repr3(rowid_dict3, nl=1) >>> result = '\n'.join([result1, result2, result3]) >>> print(result) rowid_dict1 = { 'chip': [1, 2], 'dummy_annot': [1, 2], 'fgweight': [1, 2], 'keypoint': [1, 2], 'probchip': [1, 2], 'spam': [1, 2], } rowid_dict2 = { 'chip': [3, 4], 'dummy_annot': [1, 2], 'fgweight': [3, 4], 'keypoint': [3, 4], 'probchip': [1, 2], 'spam': [3, 4], } rowid_dict3 = { 'chip': [1, 2], 'dummy_annot': [1, 2], 'fgweight': [5, 6], 'keypoint': [5, 6], 'probchip': [1, 2], 'spam': [5, 6], } Example: >>> # ENABLE_DOCTEST >>> from dtool.depcache_control import * # NOQA >>> from dtool.example_depcache import testdata_depc >>> depc = testdata_depc() >>> _debug = True >>> tablename = 'vsmany' >>> config = depc.configclass_dict['vsmany']() >>> root_rowids = [1, 2, 3] >>> ensure, eager, nInput = False, True, None >>> # Get rowids of algo ( should be None ) >>> rowid_dict = depc.get_all_descendant_rowids( >>> tablename, root_rowids, config, ensure, eager, nInput, >>> _debug=_debug) >>> result = ut.repr3(rowid_dict, nl=1) >>> print(result) { 'dummy_annot': [1, 2, 3], 'vsmany': [None, None, None], } Example: >>> # ENABLE_DOCTEST >>> from dtool.depcache_control import * # NOQA >>> from dtool.example_depcache import testdata_depc >>> # Make sure algo config can correctly get properites >>> depc = testdata_depc() >>> tablename = 'chip' >>> recompute = False >>> recompute_all = False >>> _debug = True >>> root_rowids = [1, 2] >>> configclass = depc.configclass_dict['chip'] >>> config_ = configclass() >>> config1 = depc.configclass_dict['vsmany'](dim_size=500) >>> config2 = depc.configclass_dict['vsmany'](dim_size=100) >>> config = config2 >>> prop_dicts1 = depc.get_all_descendant_rowids( >>> tablename, root_rowids, config=config1, _debug=_debug) >>> prop_dicts2 = depc.get_all_descendant_rowids( >>> tablename, root_rowids, config=config2, _debug=_debug) >>> print(prop_dicts2) >>> print(prop_dicts1) >>> assert prop_dicts1 != prop_dicts2 Example: >>> # ENABLE_DOCTEST >>> from dtool.depcache_control import * # NOQA >>> from dtool.example_depcache import testdata_depc >>> depc = testdata_depc() >>> exec(ut.execstr_funckw(depc.get_all_descendant_rowids), globals()) >>> _debug = True >>> qaids, daids = [1, 2, 4], [2, 3, 4] >>> root_rowids = list(zip(*ut.product(qaids, daids))) >>> request = depc.new_request('vsone', qaids, daids) >>> results = request.execute() >>> tablename = 'vsone' >>> rowid_dict = depc.get_all_descendant_rowids( >>> tablename, root_rowids, config=None, _debug=_debug) """ # TODO: Need to have a nice way of ensuring configs dont overlap # via namespaces. _debug = depc._debug if _debug is None else _debug indenter = ut.Indenter('[Descend-to-%s]' % (tablename,), enabled=_debug) if _debug: indenter.start() print(' * GET DESCENDANT ROWIDS %s ' % (tablename,)) print(' * config = %r' % (config,)) dependency_levels = depc.get_dependencies(tablename) if levels_up is not None: dependency_levels = dependency_levels[:-levels_up] configclass_levels = [ [depc.configclass_dict.get(tablekey, None) for tablekey in keys] for keys in dependency_levels ] if _debug: print('[depc] dependency_levels = %s' % ut.repr3(dependency_levels, nl=1)) print('[depc] config_levels = %s' % ut.repr3(configclass_levels, nl=1)) # TODO: better support for multi-edges if (len(root_rowids) > 0 and ut.isiterable(root_rowids[0]) and not depc[tablename].ismulti): rowid_dict = {} for colx, col in enumerate(root_rowids): rowid_dict[depc.root + '%d' % (colx + 1,)] = col rowid_dict[depc.root] = ut.unique_ordered(ut.flatten(root_rowids)) else: rowid_dict = {depc.root: root_rowids} # Ensure that each level ``tablename``'s dependencies have been computed for level_keys in dependency_levels[1:]: if _debug: print(' * level_keys %s ' % (level_keys,)) # For each table in the level for tablekey in level_keys: try: child_rowids = depc._expand_level_rowids( tablename, tablekey, rowid_dict, ensure, eager, nInput, config, recompute, recompute_all, _debug) except Exception as ex: table = depc[tablekey] # NOQA keys = ['tablename', 'tablekey', 'rowid_dict', 'config', 'table', 'dependency_levels'] ut.printex(ex, 'error expanding rowids', keys=keys) raise rowid_dict[tablekey] = child_rowids if _debug: print(' GOT DESCENDANT ROWIDS') indenter.stop() return rowid_dict
def get_annot_texts(ibs, aid_list, **kwargs): """ Add each type of text_list to the strings list Args: ibs (IBEISController): ibeis controller object aid_list (int): list of annotation ids Returns: list: annotation_text_list CommandLine: python -m ibeis.viz.viz_helpers --test-get_annot_texts Example: >>> # ENABLE_DOCTEST >>> from ibeis.viz.viz_helpers import * # NOQA >>> import ibeis >>> import collections >>> ibs = ibeis.opendb('testdb1') >>> # Default all kwargs to true >>> class KwargsProxy(object): ... def get(self, a, b): ... return True >>> kwargs_proxy = KwargsProxy() >>> aid_list = ibs.get_valid_aids()[::3] >>> # execute function >>> annotation_text_list = get_annot_texts(ibs, aid_list, kwargs_proxy=kwargs_proxy) >>> # verify results >>> result = ut.list_str(annotation_text_list) >>> print(result) [ 'aid1, gname=easy1.JPG, name=____, nid=-1, , nGt=0, quality=UNKNOWN, yaw=None', 'aid4, gname=hard1.JPG, name=____, nid=-4, , nGt=0, quality=UNKNOWN, yaw=None', 'aid7, gname=jeff.png, name=jeff, nid=3, EX, nGt=0, quality=UNKNOWN, yaw=None', 'aid10, gname=occl2.JPG, name=occl, nid=5, EX, nGt=0, quality=UNKNOWN, yaw=None', 'aid13, gname=zebra.jpg, name=zebra, nid=7, EX, nGt=0, quality=UNKNOWN, yaw=None', ] """ # HACK FOR TEST if 'kwargs_proxy' in kwargs: kwargs = kwargs['kwargs_proxy'] try: ibsfuncs.assert_valid_aids(ibs, aid_list) assert ut.isiterable(aid_list), 'input must be iterable' assert all([isinstance(aid, ut.VALID_INT_TYPES) for aid in aid_list]), 'invalid input' except AssertionError as ex: ut.printex(ex, 'invalid input', 'viz', key_list=['aid_list']) raise texts_list = [] # list of lists of texts if kwargs.get('show_aidstr', True): aidstr_list = get_aidstrs(aid_list) texts_list.append(aidstr_list) if kwargs.get('show_gname', False): gname_list = ibs.get_annot_image_names(aid_list) texts_list.append(['gname=%s' % gname for gname in gname_list]) if kwargs.get('show_name', True): name_list = ibs.get_annot_names(aid_list) texts_list.append(['name=%s' % name for name in name_list]) if kwargs.get('show_nid', False): nid_list = ibs.get_annot_name_rowids(aid_list) texts_list.append(['nid=%d' % nid for nid in nid_list]) if kwargs.get('show_exemplar', True): flag_list = ibs.get_annot_exemplar_flags(aid_list) texts_list.append(['EX' if flag else '' for flag in flag_list]) if kwargs.get('show_num_gt', True): # FIXME: This should be num_groundtruth with respect to the currently # allowed annotations nGt_list = ibs.get_annot_num_groundtruth(aid_list) texts_list.append(['nGt=%r' % nGt for nGt in nGt_list]) if kwargs.get('show_quality_text', False): qualtext_list = ibs.get_annot_quality_texts(aid_list) texts_list.append(list(map(lambda text: 'quality=%s' % text, qualtext_list))) if kwargs.get('show_yawtext', False): # FIXME: This should be num_groundtruth with respect to the currently # allowed annotations yawtext_list = ibs.get_annot_yaw_texts(aid_list) texts_list.append(list(map(lambda text: 'yaw=%s' % text, yawtext_list))) # zip them up to get a tuple for each chip and join the fields if len(texts_list) > 0: annotation_text_list = [', '.join(tup) for tup in zip(*texts_list)] else: # no texts were specified return empty string for each input annotation_text_list = [''] * len(aid_list) return annotation_text_list
def parse_column_tuples( self, col_name_list, col_types_dict, col_getter_dict, col_bgrole_dict, col_ider_dict, col_setter_dict, editable_colnames, sortby, sort_reverse=True, strict=False, **kwargs, ): """ parses simple lists into information suitable for making guitool headers """ # Unpack the column tuples into names, getters, and types if not strict: # slopply colname definitions flag_list = [colname in col_getter_dict for colname in col_name_list] if not all(flag_list): invalid_colnames = ut.compress(col_name_list, ut.not_list(flag_list)) logger.info( '[api_item_widget] Warning: colnames=%r have no getters' % (invalid_colnames,) ) col_name_list = ut.compress(col_name_list, flag_list) # sloppy type inference for colname in col_name_list: getter_ = col_getter_dict[colname] if colname not in col_types_dict: type_ = ut.get_homogenous_list_type(getter_) if type_ is not None: col_types_dict[colname] = type_ # sloppy kwargs. # FIXME: explicitly list col_nice_dict col_nice_dict = kwargs.get('col_nice_dict', {}) self.col_nice_list = [col_nice_dict.get(name, name) for name in col_name_list] self.col_name_list = col_name_list self.col_type_list = [ col_types_dict.get(colname, str) for colname in col_name_list ] # First col is always a getter self.col_getter_list = [ col_getter_dict.get(colname, str) for colname in col_name_list ] # Get number of rows / columns self.nCols = len(self.col_getter_list) if self.nCols == 0: self.nRows = 0 else: for getter in self.col_getter_list: if ut.isiterable(getter): break getter = None # FIXME assert getter is not None, 'at least one getter must be an array/list' self.nRows = len(getter) # self.nRows = 0 if self.nCols == 0 else len(self.col_getter_list[0]) # FIXME # Init iders to default and then overwite based on dict inputs self.col_ider_list = [None] * self.nCols # ut.alloc_nones(self.nCols) # for colname, ider_colnames in six.iteritems(col_ider_dict): # import utool # utool.embed() colname2_colx = ut.make_index_lookup(self.col_name_list) for colname, ider_colnames in six.iteritems(col_ider_dict): if colname not in colname2_colx: continue # for colname in self.col_name_list: ider_colnames = col_ider_dict[colname] try: colx = colname2_colx[colname] # Col iders might have tuple input ider_cols = self._uinput_1to1(self.col_name_list.index, ider_colnames) col_ider = self._uinput_1to1(lambda c: ut.partial(self.get, c), ider_cols) self.col_ider_list[colx] = col_ider del col_ider del ider_cols del colx del colname except Exception as ex: ut.printex( ex, keys=['colname', 'ider_colnames', 'colx', 'col_ider', 'ider_cols'], ) raise # Init setters to data, and then overwrite based on dict inputs self.col_setter_list = list(self.col_getter_list) for colname, col_setter in six.iteritems(col_setter_dict): colx = colname2_colx[colname] self.col_setter_list[colx] = col_setter # Init bgrole_getters to None, and then overwrite based on dict inputs self.col_bgrole_getter_list = [ col_bgrole_dict.get(colname, None) for colname in self.col_name_list ] # Mark edtiable columns self.col_edit_list = [name in editable_colnames for name in col_name_list] # Mark the sort column index if sortby is None: self.col_sort_index = 0 elif ut.is_str(sortby): self.col_sort_index = self.col_name_list.index(sortby) else: self.col_sort_index = sortby self.col_sort_reverse = sort_reverse # Hacks for tree widget self._iders = kwargs.get('iders', None) col_level_dict = kwargs.get('col_level_dict', None) if col_level_dict is None: self.col_level_list = None else: self.col_level_list = ut.take(col_level_dict, col_name_list)
def get_nidstrs(nid_list, **kwargs): if ut.isiterable(nid_list): return ['nid%d' for nid in nid_list] else: return 'nid%d' % nid_list