def test_single_signal(self):
w = self.widgetClass
WidgetPreview(w).run(42)
w.int1.assert_called_with(42)
WidgetPreview(w).run(3.14)
w.float1.assert_called_with(3.14)
self.assertEqual(w.float2.call_count, 0)
with self.assertRaises(ValueError):
WidgetPreview(w).run("foo")
with self.assertRaises(ValueError):
WidgetPreview(w).run([])
def main_with_annotation():
from AnyQt.QtWidgets import QApplication
from OWNxFile import OWNxFile
app = QApplication([])
file_widget = OWNxFile()
file_widget.Outputs.network.send = WidgetPreview(OWNxSave).run
file_widget.open_net_file("../networks/leu_by_genesets.net")
def test_named_signals(self):
w = self.widgetClass
WidgetPreview(w).run(42, float2=2.7, str1="foo")
w.int1.assert_called_with(42)
self.assertEqual(w.float1.call_count, 0)
w.float2.assert_called_with(2.7)
w.str1.assert_called_with("foo")
self.assertEqual(w.str2.call_count, 0)
def test_find_handler_name(self):
previewer = WidgetPreview(self.widgetClass)
previewer.create_widget()
find_name = previewer._find_handler_name
self.assertEqual(find_name(42), "int1")
self.assertEqual(find_name(3.14), "float1")
self.assertRaises(ValueError, find_name, "foo")
self.assertRaises(ValueError, find_name, [])
self.assertRaises(ValueError, find_name, [42])
self.assertEqual(find_name([(42, 1)]), "int1")
self.assertEqual(find_name([(2, 1), (3, 2)]), "int1")
self.assertEqual(find_name([(42.4, 1)]), "float1")
self.assertEqual(find_name([(42.4, 1), (5.1, 1)]), "float1")
self.assertRaises(ValueError, find_name, [("foo", 1)])
self.assertRaises(ValueError, find_name, [])
def test_multiple_runs(self):
w = self.widgetClass
previewer = WidgetPreview(w)
previewer.run(42, no_exit=True)
w.int1(43)
previewer.send_signals([(44, 1), (45, 2)])
previewer.run(46, no_exit=True)
w.int1.assert_has_calls(
[call(42), call(43),
call(44, 1),
call(45, 2),
call(46)])
def main(): # pragma: no cover
from orangecontrib.network.network.readwrite import read_pajek
from os.path import join, dirname
from orangewidget.utils.widgetpreview import WidgetPreview
path = join(dirname(__file__), "..", "networks")
network = read_pajek(join(path, 'airtraffic.net'))
data = Table(join(path, 'airtraffic_items.tab'))
WidgetPreview(OWNxGroups).run(set_network=network, set_data=data)
def test_send_signals(self):
previewer = WidgetPreview(self.widgetClass)
previewer.create_widget()
widget = previewer.widget
previewer.send_signals(42)
widget.int1.assert_called_with(42)
widget.int1.reset_mock()
previewer.send_signals([(42, 1), (40, 2)],
str2="foo",
float1=[(3.14, 1), (5.1, 8)])
widget.int1.assert_has_calls([call(42, 1), call(40, 2)])
widget.str2.assert_called_with("foo")
widget.float1.assert_has_calls([call(3.14, 1), call(5.1, 8)])
def test_widget_is_shown_and_ran(self):
w = self.widgetClass
app.exec_.reset_mock()
previewer = WidgetPreview(w)
previewer.run()
w.show.assert_called()
w.show.reset_mock()
app.exec_.assert_called()
app.exec_.reset_mock()
w.saveSettings.assert_called()
w.saveSettings.reset_mock()
sys.exit.assert_called()
sys.exit.reset_mock()
self.assertIsNone(previewer.widget)
previewer.run(no_exit=True)
w.show.assert_called()
w.show.reset_mock()
app.exec_.assert_called()
app.exec_.reset_mock()
w.saveSettings.assert_not_called()
sys.exit.assert_not_called()
self.assertIsNotNone(previewer.widget)
widget = previewer.widget
previewer.run(no_exec=True, no_exit=True)
w.show.assert_not_called()
app.exec_.assert_not_called()
w.saveSettings.assert_not_called()
sys.exit.assert_not_called()
self.assertIs(widget, previewer.widget)
previewer.run(no_exec=True)
w.show.assert_not_called()
app.exec_.assert_not_called()
w.saveSettings.assert_called()
sys.exit.assert_called()
self.assertIsNone(previewer.widget)
def commit(self):
if not self.graph.selection:
self.Outputs.selected_data.send(None)
return
time, _ = self.data.get_column_view(self.time_var)
if self.group_var is None:
time_interval = self.graph.selection[0].x
start, end = time_interval[0], time_interval[-1]
selection = np.argwhere((time >= start)
& (time <= end)).reshape(-1).astype(int)
else:
selection = []
group, _ = self.data.get_column_view(self.group_var)
for group_id, time_interval in self.graph.selection.items():
start, end = time_interval.x[0], time_interval.x[-1]
selection += (np.argwhere((time >= start) & (time <= end) & (
group == group_id)).reshape(-1).astype(int).tolist())
selection = sorted(selection)
self.Outputs.selected_data.send(self.data[selection, :])
def sizeHint(self):
return QSize(1280, 620)
if __name__ == "__main__":
from orangewidget.utils.widgetpreview import WidgetPreview
WidgetPreview(OWKaplanMeier).run(Table('iris'))
self.cancel_button.setDisabled(True)
if isinstance(ex, EmbeddingConnectionError):
self.Error.no_connection()
else:
self.Error.unexpected_error(type(ex).__name__)
self.cancel()
self.clear_outputs()
def cancel(self):
self.cancel_button.setDisabled(True)
super().cancel()
def _send_output_signals(self, embeddings, skipped):
self.Outputs.new_corpus.send(embeddings)
self.Outputs.skipped.send(skipped)
unsuccessful = len(skipped) if skipped else 0
if unsuccessful > 0:
self.Warning.unsuccessful_embeddings()
def clear_outputs(self):
self._send_output_signals(None, None)
def onDeleteWidget(self):
self.cancel()
super().onDeleteWidget()
if __name__ == '__main__':
from orangewidget.utils.widgetpreview import WidgetPreview
WidgetPreview(OWDocumentEmbedding).run(Corpus.from_file('book-excerpts'))
def on_done(self, result: Any) -> None:
self._task_state = "waiting"
self.button.setText("Start")
network = result[0]
self._send_output_signals(result)
nodes = network.number_of_nodes()
edges = network.number_of_edges()
summary = "{} / {}".format(nodes, edges)
directed = "Directed" if network.edges[0].directed else "Undirected"
details = "{} network with {} nodes and {} edges.".format(
directed, nodes, edges)
self.info.set_output_summary(summary, details)
def on_partial_result(self, result: Any):
self.cancel()
def on_exception(self, ex: Exception):
self.Error.unexpected_error(type(ex).__name__)
self.cancel()
def onDeleteWidget(self):
del self._corpus_to_network
super().onDeleteWidget()
if __name__ == "__main__":
from orangewidget.utils.widgetpreview import WidgetPreview
WidgetPreview(OWCorpusToNetwork).run(Corpus.from_file("book-excerpts"))
self.view.selectionModel().select(selection,
QItemSelectionModel.ClearAndSelect)
if __name__ == "__main__":
from orangewidget.utils.widgetpreview import WidgetPreview
from orangecontrib.text import preprocess
corpus = Corpus.from_file("book-excerpts")
# corpus.set_title_variable("Text")
pp_list = [
preprocess.LowercaseTransformer(),
preprocess.StripAccentsTransformer(),
preprocess.SnowballStemmer(),
]
for p in pp_list:
corpus = p(corpus)
w = StringVariable("Words")
w.attributes["type"] = "words"
words = ["house", "doctor", "boy", "way", "Rum"]
words = Table(
Domain([], metas=[w]),
np.empty((len(words), 0)),
metas=np.array(words).reshape((-1, 1)),
)
WidgetPreview(OWScoreDocuments).run(set_data=corpus, set_words=words)
callbacks=[self._progress_updater])
self._worker_thread = EmbedderThread(
lambda: self.embedder(self.network))
self._worker_thread.finished.connect(self.on_finished)
self.progressBarInit()
self.progressBarSet(1e-5)
self._worker_thread.start()
def on_finished(self):
output = self._worker_thread.result
self._worker_thread = None
self._progress_updater = None
self.progressBarFinished()
self.Outputs.items.send(output)
def onDeleteWidget(self):
if self._worker_thread is not None:
# prevent the callback from trying to access deleted widget object
self._progress_updater.widget = None
self._worker_thread.finished.disconnect()
self._worker_thread.quit()
super().onDeleteWidget()
if __name__ == "__main__":
from os.path import join, dirname
davis = join(dirname(__file__), "..", "networks", "davis.net")
network = readwrite.read_pajek(davis)
WidgetPreview(OWNxEmbedding).run(network)
super().closeEvent(event)
def closeContext(self) -> None:
"""
Gather configs in contextVariables and close context.
"""
if not self.features:
# only close in case of when features are not present if they are
# feature selection is defined by the input and context should
# not have impact
attrs, is_logit = [], []
for config in self.configs:
attrs.append(config.get_selection())
is_logit.append(config.is_logarithmic)
self.attrs = attrs
self.is_logit = is_logit
super().closeContext()
if __name__ == "__main__":
from orangecontrib.timeseries import ARIMA, VAR
airpassengers = Timeseries.from_file('airpassengers')
msft = airpassengers.interp()
model1 = ARIMA((3, 1, 1)).fit(airpassengers)
model2 = VAR(4).fit(msft)
ow = WidgetPreview(OWLineChart)
ow.run(set_data=airpassengers,
set_forecast=[(model1.predict(10, as_table=True), 0),
(model2.predict(10, as_table=True), 1)])
useful_vars[ididx] = False
return useful_vars
def _get_item_names(self, useful_vars):
return tuple(
var.name
for var, useful in zip(self.data.domain.attributes, useful_vars)
if useful)
def _prepare_domain(self, item_names, idnames=()):
idvar = self.idvar
if idvar is None:
idvar = ContinuousVariable(DEFAULT_NAME_FOR_ROW)
elif self.idvar.is_string:
idvar = DiscreteVariable(idvar.name, values=tuple(idnames))
# Renames without a warning: with only three columns, any intelligent
# user will realize why renaming
item_var_name, value_var_name = get_unique_names(
[idvar.name],
[self.item_var_name or DEFAULT_ITEM_NAME,
self.value_var_name or DEFAULT_VALUE_NAME]
)
item_var = DiscreteVariable(item_var_name, values=item_names)
value_var = ContinuousVariable(value_var_name)
return Domain([idvar, item_var], [value_var])
if __name__ == "__main__": # pragma: no cover
WidgetPreview(OWMelt).run(Table("zoo")[50:])
def cancel(self):
self.cancel_button.setDisabled(True)
super().cancel()
def _switch_to_local_embedder(self):
self.Warning.switched_local_embedder()
self.cb_embedder_current_id = self.embedders.index("squeezenet")
def _send_output_signals(self, result: Result) -> None:
self.Warning.images_skipped.clear()
self.Outputs.embeddings.send(result.embedding)
self.Outputs.skipped_images.send(result.skip_images)
if result.num_skipped != 0:
self.Warning.images_skipped(result.num_skipped)
self.set_output_data_summary(result.embedding, result.skip_images)
def clear_outputs(self):
self._send_output_signals(
Result(embedding=None, skpped_images=None, num_skipped=0))
def onDeleteWidget(self):
self.cancel()
super().onDeleteWidget()
if __name__ == "__main__":
from orangewidget.utils.widgetpreview import WidgetPreview
WidgetPreview(OWImageEmbedding).run(
Table("https://datasets.biolab.si/core/bone-healing.xlsx"))
# TODO: Allow having only a single (i.e. radial) axis
try:
ax2 = Spiralogram.AxesCategories[_enum_str(self.ax2, True)]
except KeyError:
ax2 = self.data.domain[self.ax2]
self.chart.setSeries(self.data, self.agg_attr, ax1, ax2, func)
def on_selection(self, indices):
self.indices = self.chart.selection_indices(indices)
self.commit()
def commit(self):
self.Outputs.time_series.send(
self.data[self.indices] if self.data else None)
@classmethod
def migrate_context(cls, context, version):
if version < 2:
values = context.values
context.values["agg_attr"] = values["agg_attr"][0][0]
_, type = values["agg_attr"]
ind, pos = values["agg_func"]
if type == 101: # discrete variable is always Mode in old settings
context.values["agg_func"] = ('Mode', pos)
else:
context.values["agg_func"] = (list(AGG_OPTIONS)[ind], pos)
if __name__ == "__main__":
WidgetPreview(OWSpiralogram).run(Table.from_file('airpassengers'))
self.time_var = time_var_model[0] if len(time_var_model) else None
self.event_var = event_var_model[0] if len(event_var_model) else None
self.openContext(domain)
self.commit.now()
def as_survival_data(self, data: Table) -> Optional[Table]:
if not self.time_var or not self.event_var or not data:
return
class_vars = [self.time_var, self.event_var]
time_var = self.time_var
event_var = self.event_var
time_var.attributes[TIME_TO_EVENT_VAR] = TIME_VAR
event_var.attributes[TIME_TO_EVENT_VAR] = EVENT_VAR
metas = [meta for meta in data.domain.metas if meta not in class_vars]
domain = Domain(data.domain.attributes, metas=metas, class_vars=class_vars)
data = data.transform(domain)
return data
@gui.deferred
def commit(self) -> None:
self.Outputs.data.send(self.as_survival_data(self._data))
if __name__ == "__main__":
from orangewidget.utils.widgetpreview import WidgetPreview
WidgetPreview(OWAsSurvivalData).run(Table('http://datasets.biolab.si/core/melanoma.tab'))
def sel_changed(self):
self.query_controls = False
self.radiobox.setDisabled(not self.query_controls)
self.out_box.setDisabled(not self.query_controls)
print("sds")
print(self.number)
self.ow_cache = 0
if self.lb_objects.count() == 0:
self.send("Object", None)
else:
self._executor.submit(self.get_deplyoment_info())
def get_deplyoment_info(self):
jsn_data = self.lb_objects.currentItem().data(Qt.UserRole)
url = self.BASE_URL + 'deployment/' + str(jsn_data["_id"])
resp = requests.get(url, headers={'content-type': 'application/json', 'accept': 'application/json'})
if resp.status_code == 200:
self.query_controls = True
self.radiobox.setDisabled(not self.query_controls)
self.out_box.setDisabled(not self.query_controls)
# print(resp.json().len)
if __name__ == "__main__": # pragma: no cover
WidgetPreview(UNSdata).run()
elif xprob is not None and yprob is not None:
prob = numpy.concatenate((xprob, yprob), axis=1)
else:
raise ValueError()
res = Orange.evaluation.Results()
res.data = x.data
res.domain = x.domain
res.learners = x.learners
res.row_indices = row_indices
res.actual = actual
res.predicted = predicted
res.folds = None
if prob is not None:
res.probabilities = prob
if x.models is not None and y.models is not None:
res.models = [xm + ym for xm, ym in zip(x.models, y.models)]
nmodels = predicted.shape[0]
xfailed = getattr(x, "failed", None) or [False] * nmodels
yfailed = getattr(y, "failed", None) or [False] * nmodels
assert len(xfailed) == len(yfailed)
res.failed = [xe or ye for xe, ye in zip(xfailed, yfailed)]
return res
if __name__ == "__main__":
WidgetPreview(OWLearningCurveB).run()
path.addRect(rect)
self.setSelectionArea(path)
self.selectionChanged.emit(set(self.selectedItems()), modifiers)
def updateSelectionRect(self, event):
pos = event.scenePos()
buttonDownPos = event.buttonDownScenePos(Qt.LeftButton)
rect = QRectF(pos, buttonDownPos).normalized()
rect = rect.intersected(self.sceneRect())
if not self.selectionRect:
self.selectionRect = QGraphicsRectItem()
self.selectionRect.setBrush(QColor(10, 10, 10, 20))
self.selectionRect.setPen(QPen(QColor(200, 200, 200, 200)))
self.addItem(self.selectionRect)
self.selectionRect.setRect(rect)
self.selectionRectPointChanged.emit(pos)
if __name__ == "__main__":
from Orange.data import Table
from orangecontrib.imageanalytics.image_embedder import ImageEmbedder
from orangewidget.utils.widgetpreview import WidgetPreview
embedding, _, _ = ImageEmbedder(model="squeezenet")(
Table("https://datasets.biolab.si/core/bone-healing.xlsx"),
col="Image")
WidgetPreview(OWImageGrid).run(embedding)
self.n_types = ''
def commit(self):
selected_docs = sorted(set(self.model.word_index[row][0]
for row in self.selected_rows))
concordance = self.model.get_data()
if selected_docs:
selected = self.corpus[selected_docs]
self.Outputs.selected_documents.send(selected)
else:
self.Outputs.selected_documents.send(None)
self.Outputs.concordances.send(concordance)
def send_report(self):
view = self.conc_view
model = self.conc_view.model()
self.report_items("Concordances", (
("Query", model.word),
("Tokens", model.n_tokens),
("Types", model.n_types),
("Matching", self.n_matching),
))
self.report_table(view)
if __name__ == "__main__": # pragma: no cover
from orangewidget.utils.widgetpreview import WidgetPreview
corpus = Corpus.from_file("book-excerpts")[:3]
WidgetPreview(OWConcordance).run(corpus)
def on_changed(self):
self.commit()
def commit(self):
self.Warning.no_transforms_added.clear()
data = self.data
if not data:
self.Outputs.time_series.send(None)
return
if not len(self.table_model):
self.Warning.no_transforms_added()
self.Outputs.time_series.send(None)
return
ts = moving_transform(data, self.table_model, self.non_overlapping and self.fixed_wlen)
self.Outputs.time_series.send(ts)
if __name__ == "__main__":
data = Timeseries.from_file('airpassengers')
attrs = [var.name for var in data.domain.attributes]
if 'Adj Close' in attrs:
# Make Adjusted Close a class variable
attrs.remove('Adj Close')
data = Timeseries.from_table(
Domain(attrs, [data.domain['Adj Close']], None, source=data.domain),
data)
WidgetPreview(OWMovingTransform).run(data)
file_format=recent.file_format)
resolved = recent.resolve(search_paths)
if resolved is not None:
rec.append(
RecentPath.create(resolved.abspath, search_paths,
**kwargs))
else:
rec.append(recent)
# change the list in-place for the case the widgets wraps this list
self.recent_paths[:] = rec
def workflowEnvChanged(self, key, value, oldvalue):
"""
Function called when environment changes (e.g. while saving the scheme)
It make sure that all environment connected values are modified
(e.g. relative file paths are changed)
"""
self.__initRecentItemsModel()
class UserInterruptError(BaseException):
"""
A BaseException subclass used for cooperative task/thread cancellation
"""
pass
if __name__ == "__main__":
from orangewidget.utils.widgetpreview import WidgetPreview
WidgetPreview(OWImportImages).run()
domain = Domain(attrs, metas=metas)
table = Table(domain, df_exp.to_numpy(), metas=x_metas)
state.set_progress_value(next(progress_steps_download))
state.set_status('Matching genes ...')
progress_steps_gm = iter(
np.linspace(50, 99, len(coll_table.gene_ids)))
def gm_callback():
state.set_progress_value(next(progress_steps_gm))
tax_id = species_name_to_taxid(species)
gm = GeneMatcher(tax_id, progress_callback=gm_callback)
table = gm.match_table_attributes(table, rename=True)
table.attributes[TableAnnotation.tax_id] = tax_id
table.attributes[TableAnnotation.gene_as_attr_name] = True
table.attributes[TableAnnotation.gene_id_attribute] = 'Entrez ID'
self.data_table = table
state.set_status('Normalizing ...')
table = self.normalize(table)
state.set_progress_value(100)
return table
if __name__ == "__main__":
from orangewidget.utils.widgetpreview import WidgetPreview
WidgetPreview(OWGenialisExpressions).run()
def main_without_annotation():
net = readwrite.read_pajek("../networks/leu_by_genesets.net")
WidgetPreview(OWNxSave).run(net)
# Helper methods
def get_selected_attributes(self):
"""Get select attributes in the table"""
selection_model = self.agg_table_view.selectionModel()
sel_rows = selection_model.selectedRows()
vars_ = self.data.domain.variables + self.data.domain.metas
return [vars_[index.row()] for index in sel_rows]
def _set_gb_selection(self) -> None:
"""Set selection in groupby list according to self.gb_attrs"""
sm = self.gb_attrs_view.selectionModel()
values = self.gb_attrs_model[:]
with disconnected(sm.selectionChanged, self.__gb_changed):
for val in self.gb_attrs:
index = values.index(val)
model_index = self.gb_attrs_model.index(index, 0)
sm.select(model_index, QItemSelectionModel.Select)
@staticmethod
def __aggregation_compatible(agg, attr):
"""Check a compatibility of aggregation with the variable"""
return type(attr) in AGGREGATIONS[agg].types
if __name__ == "__main__":
# pylint: disable=ungrouped-imports
from orangewidget.utils.widgetpreview import WidgetPreview
WidgetPreview(OWGroupBy).run(Table("iris"))
("Matches", self.n_matches)
))
def showEvent(self, event):
super().showEvent(event)
self.update_splitter()
def update_splitter(self):
"""
Update splitter that document list on the left never take more
than 1/3 of the space. It is only set on showEvent. If user
later changes sizes it stays as it is.
"""
w1, w2 = self.splitter.sizes()
ws = w1 + w2
if w2 < 2/3 * ws:
self.splitter.setSizes([ws * 1/3, ws * 2/3])
if __name__ == '__main__':
from orangecontrib.text.preprocess import BASE_TOKENIZER
from orangecontrib.text.tag.pos import AveragedPerceptronTagger
from orangewidget.utils.widgetpreview import WidgetPreview
corpus = Corpus.from_file('book-excerpts')
corpus = corpus[:3]
tagger = AveragedPerceptronTagger()
tagged_corpus = tagger(BASE_TOKENIZER(corpus))
tagged_corpus.ngram_range = (1, 2)
WidgetPreview(OWCorpusViewer).run(tagged_corpus)
if (result_corpus is
None # probably because of rate error at beginning
# or fewer tweets than expected
or self.mode == self.CONTENT
and len(result_corpus) < self.max_tweets or
self.mode == self.AUTHOR
# for authors, we expect self.max_tweets for each author
and
len(result_corpus) < self.max_tweets * len(self.word_list)):
self.Info.nut_enough_tweets()
self.Outputs.corpus.send(result_corpus)
def on_exception(self, ex):
self.search_button.setText("Search")
if isinstance(ex, NoAuthorError):
self.Error.wrong_author(str(ex))
else:
self.Error.api_error(str(ex))
def on_partial_result(self, _):
pass
@gui_require("api", "key_missing")
def send_report(self):
for task in self.api.search_history:
self.report_items(task)
if __name__ == "__main__":
WidgetPreview(OWTwitter).run()
mime_data = src_model.mimeData(selected_items)
# remove nodes from the source view
src_model.remove_node_list(selected_items)
dst_model.dropMimeData(mime_data, Qt.MoveAction, -1, -1)
@staticmethod
def _selected_rows(view: TreeView) -> List[QModelIndex]:
"""
Return the selected rows in the view.
"""
rows = view.selectionModel().selectedRows()
return list(map(view.model().mapToSource, rows))
@classmethod
def migrate_settings(cls, settings, version=0):
def migrate_to_version_2():
settings["selected_source"] = settings.pop("selected_db_source", "")
settings["selected_organism"] = settings.pop("selected_group", "")
if "context_settings" in settings:
for co in settings["context_settings"]:
co.values["selected_genes"] = [g[0] + g[1] for g in co.values["selected_genes"]]
if version < 2:
migrate_to_version_2()
if __name__ == "__main__":
from orangewidget.utils.widgetpreview import WidgetPreview
WidgetPreview(OWMarkerGenes).run()
