def fix_size(self, content, extra=50):
"""
Adjusts the width and height of the file switcher,
based on its content.
"""
# Update size of dialog based on longest shortened path
strings = []
if content:
for rich_text in content:
label = QLabel(rich_text)
label.setTextFormat(Qt.PlainText)
strings.append(label.text())
fm = label.fontMetrics()
# Max width
max_width = max([fm.width(s) * 1.3 for s in strings])
self.list.setMinimumWidth(max_width + extra)
# Max height
if len(strings) < 8:
max_entries = len(strings)
else:
max_entries = 8
max_height = fm.height() * max_entries * 2.5
self.list.setMinimumHeight(max_height)
# Set position according to size
self.set_dialog_position()
def _drop_indicator_width(label: QLabel) -> float:
'''
Drop indicator width depending on the operating system for a given label
'''
if LINUX:
return 40.
return 3.0 * label.fontMetrics().height()
def fix_size(self, content, extra=50):
"""
Adjusts the width and height of the file switcher,
based on its content.
"""
# Update size of dialog based on longest shortened path
strings = []
if content:
for rich_text in content:
label = QLabel(rich_text)
label.setTextFormat(Qt.PlainText)
strings.append(label.text())
fm = label.fontMetrics()
# Max width
max_width = max([fm.width(s) * 1.3 for s in strings])
self.list.setMinimumWidth(max_width + extra)
# Max height
if len(strings) < 8:
max_entries = len(strings)
else:
max_entries = 8
max_height = fm.height() * max_entries * 2.5
self.list.setMinimumHeight(max_height)
# Set position according to size
self.set_dialog_position()
def create_drop_indicator_widget(self, area: DockWidgetArea,
mode: OverlayMode) -> QLabel:
'''
Create drop indicator widget
Parameters
----------
area : DockWidgetArea
mode : OverlayMode
Returns
-------
value : QLabel
'''
l = QLabel()
l.setObjectName("DockWidgetAreaLabel")
metric = 3.0 * l.fontMetrics().height()
size = QSizeF(metric, metric)
l.setPixmap(
self.create_high_dpi_drop_indicator_pixmap(size, area, mode))
l.setWindowFlags(Qt.Tool | Qt.FramelessWindowHint)
l.setAttribute(Qt.WA_TranslucentBackground)
l.setProperty("dockWidgetArea", area)
return l
def fix_size(self, content, extra=50):
"""Adjusts the width of the file switcher, based on the content."""
# Update size of dialog based on longest shortened path
strings = []
if content:
for rich_text in content:
label = QLabel(rich_text)
label.setTextFormat(Qt.PlainText)
strings.append(label.text())
fm = label.fontMetrics()
max_width = max([fm.width(s)*1.3 for s in strings])
self.list.setMinimumWidth(max_width + extra)
self.set_dialog_position()
def update_drop_indicator_icon(self, label: QLabel):
'''
Update drop indicator icon
Parameters
----------
drop_indicator_widget : QLabel
'''
metric = 3.0 * label.fontMetrics().height()
size = QSizeF(metric, metric)
area = label.property("dockWidgetArea")
label.setPixmap(
self.create_high_dpi_drop_indicator_pixmap(size, area, self.mode))
def get_item_size(self, content):
"""
Get the max size (width and height) for the elements of a list of
strings as a QLabel.
"""
strings = []
if content:
for rich_text in content:
label = QLabel(rich_text)
label.setTextFormat(Qt.PlainText)
strings.append(label.text())
fm = label.fontMetrics()
return (max([fm.width(s) * 1.3 for s in strings]), fm.height())
def get_item_size(self, content):
"""
Get the max size (width and height) for the elements of a list of
strings as a QLabel.
"""
strings = []
if content:
for rich_text in content:
label = QLabel(rich_text)
label.setTextFormat(Qt.PlainText)
strings.append(label.text())
fm = label.fontMetrics()
return (max([fm.width(s) * 1.3 for s in strings]), fm.height())
class HomeTab(WidgetBase):
"""Home applications tab."""
# name, prefix, sender
sig_item_selected = Signal(object, object, object)
# button_widget, sender
sig_channels_requested = Signal(object, object)
# application_name, command, prefix, leave_path_alone, sender
sig_launch_action_requested = Signal(object, object, bool, object, object)
# action, application_name, version, sender
sig_conda_action_requested = Signal(object, object, object, object)
# url
sig_url_clicked = Signal(object)
# TODO: Connect these signals to have more granularity
# [{'name': package_name, 'version': version}...], sender
sig_install_action_requested = Signal(object, object)
sig_remove_action_requested = Signal(object, object)
def __init__(self, parent=None):
"""Home applications tab."""
super(HomeTab, self).__init__(parent)
# Variables
self._parent = parent
self.api = AnacondaAPI()
self.applications = None
self.style_sheet = None
self.app_timers = None
self.current_prefix = None
# Widgets
self.list = ListWidgetApplication()
self.button_channels = ButtonHomeChannels('Channels')
self.button_refresh = ButtonHomeRefresh('Refresh')
self.combo = ComboHomeEnvironment()
self.frame_top = FrameTabHeader(self)
self.frame_body = FrameTabContent(self)
self.frame_bottom = FrameTabFooter(self)
self.label_home = LabelHome('Applications on')
self.label_status_action = QLabel('')
self.label_status = QLabel('')
self.progress_bar = QProgressBar()
self.first_widget = self.combo
# Widget setup
self.setObjectName('Tab')
self.progress_bar.setTextVisible(False)
self.list.setVerticalScrollBarPolicy(Qt.ScrollBarAlwaysOn)
# Layout
layout_top = QHBoxLayout()
layout_top.addWidget(self.label_home)
layout_top.addWidget(SpacerHorizontal())
layout_top.addWidget(self.combo)
layout_top.addWidget(SpacerHorizontal())
layout_top.addWidget(self.button_channels)
layout_top.addWidget(SpacerHorizontal())
layout_top.addStretch()
layout_top.addWidget(self.button_refresh)
self.frame_top.setLayout(layout_top)
layout_body = QVBoxLayout()
layout_body.addWidget(self.list)
self.frame_body.setLayout(layout_body)
layout_bottom = QHBoxLayout()
layout_bottom.addWidget(self.label_status_action)
layout_bottom.addWidget(SpacerHorizontal())
layout_bottom.addWidget(self.label_status)
layout_bottom.addStretch()
layout_bottom.addWidget(self.progress_bar)
self.frame_bottom.setLayout(layout_bottom)
layout = QVBoxLayout()
layout.addWidget(self.frame_top)
layout.addWidget(self.frame_body)
layout.addWidget(self.frame_bottom)
self.setLayout(layout)
# Signals
self.list.sig_conda_action_requested.connect(
self.sig_conda_action_requested)
self.list.sig_url_clicked.connect(self.sig_url_clicked)
self.list.sig_launch_action_requested.connect(
self.sig_launch_action_requested)
self.button_channels.clicked.connect(self.show_channels)
self.button_refresh.clicked.connect(self.refresh_cards)
self.progress_bar.setVisible(False)
# --- Setup methods
# -------------------------------------------------------------------------
def setup(self, conda_data):
"""Setup the tab content."""
conda_processed_info = conda_data.get('processed_info')
environments = conda_processed_info.get('__environments')
applications = conda_data.get('applications')
self.current_prefix = conda_processed_info.get('default_prefix')
self.set_environments(environments)
self.set_applications(applications)
def set_environments(self, environments):
"""Setup the environments list."""
# Disconnect to avoid triggering the signal when updating the content
try:
self.combo.currentIndexChanged.disconnect()
except TypeError:
pass
self.combo.clear()
for i, (env_prefix, env_name) in enumerate(environments.items()):
self.combo.addItem(env_name, env_prefix)
self.combo.setItemData(i, env_prefix, Qt.ToolTipRole)
index = 0
for i, (env_prefix, env_name) in enumerate(environments.items()):
if self.current_prefix == env_prefix:
index = i
break
self.combo.setCurrentIndex(index)
self.combo.currentIndexChanged.connect(self._item_selected)
def set_applications(self, applications):
"""Build the list of applications present in the current conda env."""
apps = self.api.process_apps(applications, prefix=self.current_prefix)
all_applications = []
installed_applications = []
not_installed_applications = []
# Check if some installed applications are not on the apps dict
# for example when the channel was removed.
linked_apps = self.api.conda_linked_apps_info(self.current_prefix)
missing_apps = [app for app in linked_apps if app not in apps]
for app in missing_apps:
apps[app] = linked_apps[app]
for app_name in sorted(list(apps.keys())):
app = apps[app_name]
item = ListItemApplication(name=app['name'],
description=app['description'],
versions=app['versions'],
command=app['command'],
image_path=app['image_path'],
prefix=self.current_prefix,
needs_license=app.get(
'needs_license', False))
if item.installed:
installed_applications.append(item)
else:
not_installed_applications.append(item)
all_applications = installed_applications + not_installed_applications
self.list.clear()
for i in all_applications:
self.list.addItem(i)
self.list.update_style_sheet(self.style_sheet)
self.set_widgets_enabled(True)
self.update_status()
# --- Other methods
# -------------------------------------------------------------------------
def current_environment(self):
"""Return the current selected environment."""
env_name = self.combo.currentText()
return self.api.conda_get_prefix_envname(env_name)
def refresh_cards(self):
"""Refresh application widgets.
List widget items sometimes are hidden on resize. This method tries
to compensate for that refreshing and repainting on user demand.
"""
self.list.update_style_sheet(self.style_sheet)
self.list.repaint()
for item in self.list.items():
if not item.widget.isVisible():
item.widget.repaint()
def show_channels(self):
"""Emit signal requesting the channels dialog editor."""
self.sig_channels_requested.emit(self.button_channels, C.TAB_HOME)
def update_list(self, name=None, version=None):
"""Update applications list."""
self.set_applications()
self.label_status.setVisible(False)
self.label_status_action.setVisible(False)
self.progress_bar.setVisible(False)
def update_versions(self, apps=None):
"""Update applications versions."""
self.items = []
for i in range(self.list.count()):
item = self.list.item(i)
self.items.append(item)
if isinstance(item, ListItemApplication):
name = item.name
meta = apps.get(name)
if meta:
versions = meta['versions']
version = self.api.get_dev_tool_version(item.path)
item.update_versions(version, versions)
# --- Common Helpers (# FIXME: factor out to common base widget)
# -------------------------------------------------------------------------
def _item_selected(self, index):
"""Notify that the item in combo (environment) changed."""
name = self.combo.itemText(index)
prefix = self.combo.itemData(index)
self.sig_item_selected.emit(name, prefix, C.TAB_HOME)
@property
def last_widget(self):
"""Return the last element of the list to be used in tab ordering."""
if self.list.items():
return self.list.items()[-1].widget
def ordered_widgets(self, next_widget=None):
"""Return a list of the ordered widgets."""
ordered_widgets = [
self.combo,
self.button_channels,
self.button_refresh,
]
ordered_widgets += self.list.ordered_widgets()
return ordered_widgets
def set_widgets_enabled(self, value):
"""Enable or disable widgets."""
self.combo.setEnabled(value)
self.button_channels.setEnabled(value)
self.button_refresh.setEnabled(value)
for item in self.list.items():
item.button_install.setEnabled(value)
item.button_options.setEnabled(value)
if value:
item.set_loading(not value)
def update_items(self):
"""Update status of items in list."""
if self.list:
for item in self.list.items():
item.update_status()
def update_status(self, action='', message='', value=None, max_value=None):
"""Update the application action status."""
# Elide if too big
width = QApplication.desktop().availableGeometry().width()
max_status_length = round(width * (2.0 / 3.0), 0)
msg_percent = 0.70
fm = self.label_status_action.fontMetrics()
action = fm.elidedText(action, Qt.ElideRight,
round(max_status_length * msg_percent, 0))
message = fm.elidedText(
message, Qt.ElideRight,
round(max_status_length * (1 - msg_percent), 0))
self.label_status_action.setText(action)
self.label_status.setText(message)
if max_value is None and value is None:
self.progress_bar.setVisible(False)
else:
self.progress_bar.setVisible(True)
self.progress_bar.setMaximum(max_value)
self.progress_bar.setValue(value)
def update_style_sheet(self, style_sheet=None):
"""Update custom CSS style sheet."""
if style_sheet is None:
self.style_sheet = load_style_sheet()
else:
self.style_sheet = style_sheet
self.list.update_style_sheet(style_sheet=self.style_sheet)
self.setStyleSheet(self.style_sheet)
class PylintWidget(PluginMainWidget):
"""
Pylint widget.
"""
DEFAULT_OPTIONS = {
"history_filenames": [],
"max_entries": 30,
"project_dir": None,
}
ENABLE_SPINNER = True
DATAPATH = get_conf_path("pylint.results")
VERSION = "1.1.0"
# --- Signals
sig_edit_goto_requested = Signal(str, int, str)
"""
This signal will request to open a file in a given row and column
using a code editor.
Parameters
----------
path: str
Path to file.
row: int
Cursor starting row position.
word: str
Word to select on given row.
"""
sig_start_analysis_requested = Signal()
"""
This signal will request the plugin to start the analysis. This is to be
able to interact with other plugins, which can only be done at the plugin
level.
"""
def __init__(self,
name=None,
plugin=None,
parent=None,
options=DEFAULT_OPTIONS):
super().__init__(name, plugin, parent, options)
# Attributes
self._process = None
self.output = None
self.error_output = None
self.filename = None
self.rdata = []
self.curr_filenames = self.get_option("history_filenames")
self.code_analysis_action = None
self.browse_action = None
# Widgets
self.filecombo = PythonModulesComboBox(self)
self.ratelabel = QLabel(self)
self.datelabel = QLabel(self)
self.treewidget = ResultsTree(self)
if osp.isfile(self.DATAPATH):
try:
with open(self.DATAPATH, "rb") as fh:
data = pickle.loads(fh.read())
if data[0] == self.VERSION:
self.rdata = data[1:]
except (EOFError, ImportError):
pass
# Widget setup
self.filecombo.setInsertPolicy(self.filecombo.InsertAtTop)
for fname in self.curr_filenames[::-1]:
self.set_filename(fname)
# Layout
layout = QVBoxLayout()
layout.addWidget(self.treewidget)
self.setLayout(layout)
# Signals
self.filecombo.valid.connect(self._check_new_file)
self.treewidget.sig_edit_goto_requested.connect(
self.sig_edit_goto_requested)
# --- Private API
# ------------------------------------------------------------------------
@Slot()
def _start(self):
"""Start the code analysis."""
self.start_spinner()
self.output = ""
self.error_output = ""
self._process = process = QProcess(self)
process.setProcessChannelMode(QProcess.SeparateChannels)
process.setWorkingDirectory(getcwd_or_home())
process.readyReadStandardOutput.connect(self._read_output)
process.readyReadStandardError.connect(
lambda: self._read_output(error=True))
process.finished.connect(
lambda ec, es=QProcess.ExitStatus: self._finished(ec, es))
command_args = self.get_command(self.get_filename())
processEnvironment = QProcessEnvironment()
processEnvironment.insert("PYTHONIOENCODING", "utf8")
# resolve spyder-ide/spyder#14262
if running_in_mac_app():
pyhome = os.environ.get("PYTHONHOME")
processEnvironment.insert("PYTHONHOME", pyhome)
process.setProcessEnvironment(processEnvironment)
process.start(sys.executable, command_args)
running = process.waitForStarted()
if not running:
self.stop_spinner()
QMessageBox.critical(
self,
_("Error"),
_("Process failed to start"),
)
def _read_output(self, error=False):
process = self._process
if error:
process.setReadChannel(QProcess.StandardError)
else:
process.setReadChannel(QProcess.StandardOutput)
qba = QByteArray()
while process.bytesAvailable():
if error:
qba += process.readAllStandardError()
else:
qba += process.readAllStandardOutput()
text = str(qba.data(), "utf-8")
if error:
self.error_output += text
else:
self.output += text
self.update_actions()
def _finished(self, exit_code, exit_status):
if not self.output:
self.stop_spinner()
if self.error_output:
QMessageBox.critical(
self,
_("Error"),
self.error_output,
)
print("pylint error:\n\n" + self.error_output, file=sys.stderr)
return
filename = self.get_filename()
rate, previous, results = self.parse_output(self.output)
self._save_history()
self.set_data(filename, (time.localtime(), rate, previous, results))
self.output = self.error_output + self.output
self.show_data(justanalyzed=True)
self.update_actions()
self.stop_spinner()
def _check_new_file(self):
fname = self.get_filename()
if fname != self.filename:
self.filename = fname
self.show_data()
def _is_running(self):
process = self._process
return process is not None and process.state() == QProcess.Running
def _kill_process(self):
self._process.kill()
self._process.waitForFinished()
self.stop_spinner()
def _update_combobox_history(self):
"""Change the number of files listed in the history combobox."""
max_entries = self.get_option("max_entries")
if self.filecombo.count() > max_entries:
num_elements = self.filecombo.count()
diff = num_elements - max_entries
for __ in range(diff):
num_elements = self.filecombo.count()
self.filecombo.removeItem(num_elements - 1)
self.filecombo.selected()
else:
num_elements = self.filecombo.count()
diff = max_entries - num_elements
for i in range(num_elements, num_elements + diff):
if i >= len(self.curr_filenames):
break
act_filename = self.curr_filenames[i]
self.filecombo.insertItem(i, act_filename)
def _save_history(self):
"""Save the current history filenames."""
if self.parent:
list_save_files = []
for fname in self.curr_filenames:
if _("untitled") not in fname:
list_save_files.append(fname)
self.curr_filenames = list_save_files[:MAX_HISTORY_ENTRIES]
self.set_option("history_filenames", self.curr_filenames)
else:
self.curr_filenames = []
# --- PluginMainWidget API
# ------------------------------------------------------------------------
def get_title(self):
return _("Code Analysis")
def get_focus_widget(self):
return self.treewidget
def setup(self, options):
change_history_depth_action = self.create_action(
PylintWidgetActions.ChangeHistory,
text=_("History..."),
tip=_("Set history maximum entries"),
icon=self.create_icon("history"),
triggered=self.change_history_depth,
)
self.code_analysis_action = self.create_action(
PylintWidgetActions.RunCodeAnalysis,
icon_text=_("Analyze"),
text=_("Run code analysis"),
tip=_("Run code analysis"),
icon=self.create_icon("run"),
triggered=lambda: self.sig_start_analysis_requested.emit(),
context=Qt.ApplicationShortcut,
register_shortcut=True)
self.browse_action = self.create_action(
PylintWidgetActions.BrowseFile,
text=_("Select Python file"),
tip=_("Select Python file"),
icon=self.create_icon("fileopen"),
triggered=self.select_file,
)
self.log_action = self.create_action(
PylintWidgetActions.ShowLog,
text=_("Output"),
icon_text=_("Output"),
tip=_("Complete output"),
icon=self.create_icon("log"),
triggered=self.show_log,
)
options_menu = self.get_options_menu()
self.add_item_to_menu(
self.treewidget.get_action(OneColumnTreeActions.CollapseAllAction),
menu=options_menu,
section=PylintWidgetOptionsMenuSections.Global,
)
self.add_item_to_menu(
self.treewidget.get_action(OneColumnTreeActions.ExpandAllAction),
menu=options_menu,
section=PylintWidgetOptionsMenuSections.Global,
)
self.add_item_to_menu(
self.treewidget.get_action(
OneColumnTreeActions.CollapseSelectionAction),
menu=options_menu,
section=PylintWidgetOptionsMenuSections.Section,
)
self.add_item_to_menu(
self.treewidget.get_action(
OneColumnTreeActions.ExpandSelectionAction),
menu=options_menu,
section=PylintWidgetOptionsMenuSections.Section,
)
self.add_item_to_menu(
change_history_depth_action,
menu=options_menu,
section=PylintWidgetOptionsMenuSections.History,
)
# Update OneColumnTree contextual menu
self.add_item_to_menu(
change_history_depth_action,
menu=self.treewidget.menu,
section=PylintWidgetOptionsMenuSections.History,
)
self.treewidget.restore_action.setVisible(False)
toolbar = self.get_main_toolbar()
for item in [
self.filecombo, self.browse_action, self.code_analysis_action
]:
self.add_item_to_toolbar(
item,
toolbar,
section=PylintWidgetMainToolBarSections.Main,
)
secondary_toolbar = self.create_toolbar("secondary")
for item in [
self.ratelabel,
self.create_stretcher(), self.datelabel,
self.create_stretcher(), self.log_action
]:
self.add_item_to_toolbar(
item,
secondary_toolbar,
section=PylintWidgetMainToolBarSections.Main,
)
self.show_data()
if self.rdata:
self.remove_obsolete_items()
self.filecombo.insertItems(0, self.get_filenames())
self.code_analysis_action.setEnabled(self.filecombo.is_valid())
else:
self.code_analysis_action.setEnabled(False)
# Signals
self.filecombo.valid.connect(self.code_analysis_action.setEnabled)
def on_option_update(self, option, value):
if option == "max_entries":
self._update_combobox_history()
elif option == "history_filenames":
self.curr_filenames = value
self._update_combobox_history()
def update_actions(self):
fm = self.ratelabel.fontMetrics()
toolbar = self.get_main_toolbar()
width = max([fm.width(_("Stop")), fm.width(_("Analyze"))])
widget = toolbar.widgetForAction(self.code_analysis_action)
if widget:
widget.setMinimumWidth(width * 1.5)
if self._is_running():
self.code_analysis_action.setIconText(_("Stop"))
self.code_analysis_action.setIcon(self.create_icon("stop"))
else:
self.code_analysis_action.setIconText(_("Analyze"))
self.code_analysis_action.setIcon(self.create_icon("run"))
self.remove_obsolete_items()
# --- Public API
# ------------------------------------------------------------------------
@Slot()
@Slot(int)
def change_history_depth(self, value=None):
"""
Set history maximum entries.
Parameters
----------
value: int or None, optional
The valur to set the maximum history depth. If no value is
provided, an input dialog will be launched. Default is None.
"""
if value is None:
dialog = QInputDialog(self)
# Set dialog properties
dialog.setModal(False)
dialog.setWindowTitle(_("History"))
dialog.setLabelText(_("Maximum entries"))
dialog.setInputMode(QInputDialog.IntInput)
dialog.setIntRange(MIN_HISTORY_ENTRIES, MAX_HISTORY_ENTRIES)
dialog.setIntStep(1)
dialog.setIntValue(self.get_option("max_entries"))
# Connect slot
dialog.intValueSelected.connect(
lambda value: self.set_option("max_entries", value))
dialog.show()
else:
self.set_option("max_entries", value)
def get_filename(self):
"""
Get current filename in combobox.
"""
return str(self.filecombo.currentText())
@Slot(str)
def set_filename(self, filename):
"""
Set current filename in combobox.
"""
if self._is_running():
self._kill_process()
# Don't try to reload saved analysis for filename, if filename
# is the one currently displayed.
# Fixes spyder-ide/spyder#13347
if self.get_filename() == filename:
return
filename = str(filename)
index, _data = self.get_data(filename)
if filename not in self.curr_filenames:
self.filecombo.insertItem(0, filename)
self.curr_filenames.insert(0, filename)
self.filecombo.setCurrentIndex(0)
else:
try:
index = self.filecombo.findText(filename)
self.filecombo.removeItem(index)
self.curr_filenames.pop(index)
except IndexError:
self.curr_filenames.remove(filename)
self.filecombo.insertItem(0, filename)
self.curr_filenames.insert(0, filename)
self.filecombo.setCurrentIndex(0)
num_elements = self.filecombo.count()
if num_elements > self.get_option("max_entries"):
self.filecombo.removeItem(num_elements - 1)
self.filecombo.selected()
def start_code_analysis(self, filename=None):
"""
Perform code analysis for given `filename`.
If `filename` is None default to current filename in combobox.
If this method is called while still running it will stop the code
analysis.
"""
if self._is_running():
self._kill_process()
else:
if filename is not None:
self.set_filename(filename)
if self.filecombo.is_valid():
self._start()
self.update_actions()
def stop_code_analysis(self):
"""
Stop the code analysis process.
"""
if self._is_running():
self._kill_process()
def remove_obsolete_items(self):
"""
Removing obsolete items.
"""
self.rdata = [(filename, data) for filename, data in self.rdata
if is_module_or_package(filename)]
def get_filenames(self):
"""
Return all filenames for which there is data available.
"""
return [filename for filename, _data in self.rdata]
def get_data(self, filename):
"""
Get and load code analysis data for given `filename`.
"""
filename = osp.abspath(filename)
for index, (fname, data) in enumerate(self.rdata):
if fname == filename:
return index, data
else:
return None, None
def set_data(self, filename, data):
"""
Set and save code analysis `data` for given `filename`.
"""
filename = osp.abspath(filename)
index, _data = self.get_data(filename)
if index is not None:
self.rdata.pop(index)
self.rdata.insert(0, (filename, data))
while len(self.rdata) > self.get_option("max_entries"):
self.rdata.pop(-1)
with open(self.DATAPATH, "wb") as fh:
pickle.dump([self.VERSION] + self.rdata, fh, 2)
def show_data(self, justanalyzed=False):
"""
Show data in treewidget.
"""
text_color = MAIN_TEXT_COLOR
prevrate_color = MAIN_PREVRATE_COLOR
if not justanalyzed:
self.output = None
self.log_action.setEnabled(self.output is not None
and len(self.output) > 0)
if self._is_running():
self._kill_process()
filename = self.get_filename()
if not filename:
return
_index, data = self.get_data(filename)
if data is None:
text = _("Source code has not been rated yet.")
self.treewidget.clear_results()
date_text = ""
else:
datetime, rate, previous_rate, results = data
if rate is None:
text = _("Analysis did not succeed "
"(see output for more details).")
self.treewidget.clear_results()
date_text = ""
else:
text_style = "<span style=\"color: %s\"><b>%s </b></span>"
rate_style = "<span style=\"color: %s\"><b>%s</b></span>"
prevrate_style = "<span style=\"color: %s\">%s</span>"
color = DANGER_COLOR
if float(rate) > 5.:
color = SUCCESS_COLOR
elif float(rate) > 3.:
color = WARNING_COLOR
text = _("Global evaluation:")
text = ((text_style % (text_color, text)) +
(rate_style % (color, ("%s/10" % rate))))
if previous_rate:
text_prun = _("previous run:")
text_prun = " (%s %s/10)" % (text_prun, previous_rate)
text += prevrate_style % (prevrate_color, text_prun)
self.treewidget.set_results(filename, results)
date = time.strftime("%Y-%m-%d %H:%M:%S", datetime)
date_text = text_style % (text_color, date)
self.ratelabel.setText(text)
self.datelabel.setText(date_text)
@Slot()
def show_log(self):
"""
Show output log dialog.
"""
if self.output:
output_dialog = TextEditor(self.output,
title=_("Code analysis output"),
parent=self,
readonly=True)
output_dialog.resize(700, 500)
output_dialog.exec_()
# --- Python Specific
# ------------------------------------------------------------------------
def get_pylintrc_path(self, filename):
"""
Get the path to the most proximate pylintrc config to the file.
"""
search_paths = [
# File"s directory
osp.dirname(filename),
# Working directory
getcwd_or_home(),
# Project directory
self.get_option("project_dir"),
# Home directory
osp.expanduser("~"),
]
return get_pylintrc_path(search_paths=search_paths)
@Slot()
def select_file(self, filename=None):
"""
Select filename using a open file dialog and set as current filename.
If `filename` is provided, the dialog is not used.
"""
if filename is None:
self.sig_redirect_stdio_requested.emit(False)
filename, _selfilter = getopenfilename(
self,
_("Select Python file"),
getcwd_or_home(),
_("Python files") + " (*.py ; *.pyw)",
)
self.sig_redirect_stdio_requested.emit(True)
if filename:
self.set_filename(filename)
self.start_code_analysis()
def get_command(self, filename):
"""
Return command to use to run code analysis on given filename
"""
command_args = []
if PYLINT_VER is not None:
command_args = [
"-m",
"pylint",
"--output-format=text",
"--msg-template="
'{msg_id}:{symbol}:{line:3d},{column}: {msg}"',
]
pylintrc_path = self.get_pylintrc_path(filename=filename)
if pylintrc_path is not None:
command_args += ["--rcfile={}".format(pylintrc_path)]
command_args.append(filename)
return command_args
def parse_output(self, output):
"""
Parse output and return current revious rate and results.
"""
# Convention, Refactor, Warning, Error
results = {"C:": [], "R:": [], "W:": [], "E:": []}
txt_module = "************* Module "
module = "" # Should not be needed - just in case something goes wrong
for line in output.splitlines():
if line.startswith(txt_module):
# New module
module = line[len(txt_module):]
continue
# Supporting option include-ids: ("R3873:" instead of "R:")
if not re.match(r"^[CRWE]+([0-9]{4})?:", line):
continue
items = {}
idx_0 = 0
idx_1 = 0
key_names = ["msg_id", "message_name", "line_nb", "message"]
for key_idx, key_name in enumerate(key_names):
if key_idx == len(key_names) - 1:
idx_1 = len(line)
else:
idx_1 = line.find(":", idx_0)
if idx_1 < 0:
break
item = line[(idx_0):idx_1]
if not item:
break
if key_name == "line_nb":
item = int(item.split(",")[0])
items[key_name] = item
idx_0 = idx_1 + 1
else:
pylint_item = (module, items["line_nb"], items["message"],
items["msg_id"], items["message_name"])
results[line[0] + ":"].append(pylint_item)
# Rate
rate = None
txt_rate = "Your code has been rated at "
i_rate = output.find(txt_rate)
if i_rate > 0:
i_rate_end = output.find("/10", i_rate)
if i_rate_end > 0:
rate = output[i_rate + len(txt_rate):i_rate_end]
# Previous run
previous = ""
if rate is not None:
txt_prun = "previous run: "
i_prun = output.find(txt_prun, i_rate_end)
if i_prun > 0:
i_prun_end = output.find("/10", i_prun)
previous = output[i_prun + len(txt_prun):i_prun_end]
return rate, previous, results
class FindInFilesWidget(PluginMainWidget):
"""
Find in files widget.
"""
DEFAULT_OPTIONS = {
'case_sensitive': False,
'exclude_case_sensitive': False,
'exclude': EXCLUDE_PATTERNS[0],
'exclude_index': None,
'exclude_regexp': False,
'path_history': [],
'max_results': 1000,
'hist_limit': MAX_PATH_HISTORY,
'more_options': False,
'search_in_index': None,
'search_text': '',
'search_text_regexp': False,
'supported_encodings': ("utf-8", "iso-8859-1", "cp1252"),
'text_color': MAIN_TEXT_COLOR,
}
REGEX_INVALID = "background-color:rgb(255, 80, 80);"
REGEX_ERROR = _("Regular expression error")
# Signals
sig_edit_goto_requested = Signal(str, int, str)
"""
This signal will request to open a file in a given row and column
using a code editor.
Parameters
----------
path: str
Path to file.
row: int
Cursor starting row position.
word: str
Word to select on given row.
"""
sig_finished = Signal()
"""
This signal is emitted to inform the search process has finished.
"""
sig_max_results_reached = Signal()
"""
This signal is emitted to inform the search process has finished due
to reaching the maximum number of results.
"""
def __init__(self,
name=None,
plugin=None,
parent=None,
options=DEFAULT_OPTIONS):
super().__init__(name, plugin, parent=parent, options=options)
# Attributes
self.text_color = self.get_option('text_color')
self.supported_encodings = self.get_option('supported_encodings')
self.search_thread = None
self.running = False
self.more_options_action = None
self.extras_toolbar = None
search_text = self.get_option('search_text')
path_history = self.get_option('path_history')
exclude = self.get_option('exclude')
if not isinstance(search_text, (list, tuple)):
search_text = [search_text]
if not isinstance(exclude, (list, tuple)):
exclude = [exclude]
if not isinstance(path_history, (list, tuple)):
path_history = [path_history]
# Widgets
self.search_text_edit = PatternComboBox(
self,
search_text,
_("Search pattern"),
)
self.search_label = QLabel(_('Search:'))
self.search_in_label = QLabel(_('Location:'))
self.exclude_label = QLabel(_('Exclude:'))
self.path_selection_combo = SearchInComboBox(path_history, self)
self.exclude_pattern_edit = PatternComboBox(
self,
exclude,
_("Exclude pattern"),
)
self.result_browser = ResultsBrowser(
self,
text_color=self.text_color,
max_results=self.get_option('max_results'),
)
# Setup
self.search_label.setBuddy(self.search_text_edit)
self.exclude_label.setBuddy(self.exclude_pattern_edit)
fm = self.search_label.fontMetrics()
base_size = int(fm.width(_('Location:')) * 1.2)
self.search_text_edit.setMinimumWidth(base_size * 6)
self.exclude_pattern_edit.setMinimumWidth(base_size * 6)
self.path_selection_combo.setMinimumWidth(base_size * 6)
self.search_label.setMinimumWidth(base_size)
self.search_in_label.setMinimumWidth(base_size)
self.exclude_label.setMinimumWidth(base_size)
exclude_idx = self.get_option('exclude_index')
if (exclude_idx is not None and exclude_idx >= 0
and exclude_idx < self.exclude_pattern_edit.count()):
self.exclude_pattern_edit.setCurrentIndex(exclude_idx)
search_in_index = self.get_option('search_in_index')
self.path_selection_combo.set_current_searchpath_index(search_in_index)
# Layout
layout = QHBoxLayout()
layout.addWidget(self.result_browser)
self.setLayout(layout)
# Signals
self.path_selection_combo.sig_redirect_stdio_requested.connect(
self.sig_redirect_stdio_requested)
self.search_text_edit.valid.connect(lambda valid: self.find())
self.exclude_pattern_edit.valid.connect(lambda valid: self.find())
self.result_browser.sig_edit_goto_requested.connect(
self.sig_edit_goto_requested)
self.result_browser.sig_max_results_reached.connect(
self.sig_max_results_reached)
self.result_browser.sig_max_results_reached.connect(
self._stop_and_reset_thread)
# --- PluginMainWidget API
# ------------------------------------------------------------------------
def get_title(self):
return _("Find")
def get_focus_widget(self):
return self.search_text_edit
def setup(self, options=DEFAULT_OPTIONS):
self.search_regexp_action = self.create_action(
FindInFilesWidgetActions.ToggleSearchRegex,
text=_('Regular expression'),
tip=_('Regular expression'),
icon=self.create_icon('regex'),
toggled=lambda val: self.set_option('search_text_regexp', val),
initial=self.get_option('search_text_regexp'),
)
self.case_action = self.create_action(
FindInFilesWidgetActions.ToggleExcludeCase,
text=_("Case sensitive"),
tip=_("Case sensitive"),
icon=self.create_icon("format_letter_case"),
toggled=lambda val: self.set_option('case_sensitive', val),
initial=self.get_option('case_sensitive'),
)
self.find_action = self.create_action(
FindInFilesWidgetActions.Find,
icon_text=_('Search'),
text=_("&Find in files"),
tip=_("Search text in multiple files"),
icon=self.create_icon('find'),
triggered=self.find,
register_shortcut=False,
)
self.exclude_regexp_action = self.create_action(
FindInFilesWidgetActions.ToggleExcludeRegex,
text=_('Regular expression'),
tip=_('Regular expression'),
icon=self.create_icon('regex'),
toggled=lambda val: self.set_option('exclude_regexp', val),
initial=self.get_option('exclude_regexp'),
)
self.exclude_case_action = self.create_action(
FindInFilesWidgetActions.ToggleCase,
text=_("Exclude case sensitive"),
tip=_("Exclude case sensitive"),
icon=self.create_icon("format_letter_case"),
toggled=lambda val: self.set_option('exclude_case_sensitive', val),
initial=self.get_option('exclude_case_sensitive'),
)
self.more_options_action = self.create_action(
FindInFilesWidgetActions.ToggleMoreOptions,
text=_('Show advanced options'),
tip=_('Show advanced options'),
icon=self.create_icon("options_more"),
toggled=lambda val: self.set_option('more_options', val),
initial=self.get_option('more_options'),
)
self.set_max_results_action = self.create_action(
FindInFilesWidgetActions.MaxResults,
text=_('Set maximum number of results'),
tip=_('Set maximum number of results'),
triggered=lambda x=None: self.set_max_results(),
)
# Toolbar
toolbar = self.get_main_toolbar()
for item in [
self.search_label, self.search_text_edit,
self.search_regexp_action, self.case_action,
self.more_options_action, self.find_action
]:
self.add_item_to_toolbar(
item,
toolbar=toolbar,
section=FindInFilesWidgetMainToolBarSections.Main,
)
# Exclude Toolbar
self.extras_toolbar = self.create_toolbar(
FindInFilesWidgetToolBars.Exclude)
for item in [
self.exclude_label, self.exclude_pattern_edit,
self.exclude_regexp_action,
self.create_stretcher()
]:
self.add_item_to_toolbar(
item,
toolbar=self.extras_toolbar,
section=FindInFilesWidgetExcludeToolBarSections.Main,
)
# Location toolbar
location_toolbar = self.create_toolbar(
FindInFilesWidgetToolBars.Location)
for item in [self.search_in_label, self.path_selection_combo]:
self.add_item_to_toolbar(
item,
toolbar=location_toolbar,
section=FindInFilesWidgetLocationToolBarSections.Main,
)
menu = self.get_options_menu()
self.add_item_to_menu(
self.set_max_results_action,
menu=menu,
)
def update_actions(self):
if self.running:
icon_text = _('Stop')
icon = self.create_icon('stop')
else:
icon_text = _('Search')
icon = self.create_icon('find')
self.find_action.setIconText(icon_text)
self.find_action.setIcon(icon)
if self.extras_toolbar and self.more_options_action:
self.extras_toolbar.setVisible(
self.more_options_action.isChecked())
def on_option_update(self, option, value):
if option == 'more_options':
if value:
icon = self.create_icon('options_less')
tip = _('Hide advanced options')
else:
icon = self.create_icon('options_more')
tip = _('Show advanced options')
if self.extras_toolbar:
self.extras_toolbar.setVisible(value)
if self.more_options_action:
self.more_options_action.setIcon(icon)
self.more_options_action.setToolTip(tip)
elif option == 'max_results':
self.result_browser.set_max_results(value)
# --- Private API
# ------------------------------------------------------------------------
def _get_options(self):
"""
Get search options.
"""
text_re = self.search_regexp_action.isChecked()
exclude_re = self.exclude_regexp_action.isChecked()
case_sensitive = self.case_action.isChecked()
# Clear fields
self.search_text_edit.lineEdit().setStyleSheet("")
self.exclude_pattern_edit.lineEdit().setStyleSheet("")
self.exclude_pattern_edit.setToolTip("")
self.search_text_edit.setToolTip("")
utext = str(self.search_text_edit.currentText())
if not utext:
return
try:
texts = [(utext.encode('utf-8'), 'utf-8')]
except UnicodeEncodeError:
texts = []
for enc in self.supported_encodings:
try:
texts.append((utext.encode(enc), enc))
except UnicodeDecodeError:
pass
exclude = str(self.exclude_pattern_edit.currentText())
if not case_sensitive:
texts = [(text[0].lower(), text[1]) for text in texts]
file_search = self.path_selection_combo.is_file_search()
path = self.path_selection_combo.get_current_searchpath()
if not exclude_re:
items = [
fnmatch.translate(item.strip()) for item in exclude.split(",")
if item.strip() != ''
]
exclude = '|'.join(items)
# Validate exclude regular expression
if exclude:
error_msg = regexp_error_msg(exclude)
if error_msg:
exclude_edit = self.exclude_pattern_edit.lineEdit()
exclude_edit.setStyleSheet(self.REGEX_INVALID)
tooltip = self.REGEX_ERROR + ': ' + str(error_msg)
self.exclude_pattern_edit.setToolTip(tooltip)
return None
else:
exclude = re.compile(exclude)
# Validate text regular expression
if text_re:
error_msg = regexp_error_msg(texts[0][0])
if error_msg:
self.search_text_edit.lineEdit().setStyleSheet(
self.REGEX_INVALID)
tooltip = self.REGEX_ERROR + ': ' + str(error_msg)
self.search_text_edit.setToolTip(tooltip)
return None
else:
texts = [(re.compile(x[0]), x[1]) for x in texts]
return (path, file_search, exclude, texts, text_re, case_sensitive)
def _update_options(self):
"""
Extract search options from widgets and set the corresponding option.
"""
hist_limit = self.get_option('hist_limit')
search_texts = [
str(self.search_text_edit.itemText(index))
for index in range(self.search_text_edit.count())
]
excludes = [
str(self.search_text_edit.itemText(index))
for index in range(self.exclude_pattern_edit.count())
]
path_history = self.path_selection_combo.get_external_paths()
self.set_option('path_history', path_history)
self.set_option('search_text', search_texts[:hist_limit])
self.set_option('exclude', excludes[:hist_limit])
self.set_option('path_history', path_history[-hist_limit:])
self.set_option('exclude_index',
self.exclude_pattern_edit.currentIndex())
self.set_option('search_in_index',
self.path_selection_combo.currentIndex())
def _handle_search_complete(self, completed):
"""
Current search thread has finished.
"""
self.result_browser.set_sorting(ON)
self.result_browser.expandAll()
if self.search_thread is None:
return
self.sig_finished.emit()
found = self.search_thread.get_results()
self._stop_and_reset_thread()
if found is not None:
self.result_browser.show()
self.stop_spinner()
self.update_actions()
def _stop_and_reset_thread(self, ignore_results=False):
"""Stop current search thread and clean-up."""
if self.search_thread is not None:
if self.search_thread.isRunning():
if ignore_results:
self.search_thread.sig_finished.disconnect(
self.search_complete)
self.search_thread.stop()
self.search_thread.wait()
self.search_thread.setParent(None)
self.search_thread = None
self.running = False
self.stop_spinner()
self.update_actions()
# --- Public API
# ------------------------------------------------------------------------
@property
def path(self):
"""Return the current path."""
return self.path_selection_combo.path
@property
def project_path(self):
"""Return the current project path."""
return self.path_selection_combo.project_path
@property
def file_path(self):
"""Return the current file path."""
return self.path_selection_combo.file_path
def set_directory(self, directory):
"""
Set directory as current path.
Parameters
----------
directory: str
Directory path string.
"""
self.path_selection_combo.path = osp.abspath(directory)
def set_project_path(self, path):
"""
Set path as current project path.
Parameters
----------
path: str
Project path string.
"""
self.path_selection_combo.set_project_path(path)
def disable_project_search(self):
"""Disable project search path in combobox."""
self.path_selection_combo.set_project_path(None)
def set_file_path(self, path):
"""
Set path as current file path.
Parameters
----------
path: str
File path string.
"""
self.path_selection_combo.file_path = path
def set_search_text(self, text):
"""
Set current search text.
Parameters
----------
text: str
Search string.
Notes
-----
If `text` is empty, focus will be given to the search lineedit and no
search will be performed.
"""
if text:
self.search_text_edit.add_text(text)
self.search_text_edit.lineEdit().selectAll()
self.search_text_edit.setFocus()
def find(self):
"""
Start/stop find action.
Notes
-----
If there is no search running, this will start the search. If there is
a search running, this will stop it.
"""
if self.running:
self.stop()
else:
self.start()
def stop(self):
"""Stop find thread."""
self._stop_and_reset_thread()
def start(self):
"""Start find thread."""
options = self._get_options()
if options is None:
return
self._stop_and_reset_thread(ignore_results=True)
search_text = self.search_text_edit.currentText()
# Update and set options
self._update_options()
# Start
self.running = True
self.start_spinner()
self.search_thread = SearchThread(self, search_text, self.text_color)
self.search_thread.sig_finished.connect(self._handle_search_complete)
self.search_thread.sig_file_match.connect(
self.result_browser.append_file_result)
self.search_thread.sig_line_match.connect(
self.result_browser.append_result)
self.result_browser.clear_title(search_text)
self.search_thread.initialize(*self._get_options())
self.search_thread.start()
self.update_actions()
def add_external_path(self, path):
"""
Parameters
----------
path: str
Path to add to combobox.
"""
self.path_selection_combo.add_external_path(path)
def set_max_results(self, value=None):
"""
Set maximum amount of results to add to the result browser.
Parameters
----------
value: int, optional
Number of results. If None an input dialog will be used.
Default is None.
"""
if value is None:
value, valid = QInputDialog.getInt(
self,
self.get_name(),
_('Set maximum number of results: '),
value=self.get_option('max_results'),
min=1,
step=1,
)
else:
valid = True
if valid:
self.set_option('max_results', value)
class BaseTimerStatus(StatusBarWidget):
"""Status bar widget base for widgets that update based on timers."""
TITLE = None
TIP = None
def __init__(self, parent, statusbar):
"""Status bar widget base for widgets that update based on timers."""
super(BaseTimerStatus, self).__init__(parent, statusbar)
# Widgets
self.label = QLabel(self.TITLE)
self.value = QLabel()
# Widget setup
self.setToolTip(self.TIP)
self.value.setAlignment(Qt.AlignRight)
self.value.setFont(self.label_font)
fm = self.value.fontMetrics()
self.value.setMinimumWidth(fm.width('000%'))
# Layout
layout = self.layout()
layout.addWidget(self.label)
layout.addWidget(self.value)
layout.addSpacing(20)
# Setup
if self.is_supported():
self.timer = QTimer()
self.timer.timeout.connect(self.update_label)
self.timer.start(2000)
else:
self.timer = None
self.hide()
def set_interval(self, interval):
"""Set timer interval (ms)."""
if self.timer is not None:
self.timer.setInterval(interval)
def import_test(self):
"""Raise ImportError if feature is not supported."""
raise NotImplementedError
def is_supported(self):
"""Return True if feature is supported."""
try:
self.import_test()
return True
except ImportError:
return False
def get_value(self):
"""Return value (e.g. CPU or memory usage)."""
raise NotImplementedError
def update_label(self):
"""Update status label widget, if widget is visible."""
if self.isVisible():
self.value.setText('%d %%' % self.get_value())
