schrodinger.application.livedesign.ld_export module

class schrodinger.application.livedesign.ld_export.FileFormats(value)

Bases: enum.Enum

An enumeration.

MAE = '.mae'

CMS = '.cms'

CIF = '.cif'

class schrodinger.application.livedesign.ld_export.ExportModel(*args, _param_type=<object object>, **kwargs)

Bases: schrodinger.models.parameters.CompoundParam

ld_client: object

Base class for all Param classes. A Param is a descriptor for storing data, which means that a single Param instance will manage the data values for multiple instances of the class that owns it. Example:

class Coord(CompoundParam):
    x: int
    y: int

An instance of the Coord class can be created normally, and Params can be accessed as normal attributes:

coord = Coord()
coord.x = 4

When a Param value is set, the valueChanged signal is emitted. Params can be serialized and deserialized to and from JSON. Params can also be nested:

class Atom(CompoundParam):
    coord: Coord
    element: str

ld_models: object

Base class for all Param classes. A Param is a descriptor for storing data, which means that a single Param instance will manage the data values for multiple instances of the class that owns it. Example:

class Coord(CompoundParam):
    x: int
    y: int

An instance of the Coord class can be created normally, and Params can be accessed as normal attributes:

coord = Coord()
coord.x = 4

When a Param value is set, the valueChanged signal is emitted. Params can be serialized and deserialized to and from JSON. Params can also be nested:

class Atom(CompoundParam):
    coord: Coord
    element: str

entry_data: schrodinger.application.livedesign.entry_types.BaseEntryData

Base class for all Param classes. A Param is a descriptor for storing data, which means that a single Param instance will manage the data values for multiple instances of the class that owns it. Example:

class Coord(CompoundParam):
    x: int
    y: int

An instance of the Coord class can be created normally, and Params can be accessed as normal attributes:

coord = Coord()
coord.x = 4

When a Param value is set, the valueChanged signal is emitted. Params can be serialized and deserialized to and from JSON. Params can also be nested:

class Atom(CompoundParam):
    coord: Coord
    element: str

export_text: str

Base class for all Param classes. A Param is a descriptor for storing data, which means that a single Param instance will manage the data values for multiple instances of the class that owns it. Example:

class Coord(CompoundParam):
    x: int
    y: int

An instance of the Coord class can be created normally, and Params can be accessed as normal attributes:

coord = Coord()
coord.x = 4

When a Param value is set, the valueChanged signal is emitted. Params can be serialized and deserialized to and from JSON. Params can also be nested:

class Atom(CompoundParam):
    coord: Coord
    element: str

entry_type: object

Base class for all Param classes. A Param is a descriptor for storing data, which means that a single Param instance will manage the data values for multiple instances of the class that owns it. Example:

class Coord(CompoundParam):
    x: int
    y: int

An instance of the Coord class can be created normally, and Params can be accessed as normal attributes:

coord = Coord()
coord.x = 4

When a Param value is set, the valueChanged signal is emitted. Params can be serialized and deserialized to and from JSON. Params can also be nested:

class Atom(CompoundParam):
    coord: Coord
    element: str

entry_type_description: str

Base class for all Param classes. A Param is a descriptor for storing data, which means that a single Param instance will manage the data values for multiple instances of the class that owns it. Example:

class Coord(CompoundParam):
    x: int
    y: int

An instance of the Coord class can be created normally, and Params can be accessed as normal attributes:

coord = Coord()
coord.x = 4

When a Param value is set, the valueChanged signal is emitted. Params can be serialized and deserialized to and from JSON. Params can also be nested:

class Atom(CompoundParam):
    coord: Coord
    element: str

entry_type_name: str

Base class for all Param classes. A Param is a descriptor for storing data, which means that a single Param instance will manage the data values for multiple instances of the class that owns it. Example:

class Coord(CompoundParam):
    x: int
    y: int

An instance of the Coord class can be created normally, and Params can be accessed as normal attributes:

coord = Coord()
coord.x = 4

When a Param value is set, the valueChanged signal is emitted. Params can be serialized and deserialized to and from JSON. Params can also be nested:

class Atom(CompoundParam):
    coord: Coord
    element: str

input_summary: str

Base class for all Param classes. A Param is a descriptor for storing data, which means that a single Param instance will manage the data values for multiple instances of the class that owns it. Example:

class Coord(CompoundParam):
    x: int
    y: int

An instance of the Coord class can be created normally, and Params can be accessed as normal attributes:

coord = Coord()
coord.x = 4

When a Param value is set, the valueChanged signal is emitted. Params can be serialized and deserialized to and from JSON. Params can also be nested:

class Atom(CompoundParam):
    coord: Coord
    element: str

ld_destination: schrodinger.application.livedesign.export_models.LDDestination

Parameters specifying the destination of the exported data, both LiveDesign server and live report.

task_rl_map: object

Base class for all Param classes. A Param is a descriptor for storing data, which means that a single Param instance will manage the data values for multiple instances of the class that owns it. Example:

class Coord(CompoundParam):
    x: int
    y: int

An instance of the Coord class can be created normally, and Params can be accessed as normal attributes:

coord = Coord()
coord.x = 4

When a Param value is set, the valueChanged signal is emitted. Params can be serialized and deserialized to and from JSON. Params can also be nested:

class Atom(CompoundParam):
    coord: Coord
    element: str

export_task: schrodinger.application.livedesign.export_tasks.MasterExportTask

Primary LD export task. Responsible for

1. Preparing data for export

2. Launching subtasks that perform export processes

3. Communicating with the LD Export panel

Variables

exportFailed (QtCore.pyqtSignal) – a signal containing an error message describing export failures

summary_model: schrodinger.application.livedesign.export_models.SummaryModel

The model for the summary panel shown the user prior to export.

lr_widget_model: schrodinger.application.livedesign.live_report_widget.LiveReportModel

mapping_model: schrodinger.application.livedesign.mapping_widgets.MaestroLDMappingModel

Maestro to LiveDesign mapping model.

Note

If a subclass of panel_components.ExportTableModel is used for maestro_properties then subclass the module and update the type hint to ensure the correct type is used when deserialize the model from json.

ge_file_format: schrodinger.application.livedesign.ld_export.FileFormats

__init__(export_table_model_class=<class 'schrodinger.application.livedesign.panel_components.ExportTableModel'>, *args, **kwargs)

