class AddTracUI(QWidget):
def __init__(self, parent):
super(AddTracUI, self).__init__()
self.title = 'Create TracControl Element'
self.setLayout(QVBoxLayout(self))
self.parent = parent
self.trac = Trac(name='', outputPin=0, enabled=False, icon=Config.icon('tracControl', 'rearDiff'), momentary=False)
self._nameControl = LineEdit('Name', self)
self._nameControl.kb.connect(self.showOSK)
self._outputPinControlLabel = QLabel('Output Pin', self)
self._outputPinControl = QComboBox(self)
for _pin in self.parent.availablePins():
self._outputPinControl.addItem(str(_pin))
self._outputPinControl.setCurrentIndex(self._outputPinControl.findText(str(self.trac.outputPin)))
self._enabledControl = QCheckBox('Enabled', self)
self._iconControlLabel = QLabel('Icon', self)
self._iconControl = QComboBox(self)
for _key in Config.icons['tracControl'].keys():
icon = Config.icon('tracControl', _key)
self._iconControl.addItem(icon['name'], _key)
self._iconControl.setItemIcon(self._iconControl.count() - 1, QIcon(icon['path']))
self._addTracBtn = QPushButton('Add TracControl Element', self)
self._addTracBtn.clicked.connect(self.__createTracBtnAction)
self._cancelBtn = QPushButton('Cancel', self)
self._cancelBtn.clicked.connect(self.__cancel)
_layout = [
['_nameControl'],
['_outputPinControlLabel', '_outputPinControl'],
['_enabledControl'],
['_iconControlLabel', '_iconControl'],
['_addTracBtn', '_cancelBtn']
]
for _list in _layout:
_panel = QWidget(self)
_panel.setLayout(QHBoxLayout(_panel))
_panel.layout().setAlignment(Qt.AlignCenter)
for _control in _list:
_panel.layout().addWidget(eval('self.%s' % _control))
self.layout().addWidget(_panel)
def __createTracBtnAction(self):
self.trac.name = self._nameControl.text()
self.trac.outputPin = int(self._outputPinControl.currentText())
self.trac.enabled = self._enabledControl.isChecked()
self.trac.icon = self._iconControl.currentData()
self.parent.tracs.addTrac(self.trac)
self.parent.tracs.save()
self.parent.loadUI('config_trac')
self.parent.enableConfigButtons()
def __cancel(self):
self.parent.loadUI('config_trac')
self.parent.enableConfigButtons()
def showOSK(self):
self.window().dock.show()
self.window().osk.rWidget = self._nameControl
class ControlCombo(ControlBase, QWidget):
"""This class represents a wrapper to the combo box"""
def __init__(self, label='', default=None, helptext=None):
QWidget.__init__(self)
ControlBase.__init__(self, label, default, helptext)
##########################################################################
############ Functions ###################################################
##########################################################################
def init_form(self):
self._layout = QHBoxLayout()
self._combo = QComboBox(self.form)
if self._label is not None:
self._combolabel = QLabel(self.form)
self._layout.addWidget(self._combolabel)
self._combolabel.setAccessibleName('ControlCombo-label')
self.label = self._label
else:
self._combolabel = None
self._layout.addWidget(self._combo)
self.form.setLayout(self._layout)
self._combo.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Fixed)
self._layout.setContentsMargins(0, 0, 0, 0)
self.form.setContentsMargins(0, 0, 0, 0)
self.form.setMinimumHeight(38)
self.form.setMaximumHeight(38)
self.form.setSizePolicy(QSizePolicy.Preferred, QSizePolicy.Fixed)
self._combo.currentIndexChanged.connect(self._currentIndexChanged)
self._combo.activated.connect(self._activated)
self._combo.highlighted.connect(self._highlighted)
self._combo.editTextChanged.connect(self._editTextChanged)
self._items = {}
self._addingItem = False
def clear(self):
self._items = {}
self._value = None
self._combo.clear()
def add_item(self, label, value=None):
self._addingItem = True
if value is not None:
if not (value in self._items.values()):
self._combo.addItem(label)
else:
if not (label in self._items.keys()):
self._combo.addItem(label)
firstValue = False
if self._items == {}:
firstValue = True
if value is None:
self._items[str(label)] = label
else:
self._items[str(label)] = value
self._addingItem = False
if firstValue:
self.value = self._items[label]
def __add__(self, val):
if isinstance(val, tuple):
self.add_item(val[0], val[1])
else:
self.add_item(val)
return self
def get_item_index_by_name(self, item_name):
"""
Returns the index of the item containing the given name
:param item_name: item name in combo box
:type item_name: string
"""
return self._combo.findText(item_name)
def count(self):
return self._combo.count()
def show(self):
"""
Show the control
"""
QWidget.show(self)
def hide(self):
"""
Hide the control
"""
QWidget.hide(self)
##########################################################################
############ Events ######################################################
##########################################################################
def current_index_changed_event(self, index):
"""Called when the user chooses an item in the combobox and
the selected choice is different from the last one selected.
@index: item's index
"""
pass
def activated_event(self, index):
"""Called when the user chooses an item in the combobox.
Note that this signal happens even when the choice is not changed
@index: item's index
"""
pass
def highlighted_event(self, index):
pass
def edittext_changed_event(self, text):
pass
##########################################################################
############ PROPERTIES ##################################################
##########################################################################
@property
def form(self):
return self
@property
def current_index(self):
return self._combo.currentIndex()
@current_index.setter
def current_index(self, value):
self._combo.setCurrentIndex(value)
@property
def items(self):
return self._items.items()
@property
def value(self):
return self._value
@value.setter
def value(self, value):
for key, val in self.items:
if value == val:
index = self._combo.findText(key)
self._combo.setCurrentIndex(index)
if self._value != value:
self.changed_event()
self._value = val
@property
def text(self):
return str(self._combo.currentText())
@text.setter
def text(self, value):
for key, val in self.items:
if value == key:
self.value = val
break
@property
def label(self):
if self._combolabel:
return self._combolabel.text()
else:
return None
@label.setter
def label(self, value):
"""
Label of the control, if applies
@type value: string
"""
if self._combolabel:
self._combolabel.setText(value)
##########################################################################
############ Private functions ###########################################
##########################################################################
def _activated(self, index):
if not self._addingItem:
item = self._combo.currentText()
if len(item) >= 1:
ControlBase.value.fset(self, self._items[str(item)])
self.activated_event(index)
def _highlighted(self, index):
"""Called when an item in the combobox popup
list is highlighted by the user.
@index: item's index
"""
self.highlighted_event(index)
def _editTextChanged(self, text):
self.edittext_changed_event(text)
def _currentIndexChanged(self, index):
if not self._addingItem:
item = self._combo.currentText()
if len(item) >= 1:
ControlBase.value.fset(self, self._items[str(item)])
self.current_index_changed_event(index)
class OWSql(OWWidget):
name = "SQL Table"
id = "orange.widgets.data.sql"
description = "Load data set from SQL."
icon = "icons/SQLTable.svg"
priority = 10
category = "Data"
keywords = ["data", "file", "load", "read"]
class Outputs:
data = Output(
"Data",
Table,
doc="Attribute-valued data set read from the input file.")
settings_version = 2
want_main_area = False
resizing_enabled = False
host = Setting(None)
port = Setting(None)
database = Setting(None)
schema = Setting(None)
username = ""
password = ""
table = Setting(None)
sql = Setting("")
guess_values = Setting(True)
download = Setting(False)
materialize = Setting(False)
materialize_table_name = Setting("")
class Information(OWWidget.Information):
data_sampled = Msg("Data description was generated from a sample.")
class Error(OWWidget.Error):
connection = Msg("{}")
no_backends = Msg("Please install a backend to use this widget")
missing_extension = Msg("Database is missing extension{}: {}")
def __init__(self):
super().__init__()
self.backend = None
self.data_desc_table = None
self.database_desc = None
vbox = gui.vBox(self.controlArea, "Server", addSpace=True)
box = gui.vBox(vbox)
self.backendmodel = BackendModel(Backend.available_backends())
self.backendcombo = QComboBox(box)
if len(self.backendmodel):
self.backendcombo.setModel(self.backendmodel)
else:
self.Error.no_backends()
box.setEnabled(False)
box.layout().addWidget(self.backendcombo)
self.servertext = QLineEdit(box)
self.servertext.setPlaceholderText('Server')
self.servertext.setToolTip('Server')
self.servertext.editingFinished.connect(self._load_credentials)
if self.host:
self.servertext.setText(self.host if not self.port else '{}:{}'.
format(self.host, self.port))
box.layout().addWidget(self.servertext)
self.databasetext = QLineEdit(box)
self.databasetext.setPlaceholderText('Database[/Schema]')
self.databasetext.setToolTip('Database or optionally Database/Schema')
if self.database:
self.databasetext.setText(
self.database if not self.schema else '{}/{}'.
format(self.database, self.schema))
box.layout().addWidget(self.databasetext)
self.usernametext = QLineEdit(box)
self.usernametext.setPlaceholderText('Username')
self.usernametext.setToolTip('Username')
box.layout().addWidget(self.usernametext)
self.passwordtext = QLineEdit(box)
self.passwordtext.setPlaceholderText('Password')
self.passwordtext.setToolTip('Password')
self.passwordtext.setEchoMode(QLineEdit.Password)
box.layout().addWidget(self.passwordtext)
self._load_credentials()
tables = gui.hBox(box)
self.tablemodel = TableModel()
self.tablecombo = QComboBox(
minimumContentsLength=35,
sizeAdjustPolicy=QComboBox.AdjustToMinimumContentsLength)
self.tablecombo.setModel(self.tablemodel)
self.tablecombo.setToolTip('table')
tables.layout().addWidget(self.tablecombo)
self.tablecombo.activated[int].connect(self.select_table)
self.connectbutton = gui.button(tables,
self,
'↻',
callback=self.connect)
self.connectbutton.setSizePolicy(QSizePolicy.Fixed, QSizePolicy.Fixed)
tables.layout().addWidget(self.connectbutton)
self.custom_sql = gui.vBox(box)
self.custom_sql.setVisible(False)
self.sqltext = QTextEdit(self.custom_sql)
self.sqltext.setPlainText(self.sql)
self.custom_sql.layout().addWidget(self.sqltext)
mt = gui.hBox(self.custom_sql)
cb = gui.checkBox(mt, self, 'materialize', 'Materialize to table ')
cb.setToolTip('Save results of the query in a table')
le = gui.lineEdit(mt, self, 'materialize_table_name')
le.setToolTip('Save results of the query in a table')
self.executebtn = gui.button(self.custom_sql,
self,
'Execute',
callback=self.open_table)
box.layout().addWidget(self.custom_sql)
gui.checkBox(box,
self,
"guess_values",
"Auto-discover discrete variables",
callback=self.open_table)
gui.checkBox(box,
self,
"download",
"Download data to local memory",
callback=self.open_table)
gui.rubber(self.buttonsArea)
QTimer.singleShot(0, self.connect)
def _load_credentials(self):
self._parse_host_port()
cm = self._credential_manager(self.host, self.port)
self.username = cm.username
self.password = cm.password
if self.username:
self.usernametext.setText(self.username)
if self.password:
self.passwordtext.setText(self.password)
def _save_credentials(self):
cm = self._credential_manager(self.host, self.port)
cm.username = self.username
cm.password = self.password
def _credential_manager(self, host, port):
return CredentialManager("SQL Table: {}:{}".format(host, port))
def error(self, id=0, text=""):
super().error(id, text)
err_style = 'QLineEdit {border: 2px solid red;}'
if 'server' in text or 'host' in text:
self.servertext.setStyleSheet(err_style)
else:
self.servertext.setStyleSheet('')
if 'role' in text:
self.usernametext.setStyleSheet(err_style)
else:
self.usernametext.setStyleSheet('')
if 'database' in text:
self.databasetext.setStyleSheet(err_style)
else:
self.databasetext.setStyleSheet('')
def _parse_host_port(self):
hostport = self.servertext.text().split(':')
self.host = hostport[0]
self.port = hostport[1] if len(hostport) == 2 else None
def connect(self):
self._parse_host_port()
self.database, _, self.schema = self.databasetext.text().partition('/')
self.username = self.usernametext.text() or None
self.password = self.passwordtext.text() or None
try:
if self.backendcombo.currentIndex() < 0:
return
backend = self.backendmodel[self.backendcombo.currentIndex()]
self.backend = backend(
dict(host=self.host,
port=self.port,
database=self.database,
user=self.username,
password=self.password))
self.Error.connection.clear()
self._save_credentials()
self.database_desc = OrderedDict(
(("Host", self.host), ("Port", self.port),
("Database", self.database), ("User name", self.username)))
self.refresh_tables()
self.select_table()
except BackendError as err:
error = str(err).split('\n')[0]
self.Error.connection(error)
self.database_desc = self.data_desc_table = None
self.tablecombo.clear()
def refresh_tables(self):
self.tablemodel.clear()
self.Error.missing_extension.clear()
if self.backend is None:
self.data_desc_table = None
return
self.tablemodel.append("Select a table")
self.tablemodel.extend(self.backend.list_tables(self.schema))
self.tablemodel.append("Custom SQL")
def select_table(self):
curIdx = self.tablecombo.currentIndex()
if self.tablecombo.itemText(curIdx) != "Custom SQL":
self.custom_sql.setVisible(False)
return self.open_table()
else:
self.custom_sql.setVisible(True)
self.data_desc_table = None
self.database_desc["Table"] = "(None)"
self.table = None
#self.Error.missing_extension(
# 's' if len(missing) > 1 else '',
# ', '.join(missing),
# shown=missing)
def open_table(self):
table = self.get_table()
self.data_desc_table = table
self.Outputs.data.send(table)
def get_table(self):
if self.tablecombo.currentIndex() <= 0:
if self.database_desc:
self.database_desc["Table"] = "(None)"
self.data_desc_table = None
return
if self.tablecombo.currentIndex() < self.tablecombo.count() - 1:
self.table = self.tablemodel[self.tablecombo.currentIndex()]
self.database_desc["Table"] = self.table
if "Query" in self.database_desc:
del self.database_desc["Query"]
else:
self.sql = self.table = self.sqltext.toPlainText()
if self.materialize:
import psycopg2
if not self.materialize_table_name:
self.Error.connection(
"Specify a table name to materialize the query")
return
try:
with self.backend.execute_sql_query(
"DROP TABLE IF EXISTS " +
self.materialize_table_name):
pass
with self.backend.execute_sql_query(
"CREATE TABLE " + self.materialize_table_name +
" AS " + self.table):
pass
with self.backend.execute_sql_query(
"ANALYZE " + self.materialize_table_name):
pass
self.table = self.materialize_table_name
except (psycopg2.ProgrammingError, BackendError) as ex:
self.Error.connection(str(ex))
return
try:
table = SqlTable(dict(host=self.host,
port=self.port,
database=self.database,
user=self.username,
password=self.password),
self.table,
backend=type(self.backend),
inspect_values=False)
except BackendError as ex:
self.Error.connection(str(ex))
return
self.Error.connection.clear()
sample = False
if table.approx_len() > LARGE_TABLE and self.guess_values:
confirm = QMessageBox(self)
confirm.setIcon(QMessageBox.Warning)
confirm.setText("Attribute discovery might take "
"a long time on large tables.\n"
"Do you want to auto discover attributes?")
confirm.addButton("Yes", QMessageBox.YesRole)
no_button = confirm.addButton("No", QMessageBox.NoRole)
sample_button = confirm.addButton("Yes, on a sample",
QMessageBox.YesRole)
confirm.exec()
if confirm.clickedButton() == no_button:
self.guess_values = False
elif confirm.clickedButton() == sample_button:
sample = True
self.Information.clear()
if self.guess_values:
QApplication.setOverrideCursor(QCursor(Qt.WaitCursor))
if sample:
s = table.sample_time(1)
domain = s.get_domain(inspect_values=True)
self.Information.data_sampled()
else:
domain = table.get_domain(inspect_values=True)
QApplication.restoreOverrideCursor()
table.domain = domain
if self.download:
if table.approx_len() > MAX_DL_LIMIT:
QMessageBox.warning(
self, 'Warning', "Data is too big to download.\n"
"Consider using the Data Sampler widget to download "
"a sample instead.")
self.download = False
elif table.approx_len() > AUTO_DL_LIMIT:
confirm = QMessageBox.question(
self, 'Question', "Data appears to be big. Do you really "
"want to download it to local memory?",
QMessageBox.Yes | QMessageBox.No, QMessageBox.No)
if confirm == QMessageBox.No:
self.download = False
if self.download:
table.download_data(MAX_DL_LIMIT)
table = Table(table)
return table
def send_report(self):
if not self.database_desc:
self.report_paragraph("No database connection.")
return
self.report_items("Database", self.database_desc)
if self.data_desc_table:
self.report_items("Data",
report.describe_data(self.data_desc_table))
@classmethod
def migrate_settings(cls, settings, version):
if version < 2:
# Until Orange version 3.4.4 username and password had been stored
# in Settings.
cm = cls._credential_manager(settings["host"], settings["port"])
cm.username = settings["username"]
cm.password = settings["password"]
class OWSql(OWWidget):
name = "SQL Table"
id = "orange.widgets.data.sql"
description = "Load data set from SQL."
icon = "icons/SQLTable.svg"
priority = 10
category = "Data"
keywords = ["data", "file", "load", "read"]
class Outputs:
data = Output("Data", Table, doc="Attribute-valued data set read from the input file.")
settings_version = 2
want_main_area = False
resizing_enabled = False
host = Setting(None)
port = Setting(None)
database = Setting(None)
schema = Setting(None)
username = ""
password = ""
table = Setting(None)
sql = Setting("")
guess_values = Setting(True)
download = Setting(False)
materialize = Setting(False)
materialize_table_name = Setting("")
class Information(OWWidget.Information):
data_sampled = Msg("Data description was generated from a sample.")
class Error(OWWidget.Error):
connection = Msg("{}")
no_backends = Msg("Please install a backend to use this widget")
missing_extension = Msg("Database is missing extension{}: {}")
def __init__(self):
super().__init__()
self.backend = None
self.data_desc_table = None
self.database_desc = None
vbox = gui.vBox(self.controlArea, "Server", addSpace=True)
box = gui.vBox(vbox)
self.backendmodel = BackendModel(Backend.available_backends())
self.backendcombo = QComboBox(box)
if len(self.backendmodel):
self.backendcombo.setModel(self.backendmodel)
else:
self.Error.no_backends()
box.setEnabled(False)
box.layout().addWidget(self.backendcombo)
self.servertext = QLineEdit(box)
self.servertext.setPlaceholderText('Server')
self.servertext.setToolTip('Server')
self.servertext.editingFinished.connect(self._load_credentials)
if self.host:
self.servertext.setText(self.host if not self.port else
'{}:{}'.format(self.host, self.port))
box.layout().addWidget(self.servertext)
self.databasetext = QLineEdit(box)
self.databasetext.setPlaceholderText('Database[/Schema]')
self.databasetext.setToolTip('Database or optionally Database/Schema')
if self.database:
self.databasetext.setText(
self.database if not self.schema else
'{}/{}'.format(self.database, self.schema))
box.layout().addWidget(self.databasetext)
self.usernametext = QLineEdit(box)
self.usernametext.setPlaceholderText('Username')
self.usernametext.setToolTip('Username')
box.layout().addWidget(self.usernametext)
self.passwordtext = QLineEdit(box)
self.passwordtext.setPlaceholderText('Password')
self.passwordtext.setToolTip('Password')
self.passwordtext.setEchoMode(QLineEdit.Password)
box.layout().addWidget(self.passwordtext)
self._load_credentials()
tables = gui.hBox(box)
self.tablemodel = TableModel()
self.tablecombo = QComboBox(
minimumContentsLength=35,
sizeAdjustPolicy=QComboBox.AdjustToMinimumContentsLength
)
self.tablecombo.setModel(self.tablemodel)
self.tablecombo.setToolTip('table')
tables.layout().addWidget(self.tablecombo)
self.tablecombo.activated[int].connect(self.select_table)
self.connectbutton = gui.button(
tables, self, '↻', callback=self.connect)
self.connectbutton.setSizePolicy(
QSizePolicy.Fixed, QSizePolicy.Fixed)
tables.layout().addWidget(self.connectbutton)
self.custom_sql = gui.vBox(box)
self.custom_sql.setVisible(False)
self.sqltext = QTextEdit(self.custom_sql)
self.sqltext.setPlainText(self.sql)
self.custom_sql.layout().addWidget(self.sqltext)
mt = gui.hBox(self.custom_sql)
cb = gui.checkBox(mt, self, 'materialize', 'Materialize to table ')
cb.setToolTip('Save results of the query in a table')
le = gui.lineEdit(mt, self, 'materialize_table_name')
le.setToolTip('Save results of the query in a table')
self.executebtn = gui.button(
self.custom_sql, self, 'Execute', callback=self.open_table)
box.layout().addWidget(self.custom_sql)
gui.checkBox(box, self, "guess_values",
"Auto-discover categorical variables",
callback=self.open_table)
gui.checkBox(box, self, "download",
"Download data to local memory",
callback=self.open_table)
gui.rubber(self.buttonsArea)
QTimer.singleShot(0, self.connect)
def _load_credentials(self):
self._parse_host_port()
cm = self._credential_manager(self.host, self.port)
self.username = cm.username
self.password = cm.password
if self.username:
self.usernametext.setText(self.username)
if self.password:
self.passwordtext.setText(self.password)
def _save_credentials(self):
cm = self._credential_manager(self.host, self.port)
cm.username = self.username
cm.password = self.password
def _credential_manager(self, host, port):
return CredentialManager("SQL Table: {}:{}".format(host, port))
def error(self, id=0, text=""):
super().error(id, text)
err_style = 'QLineEdit {border: 2px solid red;}'
if 'server' in text or 'host' in text:
self.servertext.setStyleSheet(err_style)
else:
self.servertext.setStyleSheet('')
if 'role' in text:
self.usernametext.setStyleSheet(err_style)
else:
self.usernametext.setStyleSheet('')
if 'database' in text:
self.databasetext.setStyleSheet(err_style)
else:
self.databasetext.setStyleSheet('')
def _parse_host_port(self):
hostport = self.servertext.text().split(':')
self.host = hostport[0]
self.port = hostport[1] if len(hostport) == 2 else None
def connect(self):
self._parse_host_port()
self.database, _, self.schema = self.databasetext.text().partition('/')
self.username = self.usernametext.text() or None
self.password = self.passwordtext.text() or None
try:
if self.backendcombo.currentIndex() < 0:
return
backend = self.backendmodel[self.backendcombo.currentIndex()]
self.backend = backend(dict(
host=self.host,
port=self.port,
database=self.database,
user=self.username,
password=self.password
))
self.Error.connection.clear()
self._save_credentials()
self.database_desc = OrderedDict((
("Host", self.host), ("Port", self.port),
("Database", self.database), ("User name", self.username)
))
self.refresh_tables()
self.select_table()
except BackendError as err:
error = str(err).split('\n')[0]
self.Error.connection(error)
self.database_desc = self.data_desc_table = None
self.tablecombo.clear()
def refresh_tables(self):
self.tablemodel.clear()
self.Error.missing_extension.clear()
if self.backend is None:
self.data_desc_table = None
return
self.tablemodel.append("Select a table")
self.tablemodel.extend(self.backend.list_tables(self.schema))
self.tablemodel.append("Custom SQL")
def select_table(self):
curIdx = self.tablecombo.currentIndex()
if self.tablecombo.itemText(curIdx) != "Custom SQL":
self.custom_sql.setVisible(False)
return self.open_table()
else:
self.custom_sql.setVisible(True)
self.data_desc_table = None
self.database_desc["Table"] = "(None)"
self.table = None
#self.Error.missing_extension(
# 's' if len(missing) > 1 else '',
# ', '.join(missing),
# shown=missing)
def open_table(self):
table = self.get_table()
self.data_desc_table = table
self.Outputs.data.send(table)
def get_table(self):
if self.tablecombo.currentIndex() <= 0:
if self.database_desc:
self.database_desc["Table"] = "(None)"
self.data_desc_table = None
return
if self.tablecombo.currentIndex() < self.tablecombo.count() - 1:
self.table = self.tablemodel[self.tablecombo.currentIndex()]
self.database_desc["Table"] = self.table
if "Query" in self.database_desc:
del self.database_desc["Query"]
else:
self.sql = self.table = self.sqltext.toPlainText()
if self.materialize:
import psycopg2
if not self.materialize_table_name:
self.Error.connection(
"Specify a table name to materialize the query")
return
try:
with self.backend.execute_sql_query("DROP TABLE IF EXISTS " +
self.materialize_table_name):
pass
with self.backend.execute_sql_query("CREATE TABLE " +
self.materialize_table_name +
" AS " + self.table):
pass
with self.backend.execute_sql_query("ANALYZE " + self.materialize_table_name):
pass
self.table = self.materialize_table_name
except (psycopg2.ProgrammingError, BackendError) as ex:
self.Error.connection(str(ex))
return
try:
table = SqlTable(dict(host=self.host,
port=self.port,
database=self.database,
user=self.username,
password=self.password),
self.table,
backend=type(self.backend),
inspect_values=False)
except BackendError as ex:
self.Error.connection(str(ex))
return
self.Error.connection.clear()
sample = False
if table.approx_len() > LARGE_TABLE and self.guess_values:
confirm = QMessageBox(self)
confirm.setIcon(QMessageBox.Warning)
confirm.setText("Attribute discovery might take "
"a long time on large tables.\n"
"Do you want to auto discover attributes?")
confirm.addButton("Yes", QMessageBox.YesRole)
no_button = confirm.addButton("No", QMessageBox.NoRole)
sample_button = confirm.addButton("Yes, on a sample",
QMessageBox.YesRole)
confirm.exec()
if confirm.clickedButton() == no_button:
self.guess_values = False
elif confirm.clickedButton() == sample_button:
sample = True
self.Information.clear()
if self.guess_values:
QApplication.setOverrideCursor(QCursor(Qt.WaitCursor))
if sample:
s = table.sample_time(1)
domain = s.get_domain(inspect_values=True)
self.Information.data_sampled()
else:
domain = table.get_domain(inspect_values=True)
QApplication.restoreOverrideCursor()
table.domain = domain
if self.download:
if table.approx_len() > MAX_DL_LIMIT:
QMessageBox.warning(
self, 'Warning', "Data is too big to download.\n"
"Consider using the Data Sampler widget to download "
"a sample instead.")
self.download = False
elif table.approx_len() > AUTO_DL_LIMIT:
confirm = QMessageBox.question(
self, 'Question', "Data appears to be big. Do you really "
"want to download it to local memory?",
QMessageBox.Yes | QMessageBox.No, QMessageBox.No)
if confirm == QMessageBox.No:
self.download = False
if self.download:
table.download_data(MAX_DL_LIMIT)
table = Table(table)
return table
def send_report(self):
if not self.database_desc:
self.report_paragraph("No database connection.")
return
self.report_items("Database", self.database_desc)
if self.data_desc_table:
self.report_items("Data",
report.describe_data(self.data_desc_table))
@classmethod
def migrate_settings(cls, settings, version):
if version < 2:
# Until Orange version 3.4.4 username and password had been stored
# in Settings.
cm = cls._credential_manager(settings["host"], settings["port"])
cm.username = settings["username"]
cm.password = settings["password"]
class EditTracUI(QWidget):
def __init__(self, trac, parent):
super(EditTracUI, self).__init__()
self.title = 'Edit TracControl Element'
self.setLayout(QVBoxLayout(self))
self.layout().setAlignment(Qt.AlignCenter)
self.parent = parent
self.trac = trac
# Init controls
self._nameControl = LineEdit('Name', self)
self._nameControl.setText(self.trac.name)
self._nameControl.kb.connect(self.showOSK)
self._outputPinControlLabel = QLabel('Output Pin', self)
self._outputPinControl = QComboBox(self)
for _pins in self.parent.availablePins():
self._outputPinControl.addItem(str(_pins))
for _i in range(self._outputPinControl.count()):
if self._outputPinControl.itemText(_i) == str(self.trac.outputPin):
self._outputPinControl.setCurrentIndex(_i)
break
self._enabledControl = QCheckBox('Enabled', self)
self._enabledControl.setChecked(self.trac.enabled)
self._iconControlLabel = QLabel('Icon Path', self)
self._iconControl = QComboBox(self)
for _key in Config.icons['tracControl'].keys():
icon = Config.icon('tracControl', _key)
self._iconControl.addItem(icon['name'], _key)
self._iconControl.setItemIcon(self._iconControl.count() - 1,
QIcon(icon['path']))
# Set combobox selection to icon variable
for iconIdx in range(self._iconControl.count()):
if self.trac.icon is not None and self._iconControl.itemData(
iconIdx) == self.trac.icon:
self._iconControl.setCurrentIndex(iconIdx)
break
self._saveBtn = QPushButton('Save', self)
self._saveBtn.clicked.connect(self.__saveBtnAction)
self._cancelBtn = QPushButton('Cancel', self)
self._cancelBtn.clicked.connect(self.__cancel)
_layout = [['_nameControl'],
['_outputPinControlLabel', '_outputPinControl'],
['_enabledControl'], ['_iconControlLabel', '_iconControl'],
['_saveBtn', '_cancelBtn']]
for _list in _layout:
_panel = QWidget(self)
_panel.setLayout(QHBoxLayout(_panel))
_panel.layout().setAlignment(Qt.AlignCenter)
for _ctrl in _list:
_panel.layout().addWidget(eval('self.%s' % _ctrl))
self.layout().addWidget(_panel)
def __saveBtnAction(self):
self.trac.name = self._nameControl.text()
self.trac.outputPin = int(self._outputPinControl.currentText())
self.trac.enabled = self._enabledControl.isChecked()
self.trac.icon = self._iconControl.currentData()
self.parent.tracs.save()
self.parent.loadUI('config_trac')
def __cancel(self):
self.parent.loadUI('config_trac')
def showOSK(self):
self.window().dock.show()
self.window().osk.rWidget = self._nameControl
class EditLightUI(QWidget):
def __init__(self, light, parent):
super(EditLightUI, self).__init__()
self.title = 'Edit Lighting Element'
self.parent = parent
self.light = light
self.setLayout(QVBoxLayout(self))
self.layout().setAlignment(Qt.AlignCenter)
# Init Name text control
self._nameControl = LineEdit('Name', self)
self._nameControl.setText(self.light.name)
self._nameControl.kb.connect(self.showOSK)
# Init Output Pin dropdown control
self._outputPinControlLabel = QLabel('Output Pin', self)
self._outputPinControl = QComboBox(self)
for x in self.parent.availablePins():
self._outputPinControl.addItem(str(x))
for i in range(self._outputPinControl.count()):
if self._outputPinControl.itemText(i) == str(self.light.outputPin):
self._outputPinControl.setCurrentIndex(i)
break
del x, i
# Init Enabled checkbox control and set value
self._enabledControl = QCheckBox('Enabled', self)
self._enabledControl.setChecked(self.light.enabled)
# Init Icon dropdown control
self._iconControlLabel = QLabel('Icon Path', self)
self._iconControl = QComboBox(self)
for key in Config.icons['lights'].keys():
icon = Config.icon('lights', key)
self._iconControl.addItem(icon['name'], key)
self._iconControl.setItemIcon(self._iconControl.count() - 1,
QIcon(icon['path']))
for i in range(self._iconControl.count()):
if self.light.icon is not None and self._iconControl.itemData(
i) == self.light.icon:
self._iconControl.setCurrentIndex(i)
break
del key, i
# Init Strobe checkbox control and set value
self._strobeControl = QCheckBox('Strobe', self)
self._strobeControl.setChecked(self.light.strobe)
# Init Save button
self._saveBtn = QPushButton('Save', self)
self._saveBtn.clicked.connect(self.__saveBtnAction)
# Init cancel button
self._cancelBtn = QPushButton('Cancel', self)
self._cancelBtn.clicked.connect(self.__cancel)
# Assign control layout
layoutList = [['_nameControl'],
['_outputPinControlLabel', '_outputPinControl'],
['_enabledControl', '_strobeControl'],
['_iconControlLabel', '_iconControl'],
['_saveBtn', '_cancelBtn']]
for l in layoutList:
panel = QWidget(self)
panel.setLayout(QHBoxLayout(panel))
panel.layout().setAlignment(Qt.AlignCenter)
for ctrl in l:
panel.layout().addWidget(eval('self.%s' % ctrl))
self.layout().addWidget(panel)
# Destroy local variables
del l, ctrl
def __saveBtnAction(self):
self.light.name = self._nameControl.text()
self.light.outputPin = int(self._outputPinControl.currentText())
self.light.enabled = self._enabledControl.isChecked()
self.light.icon = self._iconControl.currentData()
self.light.strobe = self._strobeControl.isChecked()
self.parent.lights.save()
self.parent.loadUI("config_light")
def __cancel(self):
self.parent.loadUI("config_light")
def showOSK(self):
self.window().dock.show()
self.window().osk.rWidget = self._nameControl
class EditOBAUI(QWidget):
def __init__(self, oba, parent):
super(EditOBAUI, self).__init__()
self.parent = parent
self.oba = oba
self.setLayout(QVBoxLayout(self))
self.layout().setAlignment(Qt.AlignCenter)
# Init Name text control
self._nameControl = LineEdit('Name', self)
self._nameControl.setText(self.oba.name)
self._nameControl.kb.connect(self.showOSK)
# Init Output Pin dropdown control
self._outputPinControlLabel = QLabel('Output Pin', self)
self._outputPinControl = QComboBox(self)
for _pin in self.parent.availablePins():
self._outputPinControl.addItem(str(_pin))
for _i in range(self._outputPinControl.count()):
if self._outputPinControl.itemText(_i) == str(self.oba.outputPin):
self._outputPinControl.setCurrentIndex(_i)
break
# Init Momentary checkbox control and set value
self._momentaryControl = QCheckBox('Momentary', self)
self._momentaryControl.setChecked(self.oba.momentary)
# Init Enabled checkbox control and set value
self._enabledControl = QCheckBox('Enabled', self)
self._enabledControl.setChecked(self.oba.enabled)
# Init Icon dropdown control
self._iconControlLabel = QLabel('Icon Path', self)
self._iconControl = QComboBox(self)
for _key in Config.icons['oba'].keys():
icon = Config.icon('oba', _key)
self._iconControl.addItem(icon['name'], _key)
self._iconControl.setItemIcon(self._iconControl.count() - 1,
QIcon(icon['path']))
for _i in range(self._iconControl.count()):
# Set current index if matching icon attribute
if self.oba.icon is not None and self._iconControl.itemData(
_i) == self.oba.icon:
self._iconControl.setCurrentIndex(_i)
break
# Init Save button
self._saveBtn = QPushButton('Save', self)
self._saveBtn.clicked.connect(self.__saveBtnAction)
# Init cancel button
self._cancelBtn = QPushButton('Cancel', self)
self._cancelBtn.clicked.connect(self.__cancel)
# Assign control layout
_layout = [['_nameControl'],
['_outputPinControlLabel', '_outputPinControl'],
['_momentaryControl', '_enabledControl'],
['_iconControlLabel', '_iconControl'],
['_saveBtn', '_cancelBtn']]
for _list in _layout:
_panel = QWidget(self)
_panel.setLayout(QHBoxLayout(_panel))
_panel.layout().setAlignment(Qt.AlignCenter)
_panel.layout().setSpacing(20)
for _control in _list:
_panel.layout().addWidget(eval('self.%s' % _control))
self.layout().addWidget(_panel)
def __saveBtnAction(self):
self.oba.name = self._nameControl.text()
self.oba.outputPin = int(self._outputPinControl.currentText())
self.oba.enabled = self._enabledControl.isChecked()
self.oba.icon = self._iconControl.currentData()
self.oba.momentary = self._momentaryControl.isChecked()
self.parent.obas.save()
self.parent.loadUI('config_oba')
def __cancel(self):
self.parent.loadUI('config_oba')
def showOSK(self):
self.window().dock.show()
self.window().osk.rWidget = self._nameControl
