class OWWidgetName(widget.OWWidget):
name = "Teste"
id = "orange.widgets.widget_category.widget_name"
description = "Test"
icon = "icons/Default.png"
priority = 10
category = ""
keywords = ["list", "of", "keywords"]
class Inputs:
data = Input("Data", Orange.data.Table)
# [start-snippet-1]
class Outputs:
sample = Output("Sampled Data", Orange.data.Table)
other = Output("Other Data", Orange.data.Table)
# [end-snippet-1]
proportion = settings.Setting(50)
commitOnChange = settings.Setting(0)
want_main_area = False
foo = Setting(True)
def __init__(self):
super().__init__()
# controls
gui.rubber(self.controlArea)
def handler(self, obj):
pass
class OWDataSamplerB(OWWidget):
name = "Data Sampler (B)"
description = "Randomly selects a subset of instances from the dataset."
icon = "icons/DataSamplerB.svg"
priority = 20
class Inputs:
data = Input("Data", Orange.data.Table)
class Outputs:
sample = Output("Sampled Data", Orange.data.Table)
proportion = settings.Setting(50)
commitOnChange = settings.Setting(0)
# [end-snippet-1]
want_main_area = False
def __init__(self):
super().__init__()
self.dataset = None
self.sample = None
# GUI
# [start-snippet-3]
box = gui.widgetBox(self.controlArea, "Info")
self.infoa = gui.widgetLabel(
box, 'No data on input yet, waiting to get something.')
self.infob = gui.widgetLabel(box, '')
gui.separator(self.controlArea)
self.optionsBox = gui.widgetBox(self.controlArea, "Options")
gui.spin(self.optionsBox,
self,
'proportion',
minv=10,
maxv=90,
step=10,
label='Sample Size [%]:',
callback=[self.selection, self.checkCommit])
gui.checkBox(self.optionsBox, self, 'commitOnChange',
'Commit data on selection change')
gui.button(self.optionsBox, self, "Commit", callback=self.commit)
self.optionsBox.setDisabled(True)
# [end-snippet-3]
# [start-snippet-4]
@Inputs.data
def set_data(self, dataset):
if dataset is not None:
self.dataset = dataset
self.infoa.setText('%d instances in input dataset' % len(dataset))
self.optionsBox.setDisabled(False)
self.selection()
else:
self.dataset = None
self.sample = None
self.optionsBox.setDisabled(False)
self.infoa.setText(
'No data on input yet, waiting to get something.')
self.infob.setText('')
self.commit()
def selection(self):
if self.dataset is None:
return
n_selected = int(numpy.ceil(
len(self.dataset) * self.proportion / 100.))
indices = numpy.random.permutation(len(self.dataset))
indices = indices[:n_selected]
self.sample = self.dataset[indices]
self.infob.setText('%d sampled instances' % len(self.sample))
def commit(self):
self.Outputs.sample.send(self.sample)
def checkCommit(self):
if self.commitOnChange:
self.commit()
class OWDataSamplerC(OWWidget):
name = "Data Sampler (C)"
description = "Randomly selects a subset of instances from the dataset."
icon = "icons/DataSamplerC.svg"
priority = 30
class Inputs:
data = Input("Data", Orange.data.Table)
# [start-snippet-1]
class Outputs:
sample = Output("Sampled Data", Orange.data.Table)
other = Output("Other Data", Orange.data.Table)
# [end-snippet-1]
proportion = settings.Setting(50)
commitOnChange = settings.Setting(0)
want_main_area = False
def __init__(self):
super().__init__()
self.dataset = None
self.sample = None
self.otherdata = None
# GUI
box = gui.widgetBox(self.controlArea, "Info")
self.infoa = gui.widgetLabel(
box, "No data on input yet, waiting to get something.")
self.infob = gui.widgetLabel(box, "")
gui.separator(self.controlArea)
self.optionsBox = gui.widgetBox(self.controlArea, "Options")
gui.spin(
self.optionsBox,
self,
"proportion",
minv=10,
maxv=90,
step=10,
label="Sample Size [%]:",
callback=[self.selection, self.checkCommit],
)
gui.checkBox(self.optionsBox, self, "commitOnChange",
"Commit data on selection change")
gui.button(self.optionsBox, self, "Commit", callback=self.commit)
self.optionsBox.setDisabled(True)
self.resize(100, 50)
@Inputs.data
def set_data(self, dataset):
if dataset is not None:
self.dataset = dataset
self.infoa.setText("%d instances in input dataset" % len(dataset))
self.optionsBox.setDisabled(False)
self.selection()
else:
self.sample = None
self.otherdata = None
self.optionsBox.setDisabled(True)
self.infoa.setText(
"No data on input yet, waiting to get something.")
self.infob.setText("")
self.commit()
def selection(self):
if self.dataset is None:
return
n_selected = int(
numpy.ceil(len(self.dataset) * self.proportion / 100.0))
indices = numpy.random.permutation(len(self.dataset))
indices_sample = indices[:n_selected]
indices_other = indices[n_selected:]
self.sample = self.dataset[indices_sample]
self.otherdata = self.dataset[indices_other]
self.infob.setText("%d sampled instances" % len(self.sample))
def commit(self):
self.Outputs.sample.send(self.sample)
self.Outputs.sample.send(self.otherdata)
def checkCommit(self):
if self.commitOnChange:
self.commit()
class OWUNComtrade(widget.OWWidget):
name = "UN Comtrade"
description = "Gets data from UN Comtrade database"
icon = "icons/un_comtrade.svg"
priority = 10
outputs = [("API data", Orange.data.Table)]
# info = settings.Setting(0)
profiles_or_time_series = settings.Setting(0)
commodities_or_services = settings.Setting(0)
tf_import = settings.Setting(0)
tf_export = settings.Setting(0)
tf_re_import = settings.Setting(0)
tf_re_export = settings.Setting(0)
reporter_filter = settings.Setting('')
partner_filter = settings.Setting('')
years_filter = settings.Setting('')
comm_ser_filter = settings.Setting('')
want_main_area = False
rep_top_item = None
par_top_item = None
comm_ser_top_item = None
def __init__(self):
super().__init__()
whole_box = gui.widgetBox(self.controlArea, "", orientation=False)
left_box = gui.widgetBox(whole_box, "")
right_box = gui.widgetBox(whole_box, "")
info_box = gui.widgetBox(left_box, "Info")
self.info = gui.widgetLabel(
info_box,
'Input: no reporters, no partners, no commodities/services')
size_policy = QSizePolicy(QSizePolicy.Maximum, QSizePolicy.Minimum)
top_box = gui.widgetBox(left_box, "Type of output")
gui.radioButtonsInBox(top_box,
self,
'profiles_or_time_series',
['Profiles', 'Time series'],
orientation=False,
sizePolicy=size_policy,
callback=self.clear_messages)
reporter_partner_years_box = gui.widgetBox(left_box,
"",
orientation=False)
size_policy.setHorizontalStretch(2)
reporters_box = gui.widgetBox(reporter_partner_years_box,
"Reporters",
sizePolicy=size_policy)
gui.lineEdit(reporters_box,
self,
'reporter_filter',
'Filter ',
callback=(lambda: self.filter(self.list_model_reporter[1],
self.reporter_filter)),
callbackOnType=True,
orientation=False)
self.list_model_reporter = self.make_continent_view(
'rep', self.on_continent_item_changed, reporters_box)
size_policy.setHorizontalStretch(2)
partners_box = gui.widgetBox(reporter_partner_years_box,
"Partners",
sizePolicy=size_policy)
gui.lineEdit(partners_box,
self,
'partner_filter',
'Filter ',
callback=(lambda: self.filter(self.list_model_partner[1],
self.partner_filter)),
callbackOnType=True,
orientation=False)
self.list_model_partner = self.make_continent_view(
'par', self.on_continent_item_changed, partners_box)
size_policy.setHorizontalStretch(1)
years_box = gui.widgetBox(reporter_partner_years_box,
"Years",
sizePolicy=size_policy)
gui.lineEdit(years_box,
self,
'years_filter',
'Filter ',
callback=(lambda: self.filter(self.list_model_years[1],
self.years_filter)),
callbackOnType=True,
orientation=False)
self.list_model_years = self.make_list_view(self.on_item_changed,
years_box)
trade_flows_box = gui.widgetBox(left_box, "Trade", orientation=False)
gui.checkBox(trade_flows_box,
self,
'tf_import',
'Import',
callback=self.on_item_changed)
exp = gui.checkBox(trade_flows_box,
self,
'tf_export',
'Export',
callback=self.on_item_changed)
exp.setCheckState(Qt.Checked)
gui.checkBox(trade_flows_box,
self,
'tf_re_import',
'Re-import',
callback=self.on_item_changed)
gui.checkBox(trade_flows_box,
self,
'tf_re_export',
'Re-export',
callback=self.on_item_changed)
commodities_services_box = gui.widgetBox(right_box, "Exchange Type")
gui.radioButtonsInBox(
commodities_services_box,
self,
'commodities_or_services', ['Commodities', 'Services'],
orientation=False,
sizePolicy=size_policy,
callback=(lambda: self.change_tree_view(commodities_services_box)))
gui.lineEdit(commodities_services_box,
self,
'comm_ser_filter',
'Filter ',
callback=(lambda: self.filter(self.tree_model_cs[1], self.
comm_ser_filter)),
callbackOnType=True,
orientation=False)
self.tree_model_cs = self.make_tree_view('comm', self.on_item_changed,
commodities_services_box)
button_box = gui.widgetBox(left_box, "")
self.commit_button = gui.button(button_box,
self,
"Commit",
callback=self.commit)
self.commit_button.setEnabled(False)
# activate filters
self.filter(self.list_model_reporter[1], self.reporter_filter)
self.filter(self.list_model_partner[1], self.partner_filter)
self.filter(self.list_model_years[1], self.years_filter)
self.filter(self.tree_model_cs[1], self.comm_ser_filter)
def make_list_view(self, callback, append_to):
data = unc.years()
list = QListView()
list.setHorizontalScrollBarPolicy(Qt.ScrollBarAlwaysOff)
model = QStandardItemModel(0, 1)
for i in range(1, len(data)):
item = QStandardItem(str(data[i]))
model.appendRow(item)
model.itemChanged.connect(callback)
list.setModel(model)
list.setEditTriggers(QAbstractItemView.NoEditTriggers)
list.setSelectionMode(QAbstractItemView.ExtendedSelection)
proxy_model = FindFilterProxyModel()
proxy_model.setSourceModel(model)
proxy_model.setFilterKeyColumn(-1)
list.setModel(proxy_model)
list.selectionModel().selectionChanged.connect(callback)
append_to.layout().addWidget(list)
return [list, proxy_model, model]
def make_continent_view(self, type, callback, append_to):
cc = ContinentCountries()
if (type == 'rep'):
data = cc.rep_continents
elif (type == 'par'):
data = cc.par_continents
list = QTreeView()
model = QStandardItemModel(0, 1)
for key, values in sorted(data.items()):
continent = QStandardItem(key)
continent.setCheckable(True)
for country in values:
country = QStandardItem(country)
country.setCheckable(True)
continent.setChild(continent.rowCount(), country)
model.setItem(model.rowCount(), continent)
if (type == 'rep'):
self.rep_top_item = model.index(0, 0)
elif (type == 'par'):
self.par_top_item = model.index(0, 0)
model.itemChanged.connect(callback)
list.setModel(model)
list.setEditTriggers(QAbstractItemView.NoEditTriggers)
list.setHeaderHidden(True)
list.expandAll()
proxy_model = FindFilterProxyModel()
proxy_model.setSourceModel(model)
proxy_model.setFilterKeyColumn(-1)
list.setModel(proxy_model)
list.expandAll()
append_to.layout().addWidget(list)
return [list, proxy_model, model]
def make_tree_view(self, type, callback, append_to):
if (type == 'comm'):
data = unc.commodities_HS_all()
elif (type == 'ser'):
data = unc.services_all()
global current_tree_widget
if (current_tree_widget is not None):
append_to.layout().removeWidget(current_tree_widget)
class TreeView(QTreeView):
def sizeHint(self):
return QSize(700, 600)
tree = TreeView(
sizePolicy=QSizePolicy(QSizePolicy.Minimum, QSizePolicy.Minimum))
model = QStandardItemModel(0, 1)
model = self.recursive({'children': data}, None, model)
self.comm_ser_top_item = model.index(0, 0)
model.itemChanged.connect(callback)
tree.setModel(model)
tree.setHeaderHidden(True)
tree.expandAll()
tree.setEditTriggers(QAbstractItemView.NoEditTriggers)
proxy_model = FindFilterProxyModel()
proxy_model.setSourceModel(model)
proxy_model.setFilterKeyColumn(-1)
tree.setModel(proxy_model)
tree.expandAll()
current_tree_widget = tree
append_to.layout().addWidget(tree)
return [tree, proxy_model, model]
def recursive(self, obj, parent, model):
if (not obj['children']):
return model
for key in obj['children']:
new_obj = obj['children'][key]
top_item = QStandardItem(new_obj['text'])
top_item.setCheckable(True)
if (parent is not None):
parent.setChild(parent.rowCount(), top_item)
else:
model.setItem(model.rowCount(), top_item)
self.recursive(new_obj, top_item, model)
return model
def on_item_changed(self):
self.clear_messages()
if not self.cs_tree_constructed():
return
rep_num, par_num, tree_num = self.set_info_string()
number_of_all_selected = 0
if (rep_num == 256):
number_of_all_selected += 1
if (par_num == 277 or par_num == 278):
number_of_all_selected += 1
selected_years = self.get_selected_years()
if (len(selected_years) == 55):
number_of_all_selected += 1
selected_trade = self.get_checked_trades()
self.validate_commit(number_of_all_selected, rep_num, par_num,
len(selected_years), len(selected_trade),
tree_num)
return 0
def on_continent_item_changed(self, item):
if (item.hasChildren()):
i = 0
while (item.child(i) is not None):
child = item.child(i)
if (item.checkState() == Qt.Checked):
child.setCheckState(Qt.Checked)
else:
child.setCheckState(Qt.Unchecked)
i += 1
self.on_item_changed()
return 0
def set_info_string(self):
rep_num = len(self.checked_tree_items(self.list_model_reporter[2],
'r'))
par_num = len(self.checked_tree_items(self.list_model_partner[2], 'p'))
tree_num = len(self.checked_tree_items(self.tree_model_cs[2], 'cs'))
if (rep_num > 1):
rep_str = str(rep_num) + ' reporters'
elif (rep_num == 1):
rep_str = str(rep_num) + ' reporter'
elif (rep_num == 0):
rep_str = 'no reporters'
if (par_num > 1):
par_str = str(par_num) + ' partners'
elif (par_num == 1):
par_str = str(par_num) + ' partner'
elif (par_num == 0):
par_str = 'no partners'
if (tree_num > 1):
tree_str = str(tree_num) + ' commodities/services'
elif (tree_num == 1):
tree_str = str(tree_num) + ' commodity/service'
elif (tree_num == 0):
tree_str = 'no commodities/services'
s = 'Input: ' + rep_str + ', ' + par_str + ', ' + tree_str
self.info.setStyleSheet("QLabel { color : black; }")
self.info.setText(s)
return [rep_num, par_num, tree_num]
def filter(self, proxy_model, filter_input):
proxy_model.setFilterRegExp(QRegExp(filter_input, Qt.CaseInsensitive))
def change_tree_view(self, box):
self.clear_messages()
cs = self.commodities_or_services
if (cs == 0):
self.tree_model_cs = self.make_tree_view('comm',
self.on_item_changed, box)
elif (cs == 1):
self.tree_model_cs = self.make_tree_view('ser',
self.on_item_changed, box)
tree_view, proxy_model, model = self.tree_model_cs
proxy_model.setFilterRegExp(
QRegExp(self.comm_ser_filter, Qt.CaseInsensitive))
self.set_info_string()
return 0
def commit(self):
number_of_all_selected = 0
selected_reporters = self.checked_tree_items(
self.list_model_reporter[2], 'r')
if (len(selected_reporters) == 256):
selected_reporters = 'all'
number_of_all_selected += 1
selected_partners = self.checked_tree_items(self.list_model_partner[2],
'p')
if (len(selected_partners) == 277 or len(selected_partners) == 278):
selected_partners = 'all'
number_of_all_selected += 1
selected_years = self.get_selected_years()
selected_years.sort()
if (len(selected_years) == 55):
selected_years = 'all'
number_of_all_selected += 1
selected_trade = self.get_checked_trades()
tree_selection = self.checked_tree_items(self.tree_model_cs[2], 'cs')
# print('COMMIT')
# print(self.profiles_or_time_series)
# print(self.commodities_or_services)
# print(selected_reporters)
# print(selected_partners)
# print(selected_years)
# print(selected_trade)
# print(tree_selection)
validation = self.validate_commit(number_of_all_selected,
len(selected_reporters),
len(selected_partners),
len(selected_years),
len(selected_trade),
len(tree_selection))
if (not validation):
return
self.info.setStyleSheet("QLabel { color : black; }")
self.info.setText('Retrieving data...')
self.info.repaint()
if (self.commodities_or_services == 0):
tree_type = 'C'
elif (self.commodities_or_services == 1):
tree_type = 'S'
res = unc.get_data(selected_reporters,
selected_partners,
selected_years,
selected_trade,
type=tree_type,
commodities=tree_selection)
if (self.profiles_or_time_series == 0):
if (selected_years == 'all'):
selected_years = list(map(str, unc.years()))[1:]
output_table = unc.table_profiles(res, selected_years)
elif (self.profiles_or_time_series == 1):
output_table = unc.table_time_series(res)
# print(output_table)
if (output_table is not None):
self.send("API data", output_table)
instance_s = ' data instance' if len(
output_table) == 1 else ' data instances'
s = 'Output: ' + str(len(output_table)) + instance_s
self.info.setStyleSheet("QLabel { color : green; }")
self.info.setText(s)
else:
# self.warning("No data found.")
self.info.setStyleSheet("QLabel { color : black; }")
self.info.setText('No data found.')
return 1
return output_table
def checked_tree_items(self, model, r_p_cs):
dont_count = [
'Europe', 'North America', 'South America', 'Asia', 'Africa',
'Australia & Oceania'
]
if (r_p_cs == 'r'):
top_item = self.rep_top_item
elif (r_p_cs == 'p'):
top_item = self.par_top_item
elif (r_p_cs == 'cs'):
top_item = self.comm_ser_top_item
checked_items = model.match(top_item, Qt.CheckStateRole, Qt.Checked,
-1, Qt.MatchRecursive)
selection = [
item.data(0) for item in checked_items
if item.data(0) not in dont_count
]
return selection
def validate_commit(self, number_all_selected, rep_len, par_len, years_len,
trade_len, tree_len):
"""
self.info.setStyleSheet("QLabel { color : #dd0000; }")
if (number_all_selected > 1):
self.info.setText('Only one of reporters, partners and years can have all items selected.')
return False
if (rep_len == 0):
self.info.setText('You have to choose at least one reporter.')
return False
if (par_len == 0):
self.info.setText('You have to choose at least one partner.')
return False
if (years_len == 0):
self.info.setText('You have to choose at least one year.')
return False
if (trade_len == 0):
self.info.setText('You have to choose at least one trade flow.')
return False
if (tree_len == 0):
self.info.setText('You have to choose at least one commodity or service.')
return False
"""
if (number_all_selected > 1 or rep_len == 0 or par_len == 0
or years_len == 0 or trade_len == 0 or tree_len == 0):
self.commit_button.setEnabled(False)
return False
self.commit_button.setEnabled(True)
return True
def get_checked_trades(self):
selected_trade = []
if (self.tf_import):
selected_trade.append('Import')
if (self.tf_export):
selected_trade.append('Export')
if (self.tf_re_import):
selected_trade.append('re-Import')
if (self.tf_re_export):
selected_trade.append('re-Export')
return selected_trade
def get_selected_years(self):
return [
year.data(0)
for year in self.list_model_years[0].selectedIndexes()
]
def cs_tree_constructed(self):
return hasattr(self, 'tree_model_cs')
class OWExpressed(OWWidget):
name = "Test"
description = "Selects most expressed genes."
category = "New"
icon = "icons/Default.png"
priority = 30
class Inputs:
data = Input("Data", Orange.data.Table)
# [start-snippet-1]
class Outputs:
sample = Output("Selected Genes", Orange.data.Table)
other = Output("Other Genes", Orange.data.Table)
number = Output("Number", int)
# [end-snippet-1]
proportionEX = settings.Setting(50)
proportionVA = settings.Setting(50)
commitOnChange = settings.Setting(0)
want_main_area = False
resizing_enabled = False
RandomSeed = 42
FixedProportion, FixedSize, CrossValidation, Bootstrap = range(4)
SqlTime, SqlProportion = range(2)
use_seed = Setting(False)
replacement = Setting(False)
stratify = Setting(False)
sql_dl = Setting(False)
sampling_type = Setting(FixedProportion)
sampleSizeNumber = Setting(1)
sampleSizePercentage = Setting(70)
sampleSizeSqlTime = Setting(1)
sampleSizeSqlPercentage = Setting(0.1)
number_of_folds = Setting(10)
selectedFold = Setting(1)
class Error(OWWidget.Error):
no_data = Msg("Dataset is empty")
def __init__(self):
super().__init__()
self.dataset = None
self.sample = None
self.otherdata = None
self.sampled_instances = self.remaining_instances = None
# GUI
box = gui.widgetBox(self.controlArea, "Info")
self.infoa = gui.widgetLabel(
box, 'No data on input yet, waiting to get something.')
self.infob = gui.widgetLabel(box, '')
self.infoc = gui.widgetLabel(box, '')
self.infod = gui.widgetLabel(box, '')
box2 = gui.widgetBox(self.controlArea, "Info2")
self.infotest = gui.widgetLabel(box2, 'Test Box.')
self.infotes2 = gui.widgetLabel(box2, 'Testing')
self.sampling_box = gui.vBox(self.controlArea, "Sampling Type")
sampling = gui.radioButtons(self.sampling_box, self, "sampling_type")
def set_sampling_type(i):
def set_sampling_type_i():
self.sampling_type = i
return set_sampling_type_i
gui.appendRadioButton(sampling, "Fixed proportion of data:")
self.sampleSizePercentageSlider = gui.hSlider(
gui.indentedBox(sampling),
self,
'proportionEX',
minValue=0,
maxValue=99,
ticks=10,
labelFormat="%d %%",
callback=[self.selection, self.checkCommit],
)
gui.separator(self.controlArea)
self.optionsBox = gui.widgetBox(self.controlArea, "Options")
gui.spin(self.optionsBox,
self,
'proportionEX',
minv=0,
maxv=100,
step=1,
label='Most Expressed Genes [%]:',
callback=[self.selection, self.checkCommit])
gui.spin(self.optionsBox,
self,
'proportionVA',
minv=0,
maxv=100,
step=1,
label='Most Variant Genes [%]:',
callback=[self.selection, self.checkCommit])
gui.checkBox(self.optionsBox, self, 'commitOnChange',
'Commit data on selection change')
gui.button(self.optionsBox, self, "Commit", callback=self.commit)
self.optionsBox.setDisabled(True)
self.resize(100, 50)
@Inputs.data
def set_data(self, dataset):
if dataset is not None:
self.dataset = dataset
self.data = dataset
table = Orange.data.Table(dataset)
self.infoa.setText('%d Genes in dataset' % len(table))
self.infob.setText('%d Samples in dataset' % len(table.domain))
self.optionsBox.setDisabled(False)
self.selection()
else:
self.sample = None
self.otherdata = None
self.optionsBox.setDisabled(True)
self.infoa.setText(
'No data on input yet, waiting to get something.')
self.infob.setText('')
self.infoc.setText('')
self.infod.setText('')
self.commit()
def selection(self):
if self.dataset is None:
return
data_length = len(self.data)
n_selected = int(
numpy.ceil(len(self.dataset) * self.proportionEX / 100.))
size = np.ceil(self.proportionEX / 100 * data_length)
genes = len(self.dataset)
expressed = numpy.mean(genes)
indices = numpy.random.permutation(len(self.dataset))
indices_sample = indices[:n_selected]
indices_other = indices[n_selected:]
self.sample = size
self.otherdata = self.dataset[indices_other]
self.infoc.setText('%d Selected Genes in dataset' % self.sample)
self.infod.setText('%d Selected Genes in dataset' % size)
def commit(self):
self.Outputs.sample.send(self.sample)
self.Outputs.sample.send(self.otherdata)
def checkCommit(self):
if self.commitOnChange:
self.commit()