initializeValue()

Override to dynamically set up the default value of the param. Useful for default values that are determined at runtime. This is called any time the param is reset.

initConcrete()

Override to customize initialization of concrete params.

classmethod configureParam()

Synchronize parameters that should always have the same value.

DataClass

This class can be used to declare a public attribute on a CompoundParam. Declared public attributes can be used without error.

Example usage:

class Coord(CompoundParam):
    x: int
    y: int
    note = NonParamAttribute()

coord = Coord()
coord.note = "hello" # No error

classmethod addSubParam(name, param, update_owner=True)

blockSignals(self, b: bool) → bool

block_signal_propagation()

childEvent(self, a0: QChildEvent)

children(self) → List[QObject]

connectNotify(self, signal: QMetaMethod)

customEvent(self, a0: QEvent)

classmethod defaultValue()

Returns the default value for this abstract param:

default_atom = Atom.defaultValue()
assert Atom.coord.x == 0

deleteLater(self)

destroyed

destroyed(self, object: typing.Optional[QObject] = None) [signal]

disconnect(a0: QMetaObject.Connection) → bool

disconnect(self) → None

disconnectNotify(self, signal: QMetaMethod)

dumpObjectInfo(self)

dumpObjectTree(self)

dynamicPropertyNames(self) → List[QByteArray]

entry_dataChanged

entry_dataReplaced

entry_typeChanged

entry_typeReplaced

entry_type_descriptionChanged

entry_type_descriptionReplaced

entry_type_nameChanged

entry_type_nameReplaced

event(self, a0: QEvent) → bool

eventFilter(self, a0: QObject, a1: QEvent) → bool

export_taskChanged

export_taskReplaced

export_textChanged

export_textReplaced

findChild(self, type: type, name: str = '', options: Qt.FindChildOption = Qt.FindChildrenRecursively) → QObject

findChild(self, types: Tuple, name: str = '', options: Qt.FindChildOption = Qt.FindChildrenRecursively) → QObject

findChildren(self, type: type, name: str = '', options: Qt.FindChildOption = Qt.FindChildrenRecursively) → List[QObject]

findChildren(self, types: Tuple, name: str = '', options: Qt.FindChildOption = Qt.FindChildrenRecursively) → List[QObject]

findChildren(self, type: type, re: QRegularExpression, options: Qt.FindChildOption = Qt.FindChildrenRecursively) → List[QObject]

findChildren(self, types: Tuple, re: QRegularExpression, options: Qt.FindChildOption = Qt.FindChildrenRecursively) → List[QObject]

classmethod fromJson(json_obj)

A factory method which constructs a new object from a given dict loaded from a json string or file.

Parameters

json_obj (dict) – A json-loaded dictionary to create an object from.

Returns

An instance of this class.

Return type

cls

classmethod fromJsonImplementation(json_dict)

Sets the value of this compound param value object from a JSON dict.

Warning

This should never be called directly.

ge_file_formatChanged

ge_file_formatReplaced

getAbstractParam()

Return the corresponding abstract param for this instance.

classmethod getJsonBlacklist()

Override to customize what params are serialized.

Implementations should return a list of abstract params that should be omitted from serialization.

..NOTE

Returned abstract params must be direct child params of cls, e.g. cls.name, not cls.coord.x.

classmethod getParamSignal(obj, signal_type='Changed')

classmethod getParamValue(obj)

Enables access to a param value on a compound param via an abstract param reference:

a = Atom()
assert Atom.coord.x.getParamValue(a) == 0 # ints default to 0
a.coord.x = 3
assert Atom.coord.x.getParamValue(a) == 3

Parameters

param (CompoundParam) – The owner param to get a param value from

classmethod getSubParam(name)

Get the value of a subparam using the string name:

c = Coord()
assert c.getSubParam('x') == 0

Note

Using the string name to access params is generally discouraged, but can be useful for serializing/deserializing param data.

Parameters

name (str) – The name of the subparam to get the value for.

classmethod getSubParams()

Return a dictionary mapping subparam names to their values.

getTypeHint()

get_version()

Method to get the version of a particular object. Defaults to the current version of mmshare. This class can be overridden for custom versioning behavior.

inherits(self, classname: str) → bool

initAbstract()

input_summaryChanged

input_summaryReplaced

installEventFilter(self, a0: QObject)

classmethod isAbstract()

Whether the param is an “abstract” param.

isDefault()

Whether the current value of this instance matches the default value.

isSignalConnected(self, signal: QMetaMethod) → bool

isWidgetType(self) → bool

isWindowType(self) → bool

killTimer(self, id: int)

ld_clientChanged

ld_clientReplaced

ld_destinationChanged

ld_destinationReplaced

ld_modelsChanged

ld_modelsReplaced

lr_widget_modelChanged

lr_widget_modelReplaced

mapping_modelChanged

mapping_modelReplaced

metaObject(self) → QMetaObject

moveToThread(self, thread: QThread)

objectName(self) → str

objectNameChanged

objectNameChanged(self, objectName: str) [signal]

classmethod owner()

Get the owner of the param:

# Can be called on an abstract param:
assert Coord.x.owner() == Coord

# ...or on an instance of a CompoundParam
a = Atom()
assert a.coord.owner() == a

classmethod ownerChain()

Returns a list of param owners starting from the toplevel param and ending with self. Examples:

foo.bar.atom.coord.ownerChain() will return [foo, bar, atom, coord] where every item is a concrete param.

Foo.bar.atom.coord.x.ownerChain() will return [Foo, Foo.bar, Foo.atom.coord, Foo.atom.coord.x] where every item is an abstract params.

classmethod paramName()

Get the name of the param:

# Can be called on an abstract param:
print(Coord.x.paramName()) # 'x'

# ...or on an instance of a CompoundParam
a = Atom()
a.coord.paramName() # 'coord'

parent(self) → QObject

property(self, name: str) → Any

pyqtConfigure(...)

Each keyword argument is either the name of a Qt property or a Qt signal. For properties the property is set to the given value which should be of an appropriate type. For signals the signal is connected to the given value which should be a callable.

receivers(self, signal: PYQT_SIGNAL) → int

removeEventFilter(self, a0: QObject)

reset(*abstract_params)

Resets this compound param to its default value:

