class OWPIPAx(widget.OWWidget):
name = "PIPAx"
description = "Access data from PIPA RNA-Seq database."
icon = "../widgets/icons/PIPA.svg"
priority = 35
inputs = []
outputs = [("Data", Orange.data.Table)]
username = settings.Setting("")
password = settings.Setting("")
log2 = settings.Setting(False)
rtypei = settings.Setting(5) # hardcoded rpkm mapability polya
excludeconstant = settings.Setting(False)
joinreplicates = settings.Setting(False)
#: The stored current selection (in experiments view)
#: SelectionByKey | None
currentSelection = settings.Setting(None)
#: Stored selections (presets)
#: list of SelectionByKey
storedSelections = settings.Setting([])
#: Stored column sort keys (from Sort view)
#: list of strings
storedSortingOrder = settings.Setting(
["Strain", "Experiment", "Genotype", "Timepoint"])
experimentsHeaderState = settings.Setting(
{name: False for _, name in HEADER[:ID_INDEX + 1]}
)
def __init__(self, parent=None, signalManager=None, name="PIPAx"):
super().__init__(parent)
self.selectedExperiments = []
self.buffer = dicty.CacheSQLite(bufferfile)
self.searchString = ""
self.result_types = []
self.mappings = {}
self.controlArea.setMaximumWidth(250)
self.controlArea.setMinimumWidth(250)
gui.button(self.controlArea, self, "Reload",
callback=self.Reload)
gui.button(self.controlArea, self, "Clear cache",
callback=self.clear_cache)
b = gui.widgetBox(self.controlArea, "Experiment Sets")
self.selectionSetsWidget = SelectionSetsWidget(self)
self.selectionSetsWidget.setSizePolicy(
QSizePolicy.Preferred, QSizePolicy.Maximum)
def store_selections(modified):
if not modified:
self.storedSelections = self.selectionSetsWidget.selections
self.selectionSetsWidget.selectionModified.connect(store_selections)
b.layout().addWidget(self.selectionSetsWidget)
gui.separator(self.controlArea)
b = gui.widgetBox(self.controlArea, "Sort output columns")
self.columnsSortingWidget = SortedListWidget(self)
self.columnsSortingWidget.setSizePolicy(
QSizePolicy.Preferred, QSizePolicy.Maximum)
def store_sort_order():
self.storedSortingOrder = self.columnsSortingWidget.sortingOrder
self.columnsSortingWidget.sortingOrderChanged.connect(store_sort_order)
b.layout().addWidget(self.columnsSortingWidget)
sorting_model = QStringListModel(SORTING_MODEL_LIST)
self.columnsSortingWidget.setModel(sorting_model)
gui.separator(self.controlArea)
box = gui.widgetBox(self.controlArea, 'Expression Type')
self.expressionTypesCB = gui.comboBox(
box, self, "rtypei", items=[], callback=self.UpdateResultsList)
gui.checkBox(self.controlArea, self, "excludeconstant",
"Exclude labels with constant values")
gui.checkBox(self.controlArea, self, "joinreplicates",
"Average replicates (use median)")
gui.checkBox(self.controlArea, self, "log2",
"Logarithmic (base 2) transformation")
self.commit_button = gui.button(self.controlArea, self, "&Commit",
callback=self.Commit)
self.commit_button.setDisabled(True)
gui.rubber(self.controlArea)
box = gui.widgetBox(self.controlArea, "Authentication")
gui.lineEdit(box, self, "username", "Username:"******"password", "Password:"******"searchString", "Search",
callbackOnType=True,
callback=self.SearchUpdate)
self.headerLabels = [t[1] for t in HEADER]
self.experimentsWidget = QTreeWidget()
self.experimentsWidget.setHeaderLabels(self.headerLabels)
self.experimentsWidget.setSelectionMode(QTreeWidget.ExtendedSelection)
self.experimentsWidget.setRootIsDecorated(False)
self.experimentsWidget.setSortingEnabled(True)
contextEventFilter = gui.VisibleHeaderSectionContextEventFilter(
self.experimentsWidget, self.experimentsWidget
)
self.experimentsWidget.header().installEventFilter(contextEventFilter)
self.experimentsWidget.setItemDelegateForColumn(
0, gui.IndicatorItemDelegate(self, role=Qt.DisplayRole))
self.experimentsWidget.setAlternatingRowColors(True)
self.experimentsWidget.selectionModel().selectionChanged.connect(
self.onSelectionChanged)
self.selectionSetsWidget.setSelectionModel(
self.experimentsWidget.selectionModel()
)
self.mainArea.layout().addWidget(self.experimentsWidget)
# Restore the selection states from the stored settings
self.selectionSetsWidget.selections = self.storedSelections
self.columnsSortingWidget.sortingOrder = self.storedSortingOrder
self.restoreHeaderState()
self.experimentsWidget.header().geometriesChanged.connect(
self.saveHeaderState)
self.dbc = None
self.AuthSet()
QTimer.singleShot(100, self.UpdateExperiments)
def sizeHint(self):
return QSize(800, 600)
def AuthSet(self):
if len(self.username):
self.passf.setDisabled(False)
else:
self.passf.setDisabled(True)
def AuthChanged(self):
self.AuthSet()
self.ConnectAndUpdate()
def ConnectAndUpdate(self):
self.Connect()
self.UpdateExperiments(reload=True)
def Connect(self):
self.error(1)
self.warning(1)
def en(x):
return x if len(x) else None
self.dbc = dicty.PIPAx(cache=self.buffer,
username=en(self.username),
password=self.password)
# check password
if en(self.username) != None:
try:
self.dbc.mappings(reload=True)
except dicty.AuthenticationError:
self.error(1, "Wrong username or password")
self.dbc = None
except Exception as ex:
print("Error when contacting the PIPA database", ex)
sys.excepthook(*sys.exc_info())
try: # maybe cached?
self.dbc.mappings()
self.warning(1, "Can not access database - using cached data.")
except Exception as ex:
self.dbc = None
self.error(1, "Can not access database.")
def Reload(self):
self.UpdateExperiments(reload=True)
def clear_cache(self):
self.buffer.clear()
self.Reload()
def rtype(self):
"""Return selected result template type """
if self.result_types:
return self.result_types[self.rtypei][0]
else:
return "-1"
def UpdateExperimentTypes(self):
self.expressionTypesCB.clear()
items = [desc for _, desc in self.result_types]
self.expressionTypesCB.addItems(items)
self.rtypei = max(0, min(self.rtypei, len(self.result_types) - 1))
def UpdateExperiments(self, reload=False):
self.experimentsWidget.clear()
self.items = []
self.progressBarInit()
if not self.dbc:
self.Connect()
mappings = {}
result_types = []
sucind = False # success indicator for database index
try:
mappings = self.dbc.mappings(reload=reload)
result_types = self.dbc.result_types(reload=reload)
sucind = True
except Exception as ex:
try:
mappings = self.dbc.mappings()
result_types = self.dbc.result_types()
self.warning(0, "Can not access database - using cached data.")
sucind = True
except Exception as ex:
self.error(0, "Can not access database.")
if sucind:
self.warning(0)
self.error(0)
self.mappings = mappings
self.result_types = result_types
self.UpdateExperimentTypes()
self.UpdateResultsList(reload=reload)
self.progressBarFinished()
if self.currentSelection:
self.currentSelection.select(
self.experimentsWidget.selectionModel())
self.handle_commit_button()
def UpdateResultsList(self, reload=False):
results_list = {}
try:
results_list = self.dbc.results_list(self.rtype(), reload=reload)
except Exception as ex:
try:
results_list = self.dbc.results_list(self.rtype())
except Exception as ex:
self.error(0, "Can not access database.")
self.results_list = results_list
mappings_key_dict = dict(((m["data_id"], m["id"]), key) \
for key, m in self.mappings.items())
def mapping_unique_id(annot):
"""Map annotations dict from results_list to unique
`mappings` ids.
"""
data_id, mappings_id = annot["data_id"], annot["mappings_id"]
return mappings_key_dict[data_id, mappings_id]
elements = []
# softly change the view so that the selection stays the same
items_shown = {}
for i, item in enumerate(self.items):
c = str(item.text(10))
items_shown[c] = i
items_to_show = dict((mapping_unique_id(annot), annot)
for annot in self.results_list.values())
add_items = set(items_to_show) - set(items_shown)
delete_items = set(items_shown) - set(items_to_show)
i = 0
while i < self.experimentsWidget.topLevelItemCount():
it = self.experimentsWidget.topLevelItem(i)
if str(it.text(10)) in delete_items:
self.experimentsWidget.takeTopLevelItem(i)
else:
i += 1
delete_ind = set([items_shown[i] for i in delete_items])
self.items = [it for i, it in enumerate(self.items) if i not in delete_ind]
for r_annot in [items_to_show[i] for i in add_items]:
d = defaultdict(lambda: "?", r_annot)
row_items = [""] + [d.get(key, "?") for key, _ in HEADER[1:]]
try:
time_dict = literal_eval(row_items[DATE_INDEX])
date_rna = date(time_dict["fullYearUTC"],
time_dict["monthUTC"] + 1, # Why is month 0 based?
time_dict["dateUTC"])
row_items[DATE_INDEX] = date_rna.strftime("%x")
except Exception:
row_items[DATE_INDEX] = ''
row_items[ID_INDEX] = mapping_unique_id(r_annot)
elements.append(row_items)
ci = MyTreeWidgetItem(self.experimentsWidget, row_items)
self.items.append(ci)
for i in range(len(self.headerLabels)):
self.experimentsWidget.resizeColumnToContents(i)
# which is the ok buffer version
# FIXME: what attribute to use for version?
self.wantbufver = \
lambda x, ad=self.results_list: \
defaultdict(lambda: "?", ad[x])["date"]
self.wantbufver = lambda x: "0"
self.UpdateCached()
def UpdateCached(self):
if self.wantbufver and self.dbc:
fn = self.dbc.download_key_function()
result_id_key = dict(((m["data_id"], m["mappings_id"]), key) \
for key, m in self.results_list.items())
for item in self.items:
c = str(item.text(10))
mapping = self.mappings[c]
data_id, mappings_id = mapping["data_id"], mapping["id"]
r_id = result_id_key[data_id, mappings_id]
# Get the buffered version
buffered = self.dbc.inBuffer(fn(r_id))
value = " " if buffered == self.wantbufver(r_id) else ""
item.setData(0, Qt.DisplayRole, value)
def SearchUpdate(self, string=""):
for item in self.items:
item.setHidden(not all(s in item \
for s in self.searchString.split())
)
def Commit(self):
if not self.dbc:
self.Connect()
pb = gui.ProgressBar(self, iterations=100)
table = None
ids = []
for item in self.experimentsWidget.selectedItems():
unique_id = str(item.text(10))
annots = self.mappings[unique_id]
ids.append((annots["data_id"], annots["id"]))
transfn = None
if self.log2:
transfn = lambda x: math.log(x + 1.0, 2)
reverse_header_dict = dict((name, key) for key, name in HEADER)
hview = self.experimentsWidget.header()
shownHeaders = [label for i, label in \
list(enumerate(self.headerLabels))[1:] \
if not hview.isSectionHidden(i)
]
allowed_labels = [reverse_header_dict.get(label, label) \
for label in shownHeaders]
if self.joinreplicates and "id" not in allowed_labels:
# need 'id' labels in join_replicates for attribute names
allowed_labels.append("id")
if len(ids):
table = self.dbc.get_data(ids=ids, result_type=self.rtype(),
callback=pb.advance,
exclude_constant_labels=self.excludeconstant,
# bufver=self.wantbufver,
transform=transfn,
allowed_labels=allowed_labels)
if self.joinreplicates:
table = dicty.join_replicates(table,
ignorenames=["replicate", "data_id", "mappings_id",
"data_name", "id", "unique_id"],
namefn=None,
avg=dicty.median
)
# Sort attributes
sortOrder = self.columnsSortingWidget.sortingOrder
all_values = defaultdict(set)
for at in table.domain.attributes:
atts = at.attributes
for name in sortOrder:
all_values[name].add(atts.get(reverse_header_dict[name], ""))
isnum = {}
for at, vals in all_values.items():
vals = filter(None, vals)
try:
for a in vals:
float(a)
isnum[at] = True
except:
isnum[at] = False
def optfloat(x, at):
if x == "":
return ""
else:
return float(x) if isnum[at] else x
def sorting_key(attr):
atts = attr.attributes
return tuple([optfloat(atts.get(reverse_header_dict[name], ""), name) \
for name in sortOrder])
attributes = sorted(table.domain.attributes,
key=sorting_key)
domain = Orange.data.Domain(
attributes, table.domain.class_var, table.domain.metas)
table = table.from_table(domain, table)
data_hints.set_hint(table, "taxid", "352472")
data_hints.set_hint(table, "genesinrows", False)
self.send("Data", table)
self.UpdateCached()
pb.finish()
def onSelectionChanged(self, selected, deselected):
self.handle_commit_button()
def handle_commit_button(self):
self.currentSelection = \
SelectionByKey(self.experimentsWidget.selectionModel().selection(),
key=(1, 2, 3, 10))
self.commit_button.setDisabled(not len(self.currentSelection))
def saveHeaderState(self):
hview = self.experimentsWidget.header()
for i, label in enumerate(self.headerLabels):
self.experimentsHeaderState[label] = hview.isSectionHidden(i)
def restoreHeaderState(self):
hview = self.experimentsWidget.header()
state = self.experimentsHeaderState
for i, label in enumerate(self.headerLabels):
hview.setSectionHidden(i, state.get(label, True))
self.experimentsWidget.resizeColumnToContents(i)
class OWGenExpress(widget.OWWidget):
name = "GenExpress"
description = "Expression data from GenExpress."
icon = "../widgets/icons/GenCloud.svg"
priority = 36
inputs = []
outputs = [("Data", Orange.data.Table)]
username = settings.Setting("anonymous")
password = settings.Setting("")
log2 = settings.Setting(False)
transpose = settings.Setting(False)
rtypei = settings.Setting(0)
projecti = settings.Setting(0)
serveri = settings.Setting(0)
exnamei = settings.Setting(6)
excludeconstant = settings.Setting(False)
joinreplicates = settings.Setting(False)
currentSelection = settings.Setting(None)
experimentsHeaderState = settings.Setting({
name: False for _, name in HEADER[:ID_INDEX + 1]}
)
storedSortOrder = settings.Setting([])
storedSelections = settings.Setting([])
def __init__(self, parent=None):
super().__init__(parent)
self.servers = [
('https://dictyexpress.research.bcm.edu/', 'dictyExpress'),
('https://cloud.genialis.com/', 'Genialis'),
]
self.selectedExperiments = []
self.buffer = dicty.CacheSQLite(bufferfile)
self.searchString = ""
self.items = []
self.result_types = []
self.controlArea.setMaximumWidth(250)
self.controlArea.setMinimumWidth(250)
box = gui.widgetBox(self.controlArea, 'Project')
self.projectCB = gui.comboBox(
box, self, "projecti", items=[], callback=self.ProjectChosen)
self.projects = []
b = gui.widgetBox(self.controlArea, "Selection bookmarks")
self.selectionSetsWidget = SelectionSetsWidget(self)
self.selectionSetsWidget.setSizePolicy(
QSizePolicy.Preferred, QSizePolicy.Maximum)
def store_selections(modified):
if not modified:
self.storedSelections = self.selectionSetsWidget.selections
self.selectionSetsWidget.selectionModified.connect(store_selections)
b.layout().addWidget(self.selectionSetsWidget)
gui.separator(self.controlArea)
b = gui.widgetBox(self.controlArea, "Sort output columns")
self.columnsSortingWidget = SortedListWidget(self)
self.columnsSortingWidget.setSizePolicy(
QSizePolicy.Preferred, QSizePolicy.Maximum)
box = gui.widgetBox(self.controlArea, 'Experiment name')
self.experimentNameCB = gui.comboBox(
box, self, "exnamei", items=SORTING_MODEL_LIST)
b.layout().addWidget(self.columnsSortingWidget)
sorting_model = QStringListModel(SORTING_MODEL_LIST)
self.columnsSortingWidget.setModel(sorting_model)
self.columnsSortingWidget.sortingOrder = self.storedSortOrder
def store_sort_order():
self.storedSortOrder = self.columnsSortingWidget.sortingOrder
self.columnsSortingWidget.sortingOrderChanged.connect(store_sort_order)
gui.separator(self.controlArea)
box = gui.widgetBox(self.controlArea, 'Expression Type')
self.expressionTypesCB = gui.comboBox(
box, self, "rtypei", items=[], callback=self.UpdateResultsList)
gui.checkBox(self.controlArea, self, "excludeconstant",
"Exclude labels with constant values")
gui.checkBox(self.controlArea, self, "joinreplicates",
"Average replicates (use median)")
gui.checkBox(self.controlArea, self, "log2",
"Logarithmic (base 2) transformation")
gui.checkBox(self.controlArea, self, "transpose",
"Genes as columns")
self.commit_button = gui.button(self.controlArea, self, "&Commit",
callback=self.Commit)
self.commit_button.setDisabled(True)
gui.rubber(self.controlArea)
box = gui.widgetBox(self.controlArea, 'Server')
gui.comboBox(box, self, "serveri",
items=[title for url, title in self.servers],
callback=self.ServerChosen)
gui.lineEdit(box, self, "username", "Username:"******"password", "Password:"******"Clear cache",
callback=self.clear_cache)
gui.lineEdit(self.mainArea, self, "searchString", "Search",
callbackOnType=True,
callback=self.SearchUpdate)
self.headerLabels = [t[1] for t in HEADER]
self.experimentsWidget = QTreeWidget()
self.experimentsWidget.setHeaderLabels(self.headerLabels)
self.experimentsWidget.setSelectionMode(QTreeWidget.ExtendedSelection)
self.experimentsWidget.setRootIsDecorated(False)
self.experimentsWidget.setSortingEnabled(True)
contextEventFilter = gui.VisibleHeaderSectionContextEventFilter(
self.experimentsWidget, self.experimentsWidget)
self.experimentsWidget.header().installEventFilter(contextEventFilter)
self.experimentsWidget.setItemDelegateForColumn(
0, gui.IndicatorItemDelegate(self, role=Qt.DisplayRole))
self.experimentsWidget.setAlternatingRowColors(True)
self.experimentsWidget.selectionModel().selectionChanged.connect(
self.onSelectionChanged)
self.selectionSetsWidget.setSelectionModel(
self.experimentsWidget.selectionModel())
self.selectionSetsWidget.setSelections(self.storedSelections)
self.mainArea.layout().addWidget(self.experimentsWidget)
self.restoreHeaderState()
self.experimentsWidget.header().geometriesChanged.connect(
self.saveHeaderState)
self.dbc = None
self.AuthSet()
QTimer.singleShot(100, self.ConnectAndUpdate)
def sizeHint(self):
return QSize(800, 600)
def AuthSet(self):
if len(self.username):
self.passf.setDisabled(False)
else:
self.passf.setDisabled(True)
def AuthChanged(self):
self.AuthSet()
self.ConnectAndUpdate()
def ConnectAndUpdate(self):
self.Connect()
if self.dbc:
def get_data_count(project_id):
# XXX: is there a better way?
# Note: limit 0 would return all objects
return self.dbc.gen.api.data.get(case_ids__contains=project_id,
type__startswith='data:expression:',
limit=1)['meta']['total_count']
self.projects = sorted([p for p in self.dbc.projects().items() if
get_data_count(p[0]) > 0], key=lambda x: x[1])
self.UpdateProjects()
self.ProjectChosen()
self.UpdateExperimentTypes()
def Connect(self):
self.error(1)
self.warning(1)
username = '******'
password = '******'
url = self.servers[self.serveri][0]
if self.username:
username = self.username
password = self.password
if username.lower() in ['*****@*****.**', 'anonymous']:
username = '******'
password = '******'
self.dbc = None
self.projects = []
self.result_types = []
try:
self.dbc = Genesis(
address=url, username=username, password=password,
cache=self.buffer)
except requests.exceptions.ConnectionError:
self.dbc = Genesis(
address=url, username=username, password=password,
connect=False, cache=self.buffer)
self.warning(1, "Could not connect to server, working from cache.")
except Exception:
self.error(1, "Wrong username or password.")
self.UpdateProjects()
self.UpdateExperimentTypes() # clear lists
def Reload(self):
self.UpdateExperiments(reload=True)
def clear_cache(self):
self.buffer.clear()
self.Reload()
def rtype(self):
"""Return selected result template type """
if self.result_types:
return self.result_types[self.rtypei]
else:
return None
def UpdateExperimentTypes(self):
self.expressionTypesCB.clear()
items = [self.result_types_labels[desc] for desc in self.result_types]
self.expressionTypesCB.addItems(items)
#do not update anything if the list is empty
if len(self.result_types):
self.rtypei = max(0, min(self.rtypei, len(self.result_types) - 1))
def UpdateProjects(self):
self.projectCB.clear()
items = [desc for pid, desc in self.projects]
self.projectCB.addItems(items)
#do not update anything if the list if empty
if len(self.projects) > 0:
self.projecti = max(0, min(self.projecti, len(self.projects) - 1))
def UpdateExperiments(self, reload=False):
self.experimentsWidget.clear()
if not self.dbc or not self.dbc.projectid: # the connection did not succeed
return
self.items = []
self.progressBarInit()
result_types = []
result_types_labels = []
sucind = False # success indicator for database index
try:
result_types, result_types_labels = self.dbc.result_types(reload=reload)
sucind = True
except Exception:
try:
result_types, result_types_labels = self.dbc.result_types()
self.warning(0, "Can not access database - using cached data.")
sucind = True
except Exception:
self.error(0, "Can not access database.")
if sucind:
self.warning(0)
self.error(0)
self.result_types = result_types
self.result_types_labels = result_types_labels
self.UpdateExperimentTypes()
self.UpdateResultsList(reload=reload)
self.progressBarFinished()
if self.currentSelection:
self.currentSelection.select(self.experimentsWidget.selectionModel())
self.handle_commit_button()
def ProjectChosen(self, reload=False):
if self.projects:
self.dbc.projectid = self.projects[self.projecti][0]
else:
self.dbc.projectid = None
self.UpdateExperiments(reload=reload)
def ServerChosen(self):
self.ConnectAndUpdate()
def UpdateResultsList(self, reload=False):
results_list = self.dbc.results_list(self.rtype(), reload=reload)
try:
results_list = self.dbc.results_list(self.rtype(), reload=reload)
except Exception:
try:
results_list = self.dbc.results_list(self.rtype())
except Exception:
self.error(0, "Can not access database.")
self.results_list = results_list
#softly change the view so that the selection stays the same
items_shown = {}
for i, item in enumerate(self.items):
c = str(item.text(ID_INDEX))
items_shown[c] = i
items_to_show = set(id_ for id_ in self.results_list)
add_items = set(items_to_show) - set(items_shown)
delete_items = set(items_shown) - set(items_to_show)
i = 0
while i < self.experimentsWidget.topLevelItemCount():
it = self.experimentsWidget.topLevelItem(i)
if str(it.text(ID_INDEX)) in delete_items:
self.experimentsWidget.takeTopLevelItem(i)
else:
i += 1
delete_ind = set([items_shown[i] for i in delete_items])
self.items = [it for i, it in enumerate(self.items)
if i not in delete_ind]
for r_annot in add_items:
d = defaultdict(lambda: "?", self.results_list[r_annot])
row_items = [""] + [to_text(d.get(key, "?"))
for key, _ in HEADER[1:]]
row_items[ID_INDEX] = r_annot
ci = MyTreeWidgetItem(self.experimentsWidget, row_items)
self.items.append(ci)
for i in range(len(self.headerLabels)):
self.experimentsWidget.resizeColumnToContents(i)
self.wantbufver = lambda x: self.results_list[x]["date_modified"]
self.UpdateCached()
def UpdateCached(self):
if self.wantbufver and self.dbc:
for item in self.items:
id = str(item.text(ID_INDEX))
version = self.dbc._in_buffer(id + "|||" + self.rtype())
value = " " if version == self.wantbufver(id) else ""
item.setData(0, Qt.DisplayRole, value)
def SearchUpdate(self, string=""):
for item in self.items:
item.setHidden(
not all(s in item for s in self.searchString.split()))
def Commit(self):
pb = gui.ProgressBar(self, iterations=100)
table = None
ids = []
for item in self.experimentsWidget.selectedItems():
unique_id = str(item.text(ID_INDEX))
ids.append(unique_id)
transfn = None
if self.log2:
transfn = lambda x: math.log(x + 1.0, 2)
reverse_header_dict = {name: name for key, name in HEADER}
reverse_header_dict["ID"] = "id"
allowed_labels = None
def namefn(a):
name = SORTING_MODEL_LIST[self.exnamei]
name = reverse_header_dict.get(name, "id")
return dict(a)[name]
if len(ids):
table = self.dbc.get_data(
ids=ids, result_type=self.rtype(),
callback=pb.advance,
exclude_constant_labels=self.excludeconstant,
bufver=self.wantbufver,
transform=transfn,
allowed_labels=allowed_labels,
namefn=namefn)
if self.joinreplicates:
table = dicty.join_replicates(table,
ignorenames=self.dbc.IGNORE_REPLICATE,
namefn="name",
avg=dicty.median,
fnshow=lambda x: " | ".join(map(str, x)))
# Sort attributes
sortOrder = self.columnsSortingWidget.sortingOrder
all_values = defaultdict(set)
for at in table.domain.attributes:
atts = at.attributes
for name in sortOrder:
all_values[name].add(atts.get(reverse_header_dict[name], ""))
isnum = {}
for at, vals in all_values.items():
vals = filter(None, vals)
try:
for a in vals:
float(a)
isnum[at] = True
except ValueError:
isnum[at] = False
def optfloat(x, at):
if x == "":
return ""
else:
return float(x) if isnum[at] else x
def sorting_key(attr):
atts = attr.attributes
return tuple([optfloat(atts.get(reverse_header_dict[name], ""), name)
for name in sortOrder])
attributes = sorted(table.domain.attributes, key=sorting_key)
domain = Orange.data.Domain(
attributes, table.domain.class_vars, table.domain.metas)
table = Orange.data.Table.from_table(domain, table)
table = Orange.data.Table(domain, table)
if self.transpose:
experiments = [at for at in table.domain.variables]
attr = [compat.ContinuousVariable.make(ex['DDB'].value) for ex in table]
metavars = sorted(table.domain.variables[0].attributes.keys())
metavars = [compat.StringVariable.make(name) for name in metavars]
domain = compat.create_domain(attr, None, metavars)
metas = [[exp.attributes[var.name] for var in metavars] for exp in experiments]
table = compat.create_table(domain, table.X.transpose(), None, metas)
data_hints.set_hint(table, "taxid", "352472")
data_hints.set_hint(table, "genesinrows", False)
self.send("Data", table)
self.UpdateCached()
pb.finish()
def onSelectionChanged(self, selected, deselected):
self.handle_commit_button()
def handle_commit_button(self):
self.currentSelection = \
SelectionByKey(self.experimentsWidget.selectionModel().selection(),
key=(ID_INDEX,))
self.commit_button.setDisabled(not len(self.currentSelection))
def saveHeaderState(self):
hview = self.experimentsWidget.header()
for i, label in enumerate(self.headerLabels):
self.experimentsHeaderState[label] = hview.isSectionHidden(i)
def restoreHeaderState(self):
hview = self.experimentsWidget.header()
state = self.experimentsHeaderState
for i, label in enumerate(self.headerLabels):
hview.setSectionHidden(i, state.get(label, True))
self.experimentsWidget.resizeColumnToContents(i)
class OWGenExpress(widget.OWWidget):
name = "GenExpress"
description = "Expression data from GenExpress."
icon = "../widgets/icons/GenCloud.svg"
priority = 36
inputs = []
outputs = [("Data", Orange.data.Table)]
username = settings.Setting("anonymous")
password = settings.Setting("")
log2 = settings.Setting(False)
transpose = settings.Setting(False)
rtypei = settings.Setting(0)
projecti = settings.Setting(0)
serveri = settings.Setting(0)
exnamei = settings.Setting(6)
excludeconstant = settings.Setting(False)
joinreplicates = settings.Setting(False)
currentSelection = settings.Setting(None)
experimentsHeaderState = settings.Setting(
{name: False
for _, name in HEADER[:ID_INDEX + 1]})
storedSortOrder = settings.Setting([])
storedSelections = settings.Setting([])
def __init__(self, parent=None):
super().__init__(parent)
self.servers = [
('https://dictyexpress.research.bcm.edu/', 'dictyExpress'),
('https://cloud.genialis.com/', 'Genialis'),
]
self.selectedExperiments = []
self.buffer = dicty.CacheSQLite(bufferfile)
self.searchString = ""
self.items = []
self.result_types = []
self.controlArea.setMaximumWidth(250)
self.controlArea.setMinimumWidth(250)
box = gui.widgetBox(self.controlArea, 'Project')
self.projectCB = gui.comboBox(box,
self,
"projecti",
items=[],
callback=self.ProjectChosen)
self.projects = []
b = gui.widgetBox(self.controlArea, "Selection bookmarks")
self.selectionSetsWidget = SelectionSetsWidget(self)
self.selectionSetsWidget.setSizePolicy(QSizePolicy.Preferred,
QSizePolicy.Maximum)
def store_selections(modified):
if not modified:
self.storedSelections = self.selectionSetsWidget.selections
self.selectionSetsWidget.selectionModified.connect(store_selections)
b.layout().addWidget(self.selectionSetsWidget)
gui.separator(self.controlArea)
b = gui.widgetBox(self.controlArea, "Sort output columns")
self.columnsSortingWidget = SortedListWidget(self)
self.columnsSortingWidget.setSizePolicy(QSizePolicy.Preferred,
QSizePolicy.Maximum)
box = gui.widgetBox(self.controlArea, 'Experiment name')
self.experimentNameCB = gui.comboBox(box,
self,
"exnamei",
items=SORTING_MODEL_LIST)
b.layout().addWidget(self.columnsSortingWidget)
sorting_model = QStringListModel(SORTING_MODEL_LIST)
self.columnsSortingWidget.setModel(sorting_model)
self.columnsSortingWidget.sortingOrder = self.storedSortOrder
def store_sort_order():
self.storedSortOrder = self.columnsSortingWidget.sortingOrder
self.columnsSortingWidget.sortingOrderChanged.connect(store_sort_order)
gui.separator(self.controlArea)
box = gui.widgetBox(self.controlArea, 'Expression Type')
self.expressionTypesCB = gui.comboBox(box,
self,
"rtypei",
items=[],
callback=self.UpdateResultsList)
gui.checkBox(self.controlArea, self, "excludeconstant",
"Exclude labels with constant values")
gui.checkBox(self.controlArea, self, "joinreplicates",
"Average replicates (use median)")
gui.checkBox(self.controlArea, self, "log2",
"Logarithmic (base 2) transformation")
gui.checkBox(self.controlArea, self, "transpose", "Genes as columns")
self.commit_button = gui.button(self.controlArea,
self,
"&Commit",
callback=self.Commit)
self.commit_button.setDisabled(True)
gui.rubber(self.controlArea)
box = gui.widgetBox(self.controlArea, 'Server')
gui.comboBox(box,
self,
"serveri",
items=[title for url, title in self.servers],
callback=self.ServerChosen)
gui.lineEdit(box,
self,
"username",
"Username:"******"password",
"Password:"******"Clear cache",
callback=self.clear_cache)
gui.lineEdit(self.mainArea,
self,
"searchString",
"Search",
callbackOnType=True,
callback=self.SearchUpdate)
self.headerLabels = [t[1] for t in HEADER]
self.experimentsWidget = QTreeWidget()
self.experimentsWidget.setHeaderLabels(self.headerLabels)
self.experimentsWidget.setSelectionMode(QTreeWidget.ExtendedSelection)
self.experimentsWidget.setRootIsDecorated(False)
self.experimentsWidget.setSortingEnabled(True)
contextEventFilter = gui.VisibleHeaderSectionContextEventFilter(
self.experimentsWidget, self.experimentsWidget)
self.experimentsWidget.header().installEventFilter(contextEventFilter)
self.experimentsWidget.setItemDelegateForColumn(
0, gui.IndicatorItemDelegate(self, role=Qt.DisplayRole))
self.experimentsWidget.setAlternatingRowColors(True)
self.experimentsWidget.selectionModel().selectionChanged.connect(
self.onSelectionChanged)
self.selectionSetsWidget.setSelectionModel(
self.experimentsWidget.selectionModel())
self.selectionSetsWidget.setSelections(self.storedSelections)
self.mainArea.layout().addWidget(self.experimentsWidget)
self.restoreHeaderState()
self.experimentsWidget.header().geometriesChanged.connect(
self.saveHeaderState)
self.dbc = None
self.AuthSet()
QTimer.singleShot(100, self.ConnectAndUpdate)
def sizeHint(self):
return QSize(800, 600)
def AuthSet(self):
if len(self.username):
self.passf.setDisabled(False)
else:
self.passf.setDisabled(True)
def AuthChanged(self):
self.AuthSet()
self.ConnectAndUpdate()
def ConnectAndUpdate(self):
self.Connect()
if self.dbc:
def get_data_count(project_id):
# XXX: is there a better way?
# Note: limit 0 would return all objects
return self.dbc.gen.api.data.get(
case_ids__contains=project_id,
type__startswith='data:expression:',
limit=1)['meta']['total_count']
self.projects = sorted([
p for p in self.dbc.projects().items()
if get_data_count(p[0]) > 0
],
key=lambda x: x[1])
self.UpdateProjects()
self.ProjectChosen()
self.UpdateExperimentTypes()
def Connect(self):
self.error(1)
self.warning(1)
username = '******'
password = '******'
url = self.servers[self.serveri][0]
if self.username:
username = self.username
password = self.password
if username.lower() in ['*****@*****.**', 'anonymous']:
username = '******'
password = '******'
self.dbc = None
self.projects = []
self.result_types = []
try:
self.dbc = Genesis(address=url,
username=username,
password=password,
cache=self.buffer)
except requests.exceptions.ConnectionError:
self.dbc = Genesis(address=url,
username=username,
password=password,
connect=False,
cache=self.buffer)
self.warning(1, "Could not connect to server, working from cache.")
except Exception:
self.error(1, "Wrong username or password.")
self.UpdateProjects()
self.UpdateExperimentTypes() # clear lists
def Reload(self):
self.UpdateExperiments(reload=True)
def clear_cache(self):
self.buffer.clear()
self.Reload()
def rtype(self):
"""Return selected result template type """
if self.result_types:
return self.result_types[self.rtypei]
else:
return None
def UpdateExperimentTypes(self):
self.expressionTypesCB.clear()
items = [self.result_types_labels[desc] for desc in self.result_types]
self.expressionTypesCB.addItems(items)
#do not update anything if the list is empty
if len(self.result_types):
self.rtypei = max(0, min(self.rtypei, len(self.result_types) - 1))
def UpdateProjects(self):
self.projectCB.clear()
items = [desc for pid, desc in self.projects]
self.projectCB.addItems(items)
#do not update anything if the list if empty
if len(self.projects) > 0:
self.projecti = max(0, min(self.projecti, len(self.projects) - 1))
def UpdateExperiments(self, reload=False):
self.experimentsWidget.clear()
if not self.dbc or not self.dbc.projectid: # the connection did not succeed
return
self.items = []
self.progressBarInit()
result_types = []
result_types_labels = []
sucind = False # success indicator for database index
try:
result_types, result_types_labels = self.dbc.result_types(
reload=reload)
sucind = True
except Exception:
try:
result_types, result_types_labels = self.dbc.result_types()
self.warning(0, "Can not access database - using cached data.")
sucind = True
except Exception:
self.error(0, "Can not access database.")
if sucind:
self.warning(0)
self.error(0)
self.result_types = result_types
self.result_types_labels = result_types_labels
self.UpdateExperimentTypes()
self.UpdateResultsList(reload=reload)
self.progressBarFinished()
if self.currentSelection:
self.currentSelection.select(
self.experimentsWidget.selectionModel())
self.handle_commit_button()
def ProjectChosen(self, reload=False):
if self.projects:
self.dbc.projectid = self.projects[self.projecti][0]
else:
self.dbc.projectid = None
self.UpdateExperiments(reload=reload)
def ServerChosen(self):
self.ConnectAndUpdate()
def UpdateResultsList(self, reload=False):
results_list = self.dbc.results_list(self.rtype(), reload=reload)
try:
results_list = self.dbc.results_list(self.rtype(), reload=reload)
except Exception:
try:
results_list = self.dbc.results_list(self.rtype())
except Exception:
self.error(0, "Can not access database.")
self.results_list = results_list
#softly change the view so that the selection stays the same
items_shown = {}
for i, item in enumerate(self.items):
c = str(item.text(ID_INDEX))
items_shown[c] = i
items_to_show = set(id_ for id_ in self.results_list)
add_items = set(items_to_show) - set(items_shown)
delete_items = set(items_shown) - set(items_to_show)
i = 0
while i < self.experimentsWidget.topLevelItemCount():
it = self.experimentsWidget.topLevelItem(i)
if str(it.text(ID_INDEX)) in delete_items:
self.experimentsWidget.takeTopLevelItem(i)
else:
i += 1
delete_ind = set([items_shown[i] for i in delete_items])
self.items = [
it for i, it in enumerate(self.items) if i not in delete_ind
]
for r_annot in add_items:
d = defaultdict(lambda: "?", self.results_list[r_annot])
row_items = [""] + [
to_text(d.get(key, "?")) for key, _ in HEADER[1:]
]
row_items[ID_INDEX] = r_annot
ci = MyTreeWidgetItem(self.experimentsWidget, row_items)
self.items.append(ci)
for i in range(len(self.headerLabels)):
self.experimentsWidget.resizeColumnToContents(i)
self.wantbufver = lambda x: self.results_list[x]["date_modified"]
self.UpdateCached()
def UpdateCached(self):
if self.wantbufver and self.dbc:
for item in self.items:
id = str(item.text(ID_INDEX))
version = self.dbc._in_buffer(id + "|||" + self.rtype())
value = " " if version == self.wantbufver(id) else ""
item.setData(0, Qt.DisplayRole, value)
def SearchUpdate(self, string=""):
for item in self.items:
item.setHidden(not all(s in item
for s in self.searchString.split()))
def Commit(self):
pb = gui.ProgressBar(self, iterations=100)
table = None
ids = []
for item in self.experimentsWidget.selectedItems():
unique_id = str(item.text(ID_INDEX))
ids.append(unique_id)
transfn = None
if self.log2:
transfn = lambda x: math.log(x + 1.0, 2)
reverse_header_dict = {name: name for key, name in HEADER}
reverse_header_dict["ID"] = "id"
allowed_labels = None
def namefn(a):
name = SORTING_MODEL_LIST[self.exnamei]
name = reverse_header_dict.get(name, "id")
return dict(a)[name]
if len(ids):
table = self.dbc.get_data(
ids=ids,
result_type=self.rtype(),
callback=pb.advance,
exclude_constant_labels=self.excludeconstant,
bufver=self.wantbufver,
transform=transfn,
allowed_labels=allowed_labels,
namefn=namefn)
if self.joinreplicates:
table = dicty.join_replicates(
table,
ignorenames=self.dbc.IGNORE_REPLICATE,
namefn="name",
avg=dicty.median,
fnshow=lambda x: " | ".join(map(str, x)))
# Sort attributes
sortOrder = self.columnsSortingWidget.sortingOrder
all_values = defaultdict(set)
for at in table.domain.attributes:
atts = at.attributes
for name in sortOrder:
all_values[name].add(
atts.get(reverse_header_dict[name], ""))
isnum = {}
for at, vals in all_values.items():
vals = filter(None, vals)
try:
for a in vals:
float(a)
isnum[at] = True
except ValueError:
isnum[at] = False
def optfloat(x, at):
if x == "":
return ""
else:
return float(x) if isnum[at] else x
def sorting_key(attr):
atts = attr.attributes
return tuple([
optfloat(atts.get(reverse_header_dict[name], ""), name)
for name in sortOrder
])
attributes = sorted(table.domain.attributes, key=sorting_key)
domain = Orange.data.Domain(attributes, table.domain.class_vars,
table.domain.metas)
table = Orange.data.Table.from_table(domain, table)
table = Orange.data.Table(domain, table)
if self.transpose:
experiments = [at for at in table.domain.variables]
attr = [
compat.ContinuousVariable.make(ex['DDB'].value)
for ex in table
]
metavars = sorted(table.domain.variables[0].attributes.keys())
metavars = [
compat.StringVariable.make(name) for name in metavars
]
domain = compat.create_domain(attr, None, metavars)
metavars = compat.get_metas(domain)
metas = [[exp.attributes[var.name] for var in metavars]
for exp in experiments]
table = compat.create_table(domain, table.X.transpose(), None,
metas)
data_hints.set_hint(table, "taxid", "352472")
data_hints.set_hint(table, "genesinrows", False)
self.send("Data", table)
self.UpdateCached()
pb.finish()
def onSelectionChanged(self, selected, deselected):
self.handle_commit_button()
def handle_commit_button(self):
self.currentSelection = \
SelectionByKey(self.experimentsWidget.selectionModel().selection(),
key=(ID_INDEX,))
self.commit_button.setDisabled(not len(self.currentSelection))
def saveHeaderState(self):
hview = self.experimentsWidget.header()
for i, label in enumerate(self.headerLabels):
self.experimentsHeaderState[label] = hview.isSectionHidden(i)
def restoreHeaderState(self):
hview = self.experimentsWidget.header()
state = self.experimentsHeaderState
for i, label in enumerate(self.headerLabels):
hview.setSectionHidden(i, state.get(label, True))
self.experimentsWidget.resizeColumnToContents(i)
class OWPIPAx(widget.OWWidget):
name = "PIPAx"
description = "Access data from PIPA RNA-Seq database."
icon = "../widgets/icons/PIPA.svg"
priority = 35
inputs = []
outputs = [("Data", Orange.data.Table)]
username = settings.Setting("")
password = settings.Setting("")
log2 = settings.Setting(False)
rtypei = settings.Setting(5) # hardcoded rpkm mapability polya
excludeconstant = settings.Setting(False)
joinreplicates = settings.Setting(False)
#: The stored current selection (in experiments view)
#: SelectionByKey | None
currentSelection = settings.Setting(None)
#: Stored selections (presets)
#: list of SelectionByKey
storedSelections = settings.Setting([])
#: Stored column sort keys (from Sort view)
#: list of strings
storedSortingOrder = settings.Setting(
["Strain", "Experiment", "Genotype", "Timepoint"])
experimentsHeaderState = settings.Setting(
{name: False
for _, name in HEADER[:ID_INDEX + 1]})
def __init__(self, parent=None, signalManager=None, name="PIPAx"):
super().__init__(parent)
self.selectedExperiments = []
self.buffer = dicty.CacheSQLite(bufferfile)
self.searchString = ""
self.result_types = []
self.mappings = {}
self.controlArea.setMaximumWidth(250)
self.controlArea.setMinimumWidth(250)
gui.button(self.controlArea, self, "Reload", callback=self.Reload)
gui.button(self.controlArea,
self,
"Clear cache",
callback=self.clear_cache)
b = gui.widgetBox(self.controlArea, "Experiment Sets")
self.selectionSetsWidget = SelectionSetsWidget(self)
self.selectionSetsWidget.setSizePolicy(QSizePolicy.Preferred,
QSizePolicy.Maximum)
def store_selections(modified):
if not modified:
self.storedSelections = self.selectionSetsWidget.selections
self.selectionSetsWidget.selectionModified.connect(store_selections)
b.layout().addWidget(self.selectionSetsWidget)
gui.separator(self.controlArea)
b = gui.widgetBox(self.controlArea, "Sort output columns")
self.columnsSortingWidget = SortedListWidget(self)
self.columnsSortingWidget.setSizePolicy(QSizePolicy.Preferred,
QSizePolicy.Maximum)
def store_sort_order():
self.storedSortingOrder = self.columnsSortingWidget.sortingOrder
self.columnsSortingWidget.sortingOrderChanged.connect(store_sort_order)
b.layout().addWidget(self.columnsSortingWidget)
sorting_model = QStringListModel(SORTING_MODEL_LIST)
self.columnsSortingWidget.setModel(sorting_model)
gui.separator(self.controlArea)
box = gui.widgetBox(self.controlArea, 'Expression Type')
self.expressionTypesCB = gui.comboBox(box,
self,
"rtypei",
items=[],
callback=self.UpdateResultsList)
gui.checkBox(self.controlArea, self, "excludeconstant",
"Exclude labels with constant values")
gui.checkBox(self.controlArea, self, "joinreplicates",
"Average replicates (use median)")
gui.checkBox(self.controlArea, self, "log2",
"Logarithmic (base 2) transformation")
self.commit_button = gui.button(self.controlArea,
self,
"&Commit",
callback=self.Commit)
self.commit_button.setDisabled(True)
gui.rubber(self.controlArea)
box = gui.widgetBox(self.controlArea, "Authentication")
gui.lineEdit(box,
self,
"username",
"Username:"******"password",
"Password:"******"searchString",
"Search",
callbackOnType=True,
callback=self.SearchUpdate)
self.headerLabels = [t[1] for t in HEADER]
self.experimentsWidget = QTreeWidget()
self.experimentsWidget.setHeaderLabels(self.headerLabels)
self.experimentsWidget.setSelectionMode(QTreeWidget.ExtendedSelection)
self.experimentsWidget.setRootIsDecorated(False)
self.experimentsWidget.setSortingEnabled(True)
contextEventFilter = gui.VisibleHeaderSectionContextEventFilter(
self.experimentsWidget, self.experimentsWidget)
self.experimentsWidget.header().installEventFilter(contextEventFilter)
self.experimentsWidget.setItemDelegateForColumn(
0, gui.IndicatorItemDelegate(self, role=Qt.DisplayRole))
self.experimentsWidget.setAlternatingRowColors(True)
self.experimentsWidget.selectionModel().selectionChanged.connect(
self.onSelectionChanged)
self.selectionSetsWidget.setSelectionModel(
self.experimentsWidget.selectionModel())
self.mainArea.layout().addWidget(self.experimentsWidget)
# Restore the selection states from the stored settings
self.selectionSetsWidget.selections = self.storedSelections
self.columnsSortingWidget.sortingOrder = self.storedSortingOrder
self.restoreHeaderState()
self.experimentsWidget.header().geometriesChanged.connect(
self.saveHeaderState)
self.dbc = None
self.AuthSet()
QTimer.singleShot(100, self.UpdateExperiments)
def sizeHint(self):
return QSize(800, 600)
def AuthSet(self):
if len(self.username):
self.passf.setDisabled(False)
else:
self.passf.setDisabled(True)
def AuthChanged(self):
self.AuthSet()
self.ConnectAndUpdate()
def ConnectAndUpdate(self):
self.Connect()
self.UpdateExperiments(reload=True)
def Connect(self):
self.error(1)
self.warning(1)
def en(x):
return x if len(x) else None
self.dbc = dicty.PIPAx(cache=self.buffer,
username=en(self.username),
password=self.password)
# check password
if en(self.username) != None:
try:
self.dbc.mappings(reload=True)
except dicty.AuthenticationError:
self.error(1, "Wrong username or password")
self.dbc = None
except Exception as ex:
print("Error when contacting the PIPA database", ex)
sys.excepthook(*sys.exc_info())
try: # maybe cached?
self.dbc.mappings()
self.warning(
1, "Can not access database - using cached data.")
except Exception as ex:
self.dbc = None
self.error(1, "Can not access database.")
def Reload(self):
self.UpdateExperiments(reload=True)
def clear_cache(self):
self.buffer.clear()
self.Reload()
def rtype(self):
"""Return selected result template type """
if self.result_types:
return self.result_types[self.rtypei][0]
else:
return "-1"
def UpdateExperimentTypes(self):
self.expressionTypesCB.clear()
items = [desc for _, desc in self.result_types]
self.expressionTypesCB.addItems(items)
self.rtypei = max(0, min(self.rtypei, len(self.result_types) - 1))
def UpdateExperiments(self, reload=False):
self.experimentsWidget.clear()
self.items = []
self.progressBarInit()
if not self.dbc:
self.Connect()
mappings = {}
result_types = []
sucind = False # success indicator for database index
try:
mappings = self.dbc.mappings(reload=reload)
result_types = self.dbc.result_types(reload=reload)
sucind = True
except Exception as ex:
try:
mappings = self.dbc.mappings()
result_types = self.dbc.result_types()
self.warning(0, "Can not access database - using cached data.")
sucind = True
except Exception as ex:
self.error(0, "Can not access database.")
if sucind:
self.warning(0)
self.error(0)
self.mappings = mappings
self.result_types = result_types
self.UpdateExperimentTypes()
self.UpdateResultsList(reload=reload)
self.progressBarFinished()
if self.currentSelection:
self.currentSelection.select(
self.experimentsWidget.selectionModel())
self.handle_commit_button()
def UpdateResultsList(self, reload=False):
results_list = {}
try:
results_list = self.dbc.results_list(self.rtype(), reload=reload)
except Exception as ex:
try:
results_list = self.dbc.results_list(self.rtype())
except Exception as ex:
self.error(0, "Can not access database.")
self.results_list = results_list
mappings_key_dict = dict(((m["data_id"], m["id"]), key) \
for key, m in self.mappings.items())
def mapping_unique_id(annot):
"""Map annotations dict from results_list to unique
`mappings` ids.
"""
data_id, mappings_id = annot["data_id"], annot["mappings_id"]
return mappings_key_dict[data_id, mappings_id]
elements = []
# softly change the view so that the selection stays the same
items_shown = {}
for i, item in enumerate(self.items):
c = str(item.text(10))
items_shown[c] = i
items_to_show = dict((mapping_unique_id(annot), annot)
for annot in self.results_list.values())
add_items = set(items_to_show) - set(items_shown)
delete_items = set(items_shown) - set(items_to_show)
i = 0
while i < self.experimentsWidget.topLevelItemCount():
it = self.experimentsWidget.topLevelItem(i)
if str(it.text(10)) in delete_items:
self.experimentsWidget.takeTopLevelItem(i)
else:
i += 1
delete_ind = set([items_shown[i] for i in delete_items])
self.items = [
it for i, it in enumerate(self.items) if i not in delete_ind
]
for r_annot in [items_to_show[i] for i in add_items]:
d = defaultdict(lambda: "?", r_annot)
row_items = [""] + [d.get(key, "?") for key, _ in HEADER[1:]]
try:
time_dict = literal_eval(row_items[DATE_INDEX])
date_rna = date(
time_dict["fullYearUTC"],
time_dict["monthUTC"] + 1, # Why is month 0 based?
time_dict["dateUTC"])
row_items[DATE_INDEX] = date_rna.strftime("%x")
except Exception:
row_items[DATE_INDEX] = ''
row_items[ID_INDEX] = mapping_unique_id(r_annot)
elements.append(row_items)
ci = MyTreeWidgetItem(self.experimentsWidget, row_items)
self.items.append(ci)
for i in range(len(self.headerLabels)):
self.experimentsWidget.resizeColumnToContents(i)
# which is the ok buffer version
# FIXME: what attribute to use for version?
self.wantbufver = \
lambda x, ad=self.results_list: \
defaultdict(lambda: "?", ad[x])["date"]
self.wantbufver = lambda x: "0"
self.UpdateCached()
def UpdateCached(self):
if self.wantbufver and self.dbc:
fn = self.dbc.download_key_function()
result_id_key = dict(((m["data_id"], m["mappings_id"]), key) \
for key, m in self.results_list.items())
for item in self.items:
c = str(item.text(10))
mapping = self.mappings[c]
data_id, mappings_id = mapping["data_id"], mapping["id"]
r_id = result_id_key[data_id, mappings_id]
# Get the buffered version
buffered = self.dbc.inBuffer(fn(r_id))
value = " " if buffered == self.wantbufver(r_id) else ""
item.setData(0, Qt.DisplayRole, value)
def SearchUpdate(self, string=""):
for item in self.items:
item.setHidden(not all(s in item \
for s in self.searchString.split())
)
def Commit(self):
if not self.dbc:
self.Connect()
pb = gui.ProgressBar(self, iterations=100)
table = None
ids = []
for item in self.experimentsWidget.selectedItems():
unique_id = str(item.text(10))
annots = self.mappings[unique_id]
ids.append((annots["data_id"], annots["id"]))
transfn = None
if self.log2:
transfn = lambda x: math.log(x + 1.0, 2)
reverse_header_dict = dict((name, key) for key, name in HEADER)
hview = self.experimentsWidget.header()
shownHeaders = [label for i, label in \
list(enumerate(self.headerLabels))[1:] \
if not hview.isSectionHidden(i)
]
allowed_labels = [reverse_header_dict.get(label, label) \
for label in shownHeaders]
if self.joinreplicates and "id" not in allowed_labels:
# need 'id' labels in join_replicates for attribute names
allowed_labels.append("id")
if len(ids):
table = self.dbc.get_data(
ids=ids,
result_type=self.rtype(),
callback=pb.advance,
exclude_constant_labels=self.excludeconstant,
# bufver=self.wantbufver,
transform=transfn,
allowed_labels=allowed_labels)
if self.joinreplicates:
table = dicty.join_replicates(table,
ignorenames=[
"replicate", "data_id",
"mappings_id", "data_name",
"id", "unique_id"
],
namefn=None,
avg=dicty.median)
# Sort attributes
sortOrder = self.columnsSortingWidget.sortingOrder
all_values = defaultdict(set)
for at in table.domain.attributes:
atts = at.attributes
for name in sortOrder:
all_values[name].add(
atts.get(reverse_header_dict[name], ""))
isnum = {}
for at, vals in all_values.items():
vals = filter(None, vals)
try:
for a in vals:
float(a)
isnum[at] = True
except:
isnum[at] = False
def optfloat(x, at):
if x == "":
return ""
else:
return float(x) if isnum[at] else x
def sorting_key(attr):
atts = attr.attributes
return tuple([optfloat(atts.get(reverse_header_dict[name], ""), name) \
for name in sortOrder])
attributes = sorted(table.domain.attributes, key=sorting_key)
domain = Orange.data.Domain(attributes, table.domain.class_var,
table.domain.metas)
table = table.from_table(domain, table)
data_hints.set_hint(table, "taxid", "352472")
data_hints.set_hint(table, "genesinrows", False)
self.send("Data", table)
self.UpdateCached()
pb.finish()
def onSelectionChanged(self, selected, deselected):
self.handle_commit_button()
def handle_commit_button(self):
self.currentSelection = \
SelectionByKey(self.experimentsWidget.selectionModel().selection(),
key=(1, 2, 3, 10))
self.commit_button.setDisabled(not len(self.currentSelection))
def saveHeaderState(self):
hview = self.experimentsWidget.header()
for i, label in enumerate(self.headerLabels):
self.experimentsHeaderState[label] = hview.isSectionHidden(i)
def restoreHeaderState(self):
hview = self.experimentsWidget.header()
state = self.experimentsHeaderState
for i, label in enumerate(self.headerLabels):
hview.setSectionHidden(i, state.get(label, True))
self.experimentsWidget.resizeColumnToContents(i)
