schrodinger.tasks.taskmanager module

A TaskManager manages multiple instances of a given task class.

One main responsibility of TaskManager is to assign unique names to its task instances, which it does using a task namer. The namer uses a base name to generate unique names for subsequent task instances. There are two kinds of base names: standard base names and custom base names. Both can be used as the current base name, but they behave quite differently.

Current base name: The base name that is applied to each subsequently loaded

task. It is either the standard base name or a custom base name, and thus must be set using either setStandardBaseName or setCustomBaseName.

Standard base name: A base name that gets set as the current base name

whenever resetBaseName is called. It may be set using setStandardBaseName, which also updates the current base name. The default standard base name is the task class name.

Custom base name: A base name to use as the current base name that will be lost

when any other type of base name is specified or when resetBaseName is called. It may be set using setCustomBaseName.

class schrodinger.tasks.taskmanager.TaskManager(*args, _param_type=<object object>, **kwargs)

Bases: schrodinger.models.mappers.TargetMixin, schrodinger.models.parameters.CompoundParam


Component class for TaskManager. Is responsible for choosing the name for the next task run from the task manager. The base_name is used to construct standard names which automatically increment.


A list param that contains CompoundParam instances. Signals will be emitted any time an item in the list changes or the contents of the list itself change. See _SignalContainer and _PLPSignalContainer for information on specific signals.

NAME_NOT_UNIQUE_MSG = 'Task name is not unique.'

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
__init__(directory_management=False, **kwargs)
  • TaskClass – The task class to manage.

  • directory_management – If true, override preexisting taskdir settings with standard ones. Otherwise, respect existing settings.


Set the standard base name as the current base name and apply it to the next task.


Set a new standard base name and apply it to the next task. This base name will be used whenever resetBaseName is called.


Set a new current base name. This name does not immediately apply to the next task, and will be lost if resetBaseName is called.


Update the next tasks name to a unique name. A unique name is defined as a name that hasn’t been previously used by this taskmanager and one that doesn’t already have a directory with the same name in the current directory.

DONE = 3

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)
auto_update_model = True
auto_update_target = True
blockSignals(self, b: bool) bool
childEvent(self, a0: QChildEvent)
children(self) List[QObject]
classmethod configureParam()

Override this class method to set up the abstract param class (e.g. setParamReference on child params.)

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

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

disconnect(a0: QMetaObject.Connection) bool
disconnect(self) None
disconnectNotify(self, signal: QMetaMethod)
dynamicPropertyNames(self) List[QByteArray]
event(self, a0: QEvent) bool
eventFilter(self, a0: QObject, a1: QEvent) bool
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.


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


An instance of this class.

Return type


classmethod fromJsonImplementation(json_dict)

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


This should never be called directly.


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.


Returned abstract params must be direct child params of cls, e.g., 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

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


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


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

classmethod getSubParams()

Return a dictionary mapping subparam names to their values.


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

Override to customize initialization of concrete params.


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.

installEventFilter(self, a0: QObject)
classmethod isAbstract()

Whether the param is an “abstract” param.


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)
metaObject(self) QMetaObject
moveToThread(self, thread: QThread)
objectName(self) str

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: will return [foo, bar, atom, coord] where every item is a concrete param. will return [Foo,, 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

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)

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
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
  • 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

    def configureParam(cls):
        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
  • 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.

  • 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
startTimer(self, interval: int, timerType: Qt.TimerType = Qt.CoarseTimer) int
staticMetaObject = <PyQt6.QtCore.QMetaObject object>
thread(self) QThread
timerEvent(self, a0: QTimerEvent)

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}

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

Return type

An instance of one the classes from NATIVE_JSON_DATATYPES


Returns a JSON representation of this value object.


This should never be called directly.

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