class Line(CompoundParam):
    start = Coord(x=1, y=2)
    end = Coord(x=4, y=5)
line = Line()
line.start.x = line.end.x = 10
assert line.start.x == line.end.x == 10
line.reset()
assert line.start.x == 1
assert line.end.x == 4

Any number of abstract params may be passed in to perform a partial reset of only the specified params:

line.start.x = line.end.x = 10
line.reset(Line.start.x)  # resets just start.x
assert line.start.x == 1
assert line.end.x == 10

line.reset(Line.end)      # resets the entire end point
assert line.end.x == 4

line.start.y = line.end.y = 10
line.reset(Line.start.y, Line.end.y)  # resets the y-coord of both
assert line.start.y == 2
assert line.end.y == 5

sender(self) → QObject

senderSignalIndex(self) → int

setObjectName(self, name: str)

classmethod setParamValue(obj, value)

Set the value of a param on an object by specifying the instance and the value:

# Setting the param value of a basic param
a = Atom()
Atom.coord.x.setParamValue(a, 5)
assert a.coord.x == 5

# setParamValue can also be used to set the value of CompoundParams
c = Coord()
c.x = 10
atom.coord.setParamValue(a, c)
assert atom.coord.x == 10

Parameters

• param – The owner param to set a subparam value of.

• value – The value to set the subparam value to.

setParent(self, a0: QObject)

setProperty(self, name: str, value: Any) → bool

classmethod setReference(param1, param2)

Call this class method from configureParam to indicate that two params should be kept in sync. The initial values will start with the default value of param1. Example:

class Square(CompoundParam):
    width: float = 5
    height: float = 10

    @classmethod
    def configureParam(cls):
        super().configureParam()
        cls.setReference(cls.width, cls.height)

square = Square()
assert square.width == square.height == 5 # Default value of width
                                          # takes priority
square.height = 7
assert square.width == square.height == 7
square.width = 6
assert square.width == square.height == 6

Parameters

• param1 – The first abstract param to keep synced

• param2 – The second abstract param. After instantiation, this param will take on the value of param1.

setValue(value=None, **kwargs)

Set the value of this CompoundParam to match value.

Parameters

• value – The value to set this CompoundParam to. It should be the same type as this CompoundParam.

• kwargs – For internal use only.

signalsBlocked(self) → bool

skip_eq_check()

startTimer(self, interval: int, timerType: Qt.TimerType = Qt.CoarseTimer) → int

staticMetaObject = <PyQt6.QtCore.QMetaObject object>

summary_modelChanged

summary_modelReplaced

task_rl_mapChanged

task_rl_mapReplaced

thread(self) → QThread

timerEvent(self, a0: QTimerEvent)

toDict()

Return a dictionary version of this CompoundParam. The returned dictionary is fully nested and contains no CompoundParam instances

a = Atom()
a_dict = a.toDict()
assert a_dict['coord']['x'] == 0
assert a_dict['coord'] == {'x':0, 'y':0}

toJson(_mark_version=True)

Create and returns a data structure made up of jsonable items.

Return type

An instance of one the classes from NATIVE_JSON_DATATYPES

toJsonImplementation()

Returns a JSON representation of this value object.

Warning

This should never be called directly.

tr(sourceText: str, disambiguation: typing.Optional[str] = None, n: int = - 1) → str

valueChanged

class schrodinger.application.livedesign.ld_export.LDExportPanelMixin

Bases: object

Mixin for LD Export GUI panels. Provides a standardized window title that includes a custom string and the host name.

Subclasses must:

1. Inherit from mappers.MapperMixin

2. Have a model that includes a export_models.LDDestination parameter

   called ld_destination

Variables

TITLE_BASE – the standard string to include at the beginning of the window’s title

TITLE_BASE = NotImplemented

defineMappings()

class schrodinger.application.livedesign.ld_export.AbstractExportPanel(*args, **kwargs)

Bases: schrodinger.application.livedesign.ld_export.LDExportPanelMixin, schrodinger.ui.qt.widgetmixins.panelmixins.TaskPanelMixin, schrodinger.ui.qt.appframework2.wizards.BaseWizardPanel

Variables

allow_add_live_reports (bool) – whether users should be presented with the option to create a new live report from this panel

model_class

alias of schrodinger.application.livedesign.ld_export.ExportModel

PANEL_TASKS = [<Descriptor:ExportModel.export_task>]

ui_module = <module 'schrodinger.application.livedesign.export_ui' from '/scr/buildbot/savedbuilds/2024-1/NB/build-133/internal/lib/python3.8/site-packages/schrodinger/application/livedesign/export_ui.py'>

EXPORT_TEXT = 'Map Maestro Properties to LiveDesign Properties'

TABLE_MODEL_CLASS

alias of schrodinger.application.livedesign.panel_components.ExportTableModel

TABLE_VIEW_CLASS

alias of schrodinger.application.livedesign.panel_components.ExportTableView

MAESTRO_LD_MAPPING_WIDGET_CLASS

alias of schrodinger.application.livedesign.mapping_widgets.MaestroLDMappingWidget

MAP_ERROR_MSG = 'Error: The selected mapping could not be successfully applied. One or more data rows in the export table may be incorrect.'

allow_add_live_reports = True

initSetOptions()

Suggested subclass use: set instance variables, excluding layouts and subwidgets. Also use here to (optionally) apply the legacy stylesheet spacing settings (PANEL-19101).

initSetUp()

Creates widget from ui and stores it ui_widget.

Suggested subclass use: create and initialize subwidgets, and connect signals.

initLayOut()

@overrides: widgetmixins.InitMixin

initSetDefaults()

Override mappers.MapperMixin to avoid resetting the entire model.

processPrevPanel(state)

Override this method to receive the settings from the previous panel and processes them appropriately.

Parameters

state (settings.PanelState) – the state from the previous panel

makeInitialModel()

setModel(model)

Sets the model object for the mapper. Disconnects the old model, if one is set, and connects the new model. Pass in None to have no model set.

Parameters

model – the model instance or None

defineMappings()

Override this in the subclass to define mappings. Should return a list of tuples [(<target>, <param>)]. Targets can be:

1. a basic widget, like QLineEdit or QComboBox

2. a custom object that inherits MapperMixin or TargetMixin

3. a TargetSpec instance

4. a slot

For common widgets, standard signals and getter/setter methods will be used, as defined in mappers._get_default_access_names().

