mrv.maya.nt.set.ObjectSet:
Extended and more convenient object set interface dealing with Nodes ( and
provides the original MFnSet interface as well
optparse.OptionContainer:
Abstract base class.
optparse.OptionParser:
Class attributes:
standard_option_list : [Option]
list of standard options that will be accepted by all instances
of this parser class (intended to be overridden by subclasses).
mrv.conf._FixedConfigParser:
The RawConfigParser stores options lowercase - but we do not want that
and keep the case - for this we just need to override a method
mrv.maya.nt.set.ShadingEngine:
Provides specialized methods able to deal better with shaders
than the default implementation.
mrv.maya.nt.set.ConstraintError:
Thrown if a partition does not allow objects to be added, and the addition
was not forced, and failure was not ignored as well
mrv.util.Call:
Call object encapsulating any code, thus providing a simple facade for it
:note: derive from it if a more complex call is required
mrv.util.CallAdv:
Advanced call class providing additional options:
mrv.util.CallOnDeletion:
Call the given callable object once this object is being deleted
Its usefull if you want to assure certain code to run once the parent scope
of this object looses focus
mrv.maya.mdb.CppHeaderParser:
Simplistic regex based parser which will extract information from the file
it was initialized with.
mrv.conf.DiffData:
Struct keeping data about added, removed and/or changed data
Subclasses should override some private methods to automatically utilize some
basic functionality
mrv.conf.ConfigDiffer:
Compares two configuration objects and allows retrieval of differences
mrv.doc.base.DocGenerator:
Encapsulates all functionality required to create sphinx/epydoc documentaiton
mrv.enum.Element:
Internal helper class used to represent an ordered abstract value.
mrv.util.Event:
Descriptor allowing to easily setup callbacks for classes derived from
EventSender
mrv.util.EventSender:
Base class for all classes that want to provide a common callback interface
to supply event information to clients.
mrv.automation.qa.QAWorkflow:
Represents a workflow of QAProcessBase instances and allows to query them more
conveniently
mrv.conf.ExtendedFileInterface:
Define additional methods required by the Configuration System
:warning: Additionally, readline and write must be supported - its not mentioned
here for reasons of speed
:note: override the methods with implementation
mrv.conf.ConfigFile:
file object implementation of the ExtendedFileInterface
mrv.util.DAGTree:
Adds utility functions to DirectedTree allowing to handle a directed tree like a dag
:note: currently this tree does not support instancing
:todo: add instancing support
mrv.dge.Graph:
Holds the nodes and their connections
mrv.automation.qa.QAWorkflow:
Represents a workflow of QAProcessBase instances and allows to query them more
conveniently
mrv.mdepparse.MayaFileGraph:
Contains dependnecies between maya files including utility functions
allowing to more easily find what you are looking for
mrv.interface.iChoiceDialog:
Interface allowing access to a simple confirm dialog allowing the user
to pick between a selection of choices, one of which he has to confirm
mrv.path.ConversionPath:
On windows, python represents paths with backslashes, within maya though,
these are slashes We want to keep the original representation, but allow
the methods to work nonetheless.
mrv.automation.qa.QAWorkflow:
Represents a workflow of QAProcessBase instances and allows to query them more
conveniently
mrv.util.InterfaceMaster:
Base class making the derived class an interface provider, allowing interfaces
to be set, queried and used including build-in use
mrv.dge.NodeBase:
Base class that provides support for plugs to the superclass.
mrv.dgfe.FacadeNodeBase:
Node having no own plugs, but retrieves them by querying other other nodes
and claiming its his own ones.
mrv.dgfe.GraphNodeBase:
A node wrapping a graph, allowing it to be nested within the node
All inputs and outputs on this node are purely virtual, thus they internally connect
to the wrapped graph.
mrv.automation.process.WorkflowProcessBase:
A process wrapping a workflow, allowing workflows to be nested
Derive from this class and initialize it with the workflow you would like to have wrapped
The process works by transmitting relevant calls to its underlying workflow, allowing
nodeInsideNestedWorkflow -> thisworkflow.node.plug connections
mrv.automation.process.ProcessBase:
The base class for all processes, defining a common interface
Inputs and Outputs of this node are statically described using plugs
mrv.automation.process.WorkflowProcessBase:
A process wrapping a workflow, allowing workflows to be nested
Derive from this class and initialize it with the workflow you would like to have wrapped
The process works by transmitting relevant calls to its underlying workflow, allowing
nodeInsideNestedWorkflow -> thisworkflow.node.plug connections
mrv.interface.iProgressIndicator:
Interface allowing to submit progress information
The default implementation just prints the respective messages
Additionally you may query whether the computation has been cancelled by the user
mrv.interface.iPrompt:
Prompt a value from the user, providing a default if no input is retrieved
mrv.util.InterfaceMaster.InterfaceBase:
If your interface class is derived from this base, you get access to
access to call to the number of your current caller.
mrv.util.InterfaceMaster.InterfaceDescriptor:
Descriptor handing out interfaces from our interface dict
They allow access to interfaces directly through the InterfaceMaster without calling
extra functions
mrv.maya.mdb.MFnCodeGeneratorBase:
Define the interface and common utility methods to generate a string defining
code for a given MFnMethod according to the meta data provided by an MMethodDescriptor.
mrv.maya.mdb.MMethodDescriptor:
Contains meta-information about a given method according to data read from
the MFnDatabase
mrv.maya.undo.MuteUndo:
Instantiate this class to disable the maya undo queue - on deletion, the
previous state will be restored
mrv.maya.nt.base.Node:
Common base for all maya nodes, providing access to the maya internal object
representation
Use this class to directly create a maya node of the required type
mrv.maya.nt.base.NodeFromObj:
Virtual Constructor, producing nodes as the Node does, but it will only
accept MObjects or dagpaths which are expected to be valid.
mrv.maya.nt.storage.StorageBase.PyPickleValue:
Wrapper object prividing native access to the wrapped python pickle object
and to the corresponding value plug, providing utlity methods for easier handling
mrv.automation.qa.QACheckResult:
Wrapper class declaring test results as a type that provides a simple interface
to retrieve the test results
mrv.util.Singleton:
Singleton classes can be derived from this class,
you can derive from other classes as long as Singleton comes first (and class doesn't override __new__)
mrv.cmd.base.SpawnedCommand:
Implements a command which can be started easily by specifying a class path
such as package.cmd.module.CommandClass whose instance should be started in
a standalone process.
mrv.maya.util.StandinClass:
Simple Function Object allowing to embed the name of the type as well as
the metaclass object supposed to create the actual class.
mrv.maya.undo.StartUndo:
Utility class that will push the undo stack on __init__ and pop it on __del__
mrv.maya.undo.UndoRecorder:
Utility class allowing to undo and redo operations on the python command
stack so far to be undone and redone separately and independently of maya's
undo queue.
mrv.util.WeakInstFunction:
Create a proper weak instance to an instance function by weakly binding
the instance, not the bound function object.
mrv.path.ConversionPath:
On windows, python represents paths with backslashes, within maya though,
these are slashes We want to keep the original representation, but allow
the methods to work nonetheless.
dict:
dict() -> new empty dictionary
dict(mapping) -> new dictionary initialized from a mapping object's
(key, value) pairs
dict(iterable) -> new dictionary initialized as if via:
d = {}
for k, v in iterable:
d[k] = v
dict(**kwargs) -> new dictionary initialized with the name=value pairs
in the keyword argument list.
mrv.maya.ui.util.iItemSet:
Interface allowing to dynamically add, update and remove items to a layout
to match a given input set of item ids.
mrv.dge.iPlug:
Defines an interface allowing to compare compatabilies according to types.
mrv.dgfe.OIFacadePlug:
Facade Plugs are meant to be stored on instance level overriding the respective
class level plug descriptor.
mrv.dge.plug:
Defines an interface allowing to compare compatabilies according to types.
mrv.util.MetaCopyClsMembers:
Meta class copying members from given classes onto the type to be created
it will read the following attributes from the class dict:
forbiddenMembers, overwritePrefix, __virtual_bases__
mrv.dge._NodeBaseCheckMeta:
Class checking the consistency of the nodebase class before it is being created
mrv.dgfe._OIShellMeta:
Metaclass building the method wrappers for the _FacadeShell class - not
all methods should be overridden, just the ones important to use
mrv.dgfe._IOShellMeta:
Metaclass wrapping all unfacade attributes on the plugshell trying
to get an input connection