"""Common functions used for the psyplot gui"""

# SPDX-FileCopyrightText: 2016-2024 University of Lausanne

# SPDX-FileCopyrightText: 2020-2021 Helmholtz-Zentrum Geesthacht

# SPDX-FileCopyrightText: 2021-2024 Helmholtz-Zentrum hereon GmbH

#

# SPDX-License-Identifier: LGPL-3.0-only

import inspect

import logging

import os.path as osp

import sys

import traceback as tb

from functools import partial

import six

from psyplot_gui.compat.qtcompat import (

QAction,

QDesktopWidget,

QDockWidget,

QErrorMessage,

QIcon,

QInputDialog,

QRegExpValidator,

QtCore,

QToolButton,

)

if six.PY2:

try:

import CStringIO as io

except ImportError:

import StringIO as io

else:

import io

def is_running_tests():

"""Check if there are any GUI tests running

This function returns the :attr:`psyplot_gui.UNIT_TESTING` variable"""

import psyplot_gui

return psyplot_gui.UNIT_TESTING

def get_module_path(modname):

"""Return module `modname` base path"""

return osp.abspath(osp.dirname(sys.modules[modname].__file__))

def get_icon(name):

"""Get the path to an icon in the icons directory"""

return osp.join(get_module_path("psyplot_gui"), "icons", name)

class DockMixin(object):

"""A mixin class to define psyplot_gui plugins

Notes

-----

Each external plugin should set the :attr:`dock_position` and the

:attr:`title` attribute!

"""

_set_central_action = _view_action = None

#: The position of the plugin

dock_position = None

#: The title of the plugin

title = None

#: The class to use for the DockWidget

dock_cls = QDockWidget

#: The config page for this widget. Should inherit the

#: :class:`psyplot_gui.preferences.ConfigPage` widget

config_page = None

#: Boolean that is True if the dock widget should be hidden automatically

#: after startup

hidden = False

#: The instance of :class:`QDockWidget` of this plugin

dock = None

@property

def is_shown(self):

"""Boolean that is True, if the dock widget is shown"""

return (

self.dock is not None and self.dock.toggleViewAction().isChecked()

)

def to_dock(

self, main, title=None, position=None, docktype="pane", *args, **kwargs

):

if title is None:

title = self.title

if title is None:

raise ValueError("No title specified for the %s widget" % (self))

if position is None:

position = self.dock_position

if position is None:

raise ValueError(

"No position specified for the %s widget (%s)" % (title, self)

)

self.title = title

self.dock_position = position

if self.dock is None:

self.dock = self.dock_cls(title, main)

self.dock.setWidget(self)

main.dockwidgets.append(self.dock)

self.create_central_widget_action(main)

self.create_view_action(main, docktype)

self.position_dock(main, *args, **kwargs)

config_page = self.config_page

if config_page is not None:

main.config_pages.append(config_page)

return self.dock

def position_dock(self, main, *args, **kwargs):

"""Set the position of the dock widget

This method places the plugin widget at the desired dock position

(by default, indicated with the :attr:`dock_position` attribute)

Parameters

----------

main: psyplot_gui.main.Mainwindow

The main window where the dock is added"""

main.addDockWidget(self.dock_position, self.dock, *args, **kwargs)

def show_plugin(self):

"""Show the plugin widget"""

a = self.dock.toggleViewAction()

if not a.isChecked():

a.trigger()

def hide_plugin(self):

"""Hide the plugin widget"""

a = self.dock.toggleViewAction()

if a.isChecked():

a.trigger()

def show_status_message(self, msg):

"""Show a status message"""

try:

self.dock.parent().plugin_label.setText(msg)

except AttributeError:

pass

def create_central_widget_action(self, main):

"""Setup the action to make this plugin the central widget"""

if self._set_central_action is None:

menu = main.central_widgets_menu

group = main.central_widgets_actions

self._set_central_action = action = QAction(self.title, main)

action.setCheckable(True)

action.triggered.connect(partial(main.set_central_widget, self))

menu.addAction(action)

group.addAction(action)

return self._set_central_action

def create_view_action(self, main, docktype="pane"):

if self._view_action is None:

self._view_action = action = self.dock.toggleViewAction()

if docktype == "pane":

main.panes_menu.addAction(action)

elif docktype == "df":

main.dataframe_menu.addAction(action)

return self._view_action

def remove_plugin(self):

"""Remove this plugin and close it"""

mainwindow = self.dock.parent() if self.dock else self.parent()

key = next(

(key for key, w in mainwindow.plugins.items() if w is self), None

)

if mainwindow.centralWidget() is self:

mainwindow.set_central_widget(

mainwindow.__class__.central_widget_key

)

if self._view_action is not None:

mainwindow.panes_menu.removeAction(self._view_action)

mainwindow.dataframe_menu.removeAction(self._view_action)