For more fine-grained custom control, instantiate a TargetSpec object, which allows custom setters, getters, and signals to be specified.

Supplying a slot as the first element of the tuple is equivalent to providing TargetSpec(slot=my_slot).

Note that all target slots are triggered on setModel() as well as in response to the specified signal.

The param is an abstract param reference, e.g. MyModel.my_param.

Example:

def defineMappings(self):
    combo = self.style_combo
    return [(self.name_le, MyModel.name),
            (TargetSpec(combo,
                    getter=combo.currentText,
                    setter=combo.setCurrentText), MyModel.style),
            (self.coord_widget, MyModel.coord),
            (self._onASLTextChanged, MyModel.asl_text)]

getSignalsAndSlots(model)

Override this method to specify signal and slot pairs that need to be connected/disconnected whenever the model instance is switched using setModel. The model instance is provided as an argument so that instance-specific signals can be used, but any pairs of signals and slots may be returned from this method.

Returns

a list of 2-tuples where each tuple is a signal, slot pair

defineTaskPreprocessors(model)

Return a list of tuples containing a task and an associated preprocesor.

To include preprocessors, override this method in a subclass. Example:

def defineTaskPreprocessors(self, model):
    return [
        (model.search_task, self._validateSearchTerms),
        (model.email_task, self._compileAddresses)
    ]

Parameters

model (parameters.CompoundParam) – a model instance

Returns

a list of (task, method) tuples

Return type

list[tuple[tasks.AbstractTask, typing.Callable]]

setDefaultCheckedItems(item_strs: List[str])

Specify which LD data items will be checked by default.

Parameters

item_strs – string representations of the desired checked data item. In most cases, this is the structure property name.

updateMaestroProperties()

Update the selection and state of the items that can be exported from this panel to LiveDesign.

updateEnabledExportableData()

Enable or disable exportable data items.

Should be overridden in subclasses.

setDownstreamWidgetsEnabled(enable)

Sets the state of the downstream widgets in the Export workflow

Parameters

enable (bool) – whether to enable the widgets

openSelectedExportMap(map_name)

Slot connected to selecting a mapping. Open the selected map and use the mappings to populate the export table. This method resets the property selection tree along with the export table.

openExportMap(map_file)

Open the map_file and use the mappings to populate the export table. This method resets the property selection tree along with the export table. This function is used in KNIME to restore the Properties table contents from a map.json file

Parameters

map_file (str) – Path to a json map file

setCheckedMaestroProperties(ld_data_list)

Assign a check state to the boxes in the data selection tree.

May be overridden in subclasses that require more complex behavior when changing the LD data tree state.

Parameters

ld_data_list (list[data_classes.LDData]) – check boxes associated with these LDData objects, and uncheck all other boxes

run(prev_panel_state=None)

Runs the panel. If the panel is being invoked by clicking “Next” on the previous panel, pass in the previous panel’s state so it can be processed.

Parameters

prev_panel_state (settings.PanelState or None) – the previous panel’s state

setStatus(message, timeout=0, color=None)

Set the status bar text with optional timeout and text color.

Parameters

• message (str) – the message to display

• timeout (int) – time to show message in ms. If set to 0 (default) the message is not cleared.

• color (QtGui.QColor) – text color for message. Default is black.

ADD_RESET_THIS_TASK_OPTION = False

APPLY_LEGACY_STYLESHEET = True

APPLY_PANELX_STYLESHEET = False

class BtnPos(value)

Bases: enum.IntEnum

An enumeration.

Left = 0

Middle = 1

Right = 2

DrawChildren = 2

DrawWindowBackground = 1

IgnoreMask = 4

property PREFERENCES_KEY

PRESETS_FEATURE_FLAG = False

class PaintDeviceMetric(value)

Bases: enum.Enum

An enumeration.

PdmWidth = 1

PdmHeight = 2

PdmWidthMM = 3

PdmHeightMM = 4

PdmNumColors = 5

PdmDepth = 6

PdmDpiX = 7

PdmDpiY = 8

PdmPhysicalDpiX = 9

PdmPhysicalDpiY = 10

PdmDevicePixelRatio = 11

PdmDevicePixelRatioScaled = 12

PdmDepth = 6

PdmDevicePixelRatio = 11

PdmDevicePixelRatioScaled = 12

PdmDpiX = 7

PdmDpiY = 8

PdmHeight = 2

PdmHeightMM = 4

PdmNumColors = 5

PdmPhysicalDpiX = 9

PdmPhysicalDpiY = 10

PdmWidth = 1

PdmWidthMM = 3

class RenderFlag(value)

Bases: enum.Flag

An enumeration.

DrawWindowBackground = 1

DrawChildren = 2

IgnoreMask = 4

SHOW_AS_WINDOW = True

class StdBtn(value)

Bases: enum.IntEnum

An enumeration.

Ok = 0

Cancel = 1

Reset = 2

Help = 3

TITLE_BASE = NotImplemented

__init__(*args, **kwargs)

acceptDrops(self) → bool

property accepted

accessibleDescription(self) → str

accessibleName(self) → str

actionEvent(self, a0: QActionEvent)

actions(self) → List[QAction]

activateWindow(self)

activeTask()

Return the currently active task.

Returns

The currently active task from PANEL_TASKS

addAction(self, action: QAction)

addActions(self, actions: Iterable[QAction])

adjustSize(self)

applyAliasedSettings(settings)

Applies any aliased settings with new values from the dictionary. Any aliases not present in the settings dictionary will be left unchanged.

Parameters

settings (dict) – a dictionary mapping aliases to new values to apply

applySettings(settings, target=None)

autoFillBackground(self) → bool

backgroundRole(self) → QPalette.ColorRole

baseSize(self) → QSize

blockSignals(self, b: bool) → bool

changeEvent(self, a0: QEvent)

childAt(self, p: QPoint) → QWidget

childAt(self, ax: int, ay: int) → QWidget

childEvent(self, a0: QChildEvent)

children(self) → List[QObject]

childrenRect(self) → QRect

childrenRegion(self) → QRegion

clearFocus(self)

clearMask(self)

close(self) → bool

closeEvent(event)

Ensures proper handling of OK, Cancel, and [X] button clicks

colorCount(self) → int

connectNotify(self, signal: QMetaMethod)

contentsMargins(self) → QMargins

contentsRect(self) → QRect

contextMenuEvent(self, a0: QContextMenuEvent)

contextMenuPolicy(self) → Qt.ContextMenuPolicy

create(self, window: PyQt6.sip.voidptr = 0, initializeWindow: bool = True, destroyOldWindow: bool = True)

createWindowContainer(window: QWindow, parent: typing.Optional[QWidget] = None, flags: Qt.WindowType = Qt.WindowFlags()) → QWidget

cursor(self) → QCursor

customContextMenuRequested

customContextMenuRequested(self, pos: QPoint) [signal]

customEvent(self, a0: QEvent)

debug()

definePanelSettings()

Override this method to define the settings for the panel. The aliased settings provide an interface for saving/restoring panel state as well as for interacting with task/job runners that need to access the panel state in a way that is agnostic to the specifics of widget names and types.

Each panel setting is defined by a tuple that specifies the mapping of alias to panel setting. An optional third element in the tuple can be used to group settings by category. This allows multiple settings to share the same alias.

Each setting can either point to a specific object (usually a qt widget), or a pair of setter/getter functions.

If the mapped object is a string, this will be interpreted by af2 as referring to an attribute on the panel, and a AttributeSettingWrapper instance will automatically be created. For example, specifying the string ‘num_atoms’ will create a mapping to self.num_atoms which will simply get and set the value of that instance member.

Custom setter and getter functions should take the form getter(), returning a value that can be encoded/decoded by JSON, and setter(value), where the type of value is the same as the return type of the getter.

Commonly used objects/widgets should be handled automatically in settings.py. It’s worth considering whether it makes more sense to use a custom setter/getter here or add support for the widget in settings.py.

Returns

a list of tuples defining the custom settings.

Return type

list of tuples. Each tuple can be of type (str, object, str) or (str, (callable, callable), str) where the final str is optional.

Custom settings tuples consists of up to three elements:

1. alias - a string identier for the setting. Ex. “box_centroid”

2. either:

   1. an object of a type that is supported by settings.py or

   2. the string name of an existing panel attribute (i.e. member variable), or

   3. a (getter, setter) tuple. The getter should take no arguments, and the setter should take a single value.

3. optionally, a group identifier. This can be useful if the panel runs two different jobs that both have a parameter with the same name but that needs to map to different widgets. If a setting has a group name, it will be ignored by runners unless the runner name matches the group name.

defineTaskPostprocessors(model)

Return a list of tuples containing a task and an associated postprocessor.

The signature of this method is identical to that of defineTaskPreprocessors().

Parameters

model (parameters.CompoundParam) – a model instance

Returns

a list of (task, method) tuples

Return type

list[tuple[tasks.AbstractTask, typing.Callable]]

deleteLater(self)

depth(self) → int

destroy(self, destroyWindow: bool = True, destroySubWindows: bool = True)

destroyed

destroyed(self, object: typing.Optional[QObject] = None) [signal]

devType(self) → int

devicePixelRatio(self) → float

devicePixelRatioF(self) → float

devicePixelRatioFScale() → float

disconnect(a0: QMetaObject.Connection) → bool

disconnect(self) → None

disconnectNotify(self, signal: QMetaMethod)

dragEnterEvent(self, a0: QDragEnterEvent)

dragLeaveEvent(self, a0: QDragLeaveEvent)

dragMoveEvent(self, a0: QDragMoveEvent)

dropEvent(self, a0: QDropEvent)

dumpObjectInfo(self)

dumpObjectTree(self)

dynamicPropertyNames(self) → List[QByteArray]

effectiveWinId(self) → PyQt6.sip.voidptr

ensurePolished(self)

enterEvent(self, event: QEnterEvent)

error(*args, **kwargs)

Shows a popup error message box. For parameter documentation see messagebox.MessageBox.

event(self, a0: QEvent) → bool

eventFilter(self, a0: QObject, a1: QEvent) → bool

find(a0: PyQt6.sip.voidptr) → QWidget

findChild(self, type: type, name: str = '', options: Qt.FindChildOption = Qt.FindChildrenRecursively) → QObject

findChild(self, types: Tuple, name: str = '', options: Qt.FindChildOption = Qt.FindChildrenRecursively) → QObject

findChildren(self, type: type, name: str = '', options: Qt.FindChildOption = Qt.FindChildrenRecursively) → List[QObject]

findChildren(self, types: Tuple, name: str = '', options: Qt.FindChildOption = Qt.FindChildrenRecursively) → List[QObject]

findChildren(self, type: type, re: QRegularExpression, options: Qt.FindChildOption = Qt.FindChildrenRecursively) → List[QObject]

findChildren(self, types: Tuple, re: QRegularExpression, options: Qt.FindChildOption = Qt.FindChildrenRecursively) → List[QObject]

finished

focusInEvent(self, a0: QFocusEvent)

focusNextChild(self) → bool

focusNextPrevChild(self, next: bool) → bool

focusOutEvent(self, a0: QFocusEvent)

focusPolicy(self) → Qt.FocusPolicy

focusPreviousChild(self) → bool

focusProxy(self) → QWidget

focusWidget(self) → QWidget

font(self) → QFont

fontInfo(self) → QFontInfo

fontMetrics(self) → QFontMetrics

foregroundRole(self) → QPalette.ColorRole

forgetMessageBoxResponse(key)

Forgets any previously saved response that was stored via a save_response_key.

Parameters

key – the key for the response to forget

frameGeometry(self) → QRect

frameSize(self) → QSize

geometry(self) → QRect

getAliasedSettings()

getAliasedValue(alias)

getModel()

getObjValue(obj)

classmethod getPanelInstance(create=True)

Return the singleton instance of this panel, creating one if necessary.

Parameters

create (bool) – Whether to create an instance of the panel if none exists

Returns

instance of this panel.

Return type

PanelMixin

getPanelState()

Gets the current state of the panel in the form of a serializable dict. The state consists of the settings specified in definePanelSettings() as well as the automatically harvested settings.

getPersistenceKey(alias)

Return a unique identifier for saving/restoring a setting in the preferences. Override this method to change the key scheme (this is necessary if creating a common resource which is shared by multiple panels).

Parameters

alias (str) – the alias for which we are generating a key

getSettings(target=None, ignore_list=None)