if self._set_central_action is not None:

mainwindow.central_widgets_menu.removeAction(

self._set_central_action

)

if key is not None:

del mainwindow.plugins[key]

if self.dock is not None:

mainwindow.removeDockWidget(self.dock)

self.dock.close()

self.close()

class LoadFromConsoleButton(QToolButton):

"""A toolbutton to load an object from the console"""

#: The signal that is emitted when an object has been loaded. The first

#: argument is the object name, the second the object itself

object_loaded = QtCore.pyqtSignal(str, object)

@property

def instances2check_str(self):

return ", ".join(

"%s.%s" % (cls.__module__, cls.__name__)

for cls in self._instances2check

)

@property

def potential_object_names(self):

from ipykernel.inprocess.ipkernel import InProcessInteractiveShell

shell = InProcessInteractiveShell.instance()

return sorted(

name

for name, obj in shell.user_global_ns.items()

if not name.startswith("_") and self.check(obj)

)

def __init__(self, instances=None, *args, **kwargs):

"""

Parameters

----------

instances: class or tuple of classes

The classes that should be used for an instance check

"""

super(LoadFromConsoleButton, self).__init__(*args, **kwargs)

self.setIcon(QIcon(get_icon("console-go.png")))

if instances is not None and inspect.isclass(instances):

instances = (instances,)

self._instances2check = instances

self.error_msg = PyErrorMessage(self)

self.clicked.connect(partial(self.get_from_shell, None))

def check(self, obj):

return (

True

if not self._instances2check

else isinstance(obj, self._instances2check)

)

def get_from_shell(self, oname=None):

"""Open an input dialog, receive an object and emit the

:attr:`object_loaded` signal"""

if oname is None:

oname, ok = QInputDialog.getItem(

self,

"Select variable",

"Select a variable to import from the console",

self.potential_object_names,

)

if not ok:

return

if self.check(oname) and (

self._instances2check or not isinstance(oname, six.string_types)

):

obj = oname

oname = "object"

else:

found, obj = self.get_obj(oname.strip())

if found:

if not self.check(obj):

self.error_msg.showMessage(

"Object must be an instance of %r, not %r"

% (

self.instances2check_str,

"%s.%s"

% (type(obj).__module__, type(obj).__name__),

)

)

return

else:

if not oname.strip():

msg = "The variable name must not be empty!"

else:

msg = "Could not find object " + oname

self.error_msg.showMessage(msg)

return

self.object_loaded.emit(oname, obj)

def get_obj(self, oname):

"""Load an object from the current shell"""

from psyplot_gui.main import mainwindow

return mainwindow.console.get_obj(oname)

class ListValidator(QRegExpValidator):

"""A validator class to validate that a string consists of strings in a

list of strings"""

def __init__(self, valid, sep=",", *args, **kwargs):

"""

Parameters

----------

valid: list of str

The possible choices

sep: str, optional

The separation pattern

``*args,**kwargs``

Determined by PyQt5.QtGui.QValidator

"""

patt = QtCore.QRegExp("^((%s)(;;)?)+$" % "|".join(valid))

super(QRegExpValidator, self).__init__(patt, *args, **kwargs)

class PyErrorMessage(QErrorMessage):

"""Widget designed to display python errors via the :meth:`showTraceback`

method"""

def showTraceback(self, header=None):

if is_running_tests():

raise

s = io.StringIO()

tb.print_exc(file=s)

last_tb = "<p>" + "<br>".join(s.getvalue().splitlines()) + "</p>"

header = header + "\n" if header else ""

self.showMessage(header + last_tb)

available_width = QDesktopWidget().availableGeometry().width() / 3.0

available_height = QDesktopWidget().availableGeometry().height() / 3.0

width = self.sizeHint().width()

height = self.sizeHint().height()

# The message window should cover at least one third of the screen

self.resize(max(available_width, width), max(available_height, height))

def excepthook(self, type, value, traceback):

s = io.StringIO()

tb.print_exception(type, value, traceback, file=s)

last_tb = "<p>" + "<br>".join(s.getvalue().splitlines()) + "</p>"

header = value.message if six.PY2 else str(value)

self.showMessage(header + "\n" + last_tb)

available_width = QDesktopWidget().availableGeometry().width() / 3.0

available_height = QDesktopWidget().availableGeometry().height() / 3.0

width = self.sizeHint().width()

height = self.sizeHint().height()

# The message window should cover at least one third of the screen

self.resize(max(available_width, width), max(available_height, height))

class StreamToLogger(object):

"""

Fake file-like stream object that redirects writes to a logger instance.

"""

def __init__(self, logger, log_level=logging.INFO):

self.logger = logger

self.log_level = log_level

self.linebuf = ""

def write(self, buf):

for line in buf.rstrip().splitlines():

self.logger.log(self.log_level, line.rstrip())

def flush(self):

pass