getSettingsMenuActions(abstract_task)

Return a tuple representation of the settings button menu for a given abstract_task. For custom menus, override this method and return a list of tuples mapping desired menu item texts mapped to the method or function that should be called when the item is selected. If None is returned, then no actions are set on the settings button.

The following menu items are used for the default implementation:

  'Job Settings' -> Opens up a config dialog
  'Preferences...' -> Opens the Maestro preferences dialog to the
                      job preferences page.
  'Write' -> Write the job to a bash file

----(The above items are only shown if the task is a jobtask)-------

  *'Write STU ZIP File' -> Write a zip file that can be used to
                          create a stu test.
  'Reset Entire Panel' -> Resets the entire panel
  'Reset This Task' -> Reset just the current task (hidden by default,
                      can be enabled by setting the
                      `ADD_RESET_THIS_TASK_OPTION` class variable to
                      True).
  *'Start debugger...' -> Start a command line debugger with IPython
  *'Start debugger GUI...' -> Open up the debugger gui

• • Menu items that are only shown if the user has SCHRODINGER_SRC defined in their environment.

Parameters

abstract_task (tasks.AbstractTask) – The task to retrieve menu actions for. It will always be a member of self.PANEL_TASKS.

Returns

A list of tuples mapping the desired menu item text with the function that should be called when the item is selected. If the slot is None, then a separator will be added instead and the text will be ignored.

Return type

list[tuple(str, callable) or None] or None

getTask(panel_task=None)

Gets the task instance for a specified panel task. This is the task instance that will be run the next time the corresponding start button is clicked.

Parameters

panel_task – The abstract task from PANEL_TASKS for which to get the next task instance. If None, will return the next task instance for the active task.

getTaskBar(panel_task=None)

Gets the taskbar for a panel task.

Parameters

panel_task – The abstract task from PANEL_TASKS for which to get the taskbar. If None, will return the taskbar for the active panel task.

getTaskManager(panel_task=None)

Gets the taskmanager for a panel task.

Parameters

panel_task – The abstract task from PANEL_TASKS for which to get the taskmanager. If None, will return the taskmanager for the active task.

grab(self, rectangle: QRect = QRect(QPoint(0, 0), QSize(- 1, - 1))) → QPixmap

grabGesture(self, type: Qt.GestureType, flags: Qt.GestureFlag = Qt.GestureFlags())

grabKeyboard(self)

grabMouse(self)

grabMouse(self, a0: Union[QCursor, Qt.CursorShape]) → None

grabShortcut(self, key: Union[QKeySequence, QKeySequence.StandardKey, str, int], context: Qt.ShortcutContext = Qt.WindowShortcut) → int

graphicsEffect(self) → QGraphicsEffect

graphicsProxyWidget(self) → QGraphicsProxyWidget

hasFocus(self) → bool

hasHeightForWidth(self) → bool

hasMouseTracking(self) → bool

hasTabletTracking(self) → bool

height(self) → int

heightForWidth(self, a0: int) → int

heightMM(self) → int

hide(self)

hideEvent(self, a0: QHideEvent)

info(*args, **kwargs)

Shows a popup information message box. For parameter documentation see messagebox.MessageBox.

inherits(self, classname: str) → bool

initFinalize()

Suggested subclass use: perform any remaining initialization.

initPainter(self, painter: QPainter)

inputMethodEvent(self, a0: QInputMethodEvent)

inputMethodHints(self) → Qt.InputMethodHint

inputMethodQuery(self, a0: Qt.InputMethodQuery) → Any

insertAction(self, before: QAction, action: QAction)

insertActions(self, before: QAction, actions: Iterable[QAction])

installEventFilter(self, a0: QObject)

isActiveWindow(self) → bool

isAncestorOf(self, child: QWidget) → bool

isEnabled(self) → bool

isEnabledTo(self, a0: QWidget) → bool

isFullScreen(self) → bool

isHidden(self) → bool

isLeftToRight(self) → bool

isMaximized(self) → bool

isMinimized(self) → bool

isModal(self) → bool

isRightToLeft(self) → bool

isSignalConnected(self, signal: QMetaMethod) → bool

isVisible(self) → bool

isVisibleTo(self, a0: QWidget) → bool

isWidgetType(self) → bool

isWindow(self) → bool

isWindowModified(self) → bool

isWindowType(self) → bool

keyPressEvent(self, a0: QKeyEvent)

keyReleaseEvent(self, a0: QKeyEvent)

keyboardGrabber() → QWidget

killTimer(self, id: int)

layout(self) → QLayout

layoutDirection(self) → Qt.LayoutDirection

leaveEvent(self, a0: QEvent)

loadPanelState(filename=None)

Load the panel state from a JSON file

Parameters

filename (str) – the JSON filename. Defaults to “panelstate.json”

loadPersistentOptions()

Load all persistent options from the preferences.

locale(self) → QLocale

logicalDpiX(self) → int

logicalDpiY(self) → int

lower(self)

mapFrom(self, a0: QWidget, a1: QPoint) → QPoint

mapFrom(self, a0: QWidget, a1: QPointF) → QPointF

mapFromGlobal(self, a0: QPoint) → QPoint

mapFromGlobal(self, a0: QPointF) → QPointF

mapFromParent(self, a0: QPoint) → QPoint

mapFromParent(self, a0: QPointF) → QPointF

mapTo(self, a0: QWidget, a1: QPoint) → QPoint

mapTo(self, a0: QWidget, a1: QPointF) → QPointF

mapToGlobal(self, a0: QPoint) → QPoint

mapToGlobal(self, a0: QPointF) → QPointF

mapToParent(self, a0: QPoint) → QPoint

mapToParent(self, a0: QPointF) → QPointF

mappedParams()

Return a list of the abstract params that are mapped to.

mask(self) → QRegion

maximumHeight(self) → int

maximumSize(self) → QSize

maximumWidth(self) → int

metaObject(self) → QMetaObject

metric(self, a0: QPaintDevice.PaintDeviceMetric) → int

minimumHeight(self) → int

minimumSize(self) → QSize

minimumSizeHint(self) → QSize

minimumWidth(self) → int

property model

mouseDoubleClickEvent(self, a0: QMouseEvent)

mouseGrabber() → QWidget

mouseMoveEvent(self, a0: QMouseEvent)

mousePressEvent(self, a0: QMouseEvent)

mouseReleaseEvent(self, a0: QMouseEvent)

move(self, a0: QPoint)

move(self, ax: int, ay: int) → None

moveEvent(self, a0: QMoveEvent)

moveToThread(self, thread: QThread)

nativeEvent(self, eventType: QByteArray, message: PyQt6.sip.voidptr) → Tuple[bool, PyQt6.sip.voidptr]

nativeParentWidget(self) → QWidget

nextInFocusChain(self) → QWidget

normalGeometry(self) → QRect

objectName(self) → str

objectNameChanged

objectNameChanged(self, objectName: str) [signal]

onBackClicked()

onCancelClicked()

onNextClicked()

overrideWindowFlags(self, type: Qt.WindowType)

overrideWindowState(self, state: Qt.WindowState)

paintEngine(self) → QPaintEngine

paintEvent(self, a0: QPaintEvent)

paintingActive(self) → bool

palette(self) → QPalette

classmethod panel(blocking=False, modal=False, finished_callback=None)

Open an instance of this class.

For full argument documentation, see ExecutionMixin.run.

parent(self) → QObject

parentWidget(self) → QWidget

physicalDpiX(self) → int

physicalDpiY(self) → int

pos(self) → QPoint

previousInFocusChain(self) → QWidget

processBack()

Override this method to perform necessary actions when going back

processNext()

Override this method to perform necessary actions when going to next A return value of False will stay in the current panel, any other value will continue to the next.

property(self, name: str) → Any

pyqtConfigure(...)

Each keyword argument is either the name of a Qt property or a Qt signal. For properties the property is set to the given value which should be of an appropriate type. For signals the signal is connected to the given value which should be a callable.

question(*args, **kwargs)

Shows a popup question message box. For parameter documentation see messagebox.QuestionMessageBox.

raise_(self)

receivers(self, signal: PYQT_SIGNAL) → int

rect(self) → QRect

releaseKeyboard(self)

releaseMouse(self)

releaseShortcut(self, id: int)

removeAction(self, action: QAction)

removeEventFilter(self, a0: QObject)

render(self, target: QPaintDevice, targetOffset: QPoint = QPoint(), sourceRegion: QRegion = QRegion(), flags: QWidget.RenderFlag = QWidget.RenderFlags(QWidget.DrawWindowBackground | QWidget.DrawChildren))

render(self, painter: QPainter, targetOffset: QPoint = QPoint(), sourceRegion: QRegion = QRegion(), flags: QWidget.RenderFlag = QWidget.RenderFlags(QWidget.DrawWindowBackground | QWidget.DrawChildren)) → None

repaint(self)

repaint(self, x: int, y: int, w: int, h: int) → None

repaint(self, a0: QRect) → None

repaint(self, a0: QRegion) → None

reportValidation(results)

Present validation messages to the user. This is an implmentation of the ValidationMixin interface and does not need to be called directly.

This method assumes that error and question methods have been defined in the subclass, as in e.g. widget_mixins.MessageBoxMixin.

Parameters

results (validation.ValidationResults) – Set of validation results generated by validate

Returns

if True, there were no validation errors and the user decided to continue despite any warnings. If False, there was at least one validation error or the user decided to abort when faced with a warning.

resetMappedParams()

resize(self, a0: QSize)

resize(self, w: int, h: int) → None

resizeEvent(self, a0: QResizeEvent)

restoreGeometry(self, geometry: QByteArray) → bool

runAllSlots()

runValidation(silent=False, validate_children=True, stop_on_fail=True)

Runs validation and reports the results (unless run silently).

Parameters

• silent (bool) – run without any reporting (i.e. error messages to the user). This is useful if we want to programmatically test validity. Changes return value of this method from ValidationResults to a boolean.

• validate_children (bool) – run validation on all child objects. See _validateChildren for documentation on what this entails.

• stop_on_fail (bool) – stop validation when first failure is encountered

Returns

if silent is False, returns the validation results. If silent is True, returns a boolean generated by reportValidation.

Return type

ValidationResults or bool

saveGeometry(self) → QByteArray

savePersistentOptions()

Store all persistent options to the preferences.

screen(self) → QScreen

scroll(self, dx: int, dy: int)

scroll(self, dx: int, dy: int, a2: QRect) → None

sender(self) → QObject

senderSignalIndex(self) → int

setAcceptDrops(self, on: bool)

setAccessibleDescription(self, description: str)

setAccessibleName(self, name: str)

setActiveTask(new_active_task)

Set the currently active task. Expects a task from PANEL_TASKS.

Parameters

new_active_task – Abstract task

setAlias(alias, obj, persistent=False)

Sets an alias to conveniently access an object.

Parameters

• alias (hashable) – any hashable, but typically a string name

• obj (object) – the actual object to be referenced

• persistent (bool) – whether to make the setting persistent

setAliasedValue(alias, value)

setAliases(alias_dict, persistent=False)

Sets multiple aliases at once. Already used aliases are overwritten; other existing aliases are not affected.

Parameters

• alias_dict (dict) – map of aliases to objects

• persistent (bool) – whether to make the settings persistent

setAttribute(self, attribute: Qt.WidgetAttribute, on: bool = True)

setAutoFillBackground(self, enabled: bool)

setBackgroundRole(self, a0: QPalette.ColorRole)

setBaseSize(self, basew: int, baseh: int)

setBaseSize(self, s: QSize) → None

setContentsMargins(self, left: int, top: int, right: int, bottom: int)

setContentsMargins(self, margins: QMargins) → None

setContextMenuPolicy(self, policy: Qt.ContextMenuPolicy)

setCursor(self, a0: Union[QCursor, Qt.CursorShape])

setDefaults()

@overrides: af2.App

setDisabled(self, a0: bool)

setEnabled(self, a0: bool)

setFixedHeight(self, h: int)

setFixedSize(self, a0: QSize)

setFixedSize(self, w: int, h: int) → None

setFixedWidth(self, w: int)

setFocus(self)

setFocus(self, reason: Qt.FocusReason) → None

setFocusPolicy(self, policy: Qt.FocusPolicy)

setFocusProxy(self, a0: QWidget)

setFont(self, a0: QFont)

setForegroundRole(self, a0: QPalette.ColorRole)

setGeometry(self, a0: QRect)

setGeometry(self, ax: int, ay: int, aw: int, ah: int) → None

setGraphicsEffect(self, effect: QGraphicsEffect)

setHidden(self, hidden: bool)

setInputMethodHints(self, hints: Qt.InputMethodHint)

setLayout(self, a0: QLayout)

setLayoutDirection(self, direction: Qt.LayoutDirection)

setLocale(self, locale: QLocale)

setMask(self, a0: QBitmap)

setMask(self, a0: QRegion) → None

setMaximumHeight(self, maxh: int)

setMaximumSize(self, maxw: int, maxh: int)

setMaximumSize(self, s: QSize) → None

setMaximumWidth(self, maxw: int)

setMinimumHeight(self, minh: int)

setMinimumSize(self, minw: int, minh: int)

setMinimumSize(self, s: QSize) → None

setMinimumWidth(self, minw: int)

setModelWithoutSlots(model)

This is called when this MapperMixin is a sub-widget of a parent MapperMixin. Since the slots will all be called at the end of the parent setModel, they shouldn’t be called during the sub-widget’s setModel.

setMouseTracking(self, enable: bool)

setObjValue(obj, value)

setObjectName(self, name: str)

setPalette(self, a0: QPalette)

setPanelState(state)

Resets the panel and then sets the panel to the specified state

Parameters

state (PanelState) – the panel state to set. This object should originate from a call to getPanelState()

setParent(self, parent: QWidget)

setParent(self, parent: QWidget, f: Qt.WindowType) → None

setPersistent(alias=None)

Set options to be persistent. Any options to be made persistent must be aliased, since the alias is used to form the preference key. If no alias is specified, all aliased settings will be made persistent.

Parameters

alias (str or None) – the alias to save, or None

setProperty(self, name: str, value: Any) → bool

setScreen(self, a0: QScreen)

setShortcutAutoRepeat(self, id: int, enabled: bool = True)

setShortcutEnabled(self, id: int, enabled: bool = True)

setSizeIncrement(self, w: int, h: int)

setSizeIncrement(self, s: QSize) → None

setSizePolicy(self, a0: QSizePolicy)

setSizePolicy(self, hor: QSizePolicy.Policy, ver: QSizePolicy.Policy) → None

setStandardBaseName(base_name, panel_task=None)

Set the base name used for naming tasks.

Parameters

• base_name (str) – The new base name to use

• index (tasks.AbstractTask) – The abstract panel task to set the standard basename for. Must be a member of PANEL_TASKS. If not provided, set the basename for the currently active task.

setStatusTip(self, a0: str)

setStyle(self, a0: QStyle)

setStyleSheet(self, styleSheet: str)

setTabOrder(a0: QWidget, a1: QWidget)

setTabletTracking(self, enable: bool)

setToolTip(self, a0: str)

setToolTipDuration(self, msec: int)

setUpdatesEnabled(self, enable: bool)

setVisible(self, visible: bool)

setWhatsThis(self, a0: str)

setWidgetLayout()

Set the widget layout

setWindowFilePath(self, filePath: str)

setWindowFlag(self, a0: Qt.WindowType, on: bool = True)

setWindowFlags(self, type: Qt.WindowType)

setWindowFlagsForRun()

setWindowIcon(self, icon: QIcon)

setWindowIconText(self, a0: str)

setWindowModality(self, windowModality: Qt.WindowModality)

setWindowModified(self, a0: bool)

setWindowOpacity(self, level: float)

setWindowRole(self, a0: str)

setWindowState(self, state: Qt.WindowState)

setWindowTitle(self, a0: str)

setting_model()

sharedPainter(self) → QPainter

show()

Override the show method to clear and previous value of self.accepted

showEvent(self, a0: QShowEvent)

showFullScreen(self)

showMaximized(self)

showMessageBox(*args, **kwargs)

Shows a popup message box. For parameter documentation see messagebox.MessageBox.

showMinimized(self)

showNormal(self)

signalsBlocked(self) → bool

size(self) → QSize

sizeHint(self) → QSize

sizeIncrement(self) → QSize

sizePolicy(self) → QSizePolicy

stackUnder(self, a0: QWidget)

startTimer(self, interval: int, timerType: Qt.TimerType = Qt.CoarseTimer) → int

staticMetaObject = <PyQt6.QtCore.QMetaObject object>

statusTip(self) → str

style(self) → QStyle

styleSheet(self) → str

tabletEvent(self, a0: QTabletEvent)

taskWritten

testAttribute(self, attribute: Qt.WidgetAttribute) → bool

thread(self) → QThread

timerEvent(self, a0: QTimerEvent)

toolTip(self) → str

toolTipDuration(self) → int

tr(sourceText: str, disambiguation: typing.Optional[str] = None, n: int = - 1) → str

underMouse(self) → bool

ungrabGesture(self, type: Qt.GestureType)

unsetCursor(self)

unsetLayoutDirection(self)

unsetLocale(self)

update(self)

update(self, a0: QRect) → None

update(self, a0: QRegion) → None

update(self, ax: int, ay: int, aw: int, ah: int) → None

updateGeometry(self)

updateMicroFocus(self, query: Qt.InputMethodQuery = Qt.ImQueryAll)

updatesEnabled(self) → bool

visibleRegion(self) → QRegion

warning(*args, **kwargs)

Shows a popup warning message box. For parameter documentation see messagebox.MessageBox.

whatsThis(self) → str

wheelEvent(self, a0: QWheelEvent)

width(self) → int

widthMM(self) → int

winId(self) → PyQt6.sip.voidptr

window(self) → QWidget

windowFilePath(self) → str

windowFlags(self) → Qt.WindowType

windowHandle(self) → QWindow

windowIcon(self) → QIcon

windowIconChanged

windowIconChanged(self, icon: QIcon) [signal]

windowIconText(self) → str

windowIconTextChanged

windowIconTextChanged(self, iconText: str) [signal]

windowModality(self) → Qt.WindowModality

windowOpacity(self) → float

windowRole(self) → str

windowState(self) → Qt.WindowState

windowTitle(self) → str

windowTitleChanged

windowTitleChanged(self, title: str) [signal]

windowType(self) → Qt.WindowType

writePanelState(filename=None)

Write the panel state to a JSON file

Parameters

filename (str) – the JSON filename. Defaults to “panelstate.json”

x(self) → int

y(self) → int