Tf module

Summary: The Tf (Tools Foundations) module.

Tf – Tools Foundation

Exceptions:

`CppException`
`ErrorException`(*args)

Classes:

`CallContext`
`Debug`
`DiagnosticType`
`Enum`
`Error`
`MallocTag`
`NamedTemporaryFile`([suffix, prefix, dir, text])	A named temporary file which keeps the internal file handle closed.
`Notice`
`PyModuleWasLoaded`	A TfNotice that is sent when a script module is loaded.
`RefPtrTracker`	Provides tracking of `TfRefPtr` objects to particular objects.
`ScopeDescription`	This class is used to provide high-level descriptions about scopes of execution that could possibly block, or to provide relevant information about high-level action that would be useful in a crash report.
`ScriptModuleLoader`	Provides low-level facilities for shared modules with script bindings to register themselves with their dependences, and provides a mechanism whereby those script modules will be loaded when necessary.
`Singleton`
`StatusObject`
`Stopwatch`
`TemplateString`
`Tf_PyEnumWrapper`
`Tf_TestAnnotatedBoolResult`
`Tf_TestPyContainerConversions`
`Tf_TestPyOptional`
`Type`	TfType represents a dynamic runtime type.
`Warning`
`WindowsImportWrapper`()

Functions:

`Fatal`(msg)	Raise a fatal error to the Tf Diagnostic system.
`GetCodeLocation`(framesUp)	Returns a tuple (moduleName, functionName, fileName, lineNo).
`PrepareModule`(module, result)	PrepareModule(module, result) -- Prepare an extension module at import time.
`PreparePythonModule`([moduleName])	Prepare an extension module at import time.
`RaiseCodingError`(msg)	Raise a coding error to the Tf Diagnostic system.
`RaiseRuntimeError`(msg)	Raise a runtime error to the Tf Diagnostic system.
`Status`(msg[, verbose])	Issues a status update to the Tf diagnostic system.
`Warn`(msg[, template])	Issue a warning via the TfDiagnostic system.

exception pxr.Tf.CppException

exception pxr.Tf.ErrorException(*args)

class pxr.Tf.CallContext

Attributes:

`file`	char
`function`	char
`line`	int
`prettyFunction`	char

property file

char

Type: type

property function

char

Type: type

property line

int

Type: type

property prettyFunction

char

Type: type

class pxr.Tf.Debug

Methods:

`GetDebugSymbolDescription`	classmethod GetDebugSymbolDescription(name) -> str
`GetDebugSymbolDescriptions`	classmethod GetDebugSymbolDescriptions() -> str
`GetDebugSymbolNames`	classmethod GetDebugSymbolNames() -> list[str]
`IsDebugSymbolNameEnabled`	classmethod IsDebugSymbolNameEnabled(name) -> bool
`SetDebugSymbolsByName`	classmethod SetDebugSymbolsByName(pattern, value) -> list[str]
`SetOutputFile`	classmethod SetOutputFile(file) -> None

static GetDebugSymbolDescription()

classmethod GetDebugSymbolDescription(name) -> str

Get a description for the specified debug symbol.

A short description of the debug symbol is returned. This is the same description string that is embedded in the return value of GetDebugSymbolDescriptions.

Parameters: name (str) –

static GetDebugSymbolDescriptions()

classmethod GetDebugSymbolDescriptions() -> str

Get a description of all debug symbols and their purpose.

A single string describing all registered debug symbols along with short descriptions is returned.

static GetDebugSymbolNames()

classmethod GetDebugSymbolNames() -> list[str]

Get a listing of all debug symbols.

static IsDebugSymbolNameEnabled()

classmethod IsDebugSymbolNameEnabled(name) -> bool

True if the specified debug symbol is set.

Parameters: name (str) –

static SetDebugSymbolsByName()

classmethod SetDebugSymbolsByName(pattern, value) -> list[str]

Set registered debug symbols matching pattern to value .

All registered debug symbols matching pattern are set to value . The only matching is an exact match with pattern , or if pattern ends with an’*’as is otherwise a prefix of a debug symbols. The names of all debug symbols set by this call are returned as a vector.

Parameters

pattern (str) –
value (bool) –

static SetOutputFile()

classmethod SetOutputFile(file) -> None

Direct debug output to either stdout or stderr.

Note that file MUST be either stdout or stderr. If not, issue an error and do nothing. Debug output is issued to stdout by default. If the environment variable TF_DEBUG_OUTPUT_FILE is set to’stderr’, then output is issued to stderr by default.

Parameters: file (FILE) –

class pxr.Tf.DiagnosticType

Methods:

GetValueFromName

Attributes:

allValues

static GetValueFromName()

allValues = (Tf.TF_DIAGNOSTIC_CODING_ERROR_TYPE, Tf.TF_DIAGNOSTIC_FATAL_CODING_ERROR_TYPE, Tf.TF_DIAGNOSTIC_RUNTIME_ERROR_TYPE, Tf.TF_DIAGNOSTIC_FATAL_ERROR_TYPE, Tf.TF_DIAGNOSTIC_NONFATAL_ERROR_TYPE, Tf.TF_DIAGNOSTIC_WARNING_TYPE, Tf.TF_DIAGNOSTIC_STATUS_TYPE, Tf.TF_APPLICATION_EXIT_TYPE)

class pxr.Tf.Enum

Methods:

GetValueFromFullName

classmethod GetValueFromFullName(fullname, foundIt) -> Enum

static GetValueFromFullName()

classmethod GetValueFromFullName(fullname, foundIt) -> Enum

Returns the enumerated value for a fully-qualified name.

This takes a fully-qualified enumerated value name (e.g., "Season::WINTER" ) and returns the associated value. If there is no such name, this returns -1. Since -1 can sometimes be a valid value, the foundIt flag pointer, if not None , is set to true if the name was found and false otherwise. Also, since this is not a templated function, it has to return a generic value type, so we use TfEnum .

Parameters

fullname (str) –
foundIt (bool) –

class pxr.Tf.Error

Classes:

Mark

Attributes:

`errorCode`	The error code posted for this error.
`errorCodeString`	The error code posted for this error, as a string.

class Mark

Methods:

`Clear`
`GetErrors`	A list of the errors held by this mark.
`IsClean`
`SetMark`

Clear()

GetErrors(): A list of the errors held by this mark.

IsClean()

SetMark()

property errorCode: The error code posted for this error.

property errorCodeString: The error code posted for this error, as a string.

class pxr.Tf.MallocTag

Classes:

CallTree

Methods:

`GetCallStacks`
`GetCallTree`	classmethod GetCallTree(tree, skipRepeated) -> bool
`GetMaxTotalBytes`	classmethod GetMaxTotalBytes() -> int
`GetTotalBytes`	classmethod GetTotalBytes() -> int
`Initialize`	classmethod Initialize(errMsg) -> bool
`IsInitialized`	classmethod IsInitialized() -> bool
`SetCapturedMallocStacksMatchList`	classmethod SetCapturedMallocStacksMatchList(matchList) -> None
`SetDebugMatchList`	classmethod SetDebugMatchList(matchList) -> None

class CallTree

Classes:

`CallSite`
`PathNode`

Methods:

`GetCallSites`
`GetPrettyPrintString`
`GetRoot`
`LogReport`
`Report`

class CallSite

Attributes:

`nBytes`
`name`

property nBytes

property name

class PathNode

Methods:

GetChildren

Attributes:

`nAllocations`
`nBytes`
`nBytesDirect`
`siteName`

GetChildren()

property nAllocations

property nBytes

property nBytesDirect

property siteName

GetCallSites()

GetPrettyPrintString()

GetRoot()

LogReport()

Report()

static GetCallStacks()

static GetCallTree()

classmethod GetCallTree(tree, skipRepeated) -> bool

Return a snapshot of memory usage.

Returns a snapshot by writing into \*tree . See the C *tree structure for documentation. If Initialize() has not been called, *tree is set to a rather blank structure (empty vectors, empty strings, zero in all integral fields) and false is returned; otherwise, \*tree is set with the contents of the current memory snapshot and true is returned. It is fine to call this function on the same \*tree instance; each call simply overwrites the data from the last call. If /p skipRepeated is true , then any repeated callsite is skipped. See the CallTree documentation for more details.

Parameters

tree (CallTree) –
skipRepeated (bool) –

static GetMaxTotalBytes()

classmethod GetMaxTotalBytes() -> int

Return the maximum total number of bytes that have ever been allocated at one time.

This is simply the maximum value of GetTotalBytes() since Initialize() was called.

static GetTotalBytes()

classmethod GetTotalBytes() -> int

Return total number of allocated bytes.

The current total memory that has been allocated and not freed is returned. Memory allocated before calling Initialize() is not accounted for.

static Initialize()

classmethod Initialize(errMsg) -> bool

Initialize the memory tagging system.

This function returns true if the memory tagging system can be successfully initialized or it has already been initialized. Otherwise, \*errMsg is set with an explanation for the failure.

Until the system is initialized, the various memory reporting calls will indicate that no memory has been allocated. Note also that memory allocated prior to calling Initialize() is not tracked i.e. all data refers to allocations that happen subsequent to calling Initialize() .

Parameters: errMsg (str) –

static IsInitialized()

classmethod IsInitialized() -> bool

Return true if the tagging system is active.

If Initialize() has been successfully called, this function returns true .

static SetCapturedMallocStacksMatchList()

classmethod SetCapturedMallocStacksMatchList(matchList) -> None

Sets the tags to trace.

When memory is allocated for any tag that matches matchList a stack trace is recorded. When that memory is released the stack trace is discarded. Clients can call GetCapturedMallocStacks() to get a list of all recorded stack traces. This is useful for finding leaks.

Traces recorded for any tag that will no longer be matched are discarded by this call. Traces recorded for tags that continue to be matched are retained.

matchList is a comma, tab or newline separated list of malloc tag names. The names can have internal spaces but leading and trailing spaces are stripped. If a name ends in’*’then the suffix is wildcarded. A name can have a leading’-‘or’+’to prevent or allow a match. Each name is considered in order and later matches override earlier matches. For example,’Csd*, -CsdScene::_Populate*, +CsdScene::_PopulatePrimCacheLocal’matches any malloc tag starting with’Csd’but nothing starting with’CsdScene::_Populate’except’CsdScene::_PopulatePrimCacheLocal’. Use the empty string to disable stack capturing.

Parameters: matchList (str) –

static SetDebugMatchList()

classmethod SetDebugMatchList(matchList) -> None

Sets the tags to trap in the debugger.

When memory is allocated or freed for any tag that matches matchList the debugger trap is invoked. If a debugger is attached the program will stop in the debugger, otherwise the program will continue to run. See ArchDebuggerTrap() and ArchDebuggerWait() .

matchList is a comma, tab or newline separated list of malloc tag names. The names can have internal spaces but leading and trailing spaces are stripped. If a name ends in’*’then the suffix is wildcarded. A name can have a leading’-‘or’+’to prevent or allow a match. Each name is considered in order and later matches override earlier matches. For example,’Csd*, -CsdScene::_Populate*, +CsdScene::_PopulatePrimCacheLocal’matches any malloc tag starting with’Csd’but nothing starting with’CsdScene::_Populate’except’CsdScene::_PopulatePrimCacheLocal’. Use the empty string to disable debugging traps.

Parameters: matchList (str) –

class pxr.Tf.NamedTemporaryFile(suffix='', prefix='', dir=None, text=False)

A named temporary file which keeps the internal file handle closed. A class which constructs a temporary file(that isn’t open) on __enter__, provides its name as an attribute, and deletes it on __exit__.

Note: The constructor args for this object match those of python’s tempfile.mkstemp() function, and will have the same effect on the underlying file created.

Attributes:

name

The path for the temporary file created.

property name: The path for the temporary file created.

class pxr.Tf.Notice

Classes:

Listener

Represents the Notice connection between senders and receivers of notices.

Methods:

`Register`(noticeType, callback, sender)	noticeType : Tf.Notice callback : function sender : object
`RegisterGlobally`(noticeType, callback)	noticeType : Tf.Notice callback : function
`Send`	Send(sender)
`SendGlobally`	SendGlobally()

class Listener

Represents the Notice connection between senders and receivers of notices. When a Listener object expires the connection is broken. You can also use the Revoke() function to break the connection. A Listener object is returned from the Register() and RegisterGlobally() functions.

Methods:

Revoke

Revoke()

Revoke()

Revoke()

Revoke interest by a notice listener. This function revokes interest in the particular notice type and call-back method that its Listener object was registered for.

static Register(noticeType, callback, sender) → Listener

noticeType : Tf.Notice callback : function sender : object

Register a listener as being interested in a TfNotice type from a specific sender. Notice listener will get sender as an argument. Registration of interest in a notice class N automatically registers interest in all classes derived from N. When a notice of appropriate type is received, the listening object’s member-function method is called with the notice. To reverse the registration, call Revoke() on the Listener object returned by this call.

Register( noticeType, callback, sender ) -> Listener

noticeType : Tf.Notice callback : function sender : object

Register a listener as being interested in a TfNotice type from a specific sender. Notice listener will get sender as an argument. Registration of interest in a notice class N automatically registers interest in all classes derived from N. When a notice of appropriate type is received, the listening object’s member-function method is called with the notice. To reverse the registration, call Revoke() on the Listener object returned by this call.

static RegisterGlobally(noticeType, callback) → Listener

noticeType : Tf.Notice callback : function

Register a listener as being interested in a TfNotice type from any sender. The notice listener does not get sender as an argument.

Send()

Send(sender)

sender : object

Deliver the notice to interested listeners, returning the number of interested listeners. This is the recommended form of Send. It takes the sender as an argument. Listeners that registered for the given sender AND listeners that registered globally will get the notice.

Send(sender)

sender : object

Deliver the notice to interested listeners, returning the number of interested listeners. This is the recommended form of Send. It takes the sender as an argument. Listeners that registered for the given sender AND listeners that registered globally will get the notice.

SendGlobally()

SendGlobally()

Deliver the notice to interested listeners. For most clients it is recommended to use the Send(sender) version of Send() rather than this one. Clients that use this form of Send will prevent listeners from being able to register to receive notices based on the sender of the notice. ONLY listeners that registered globally will get the notice.

class pxr.Tf.PyModuleWasLoaded

A TfNotice that is sent when a script module is loaded. Since many modules may be loaded at once, listeners are encouraged to defer work triggered by this notice to the end of an application iteration. This, of course, is good practice in general.

Methods:

name()

Return the name of the module that was loaded.

name() → str: Return the name of the module that was loaded.

class pxr.Tf.RefPtrTracker

Provides tracking of TfRefPtr objects to particular objects.

Clients can enable, at compile time, tracking of TfRefPtr objects that point to particular instances of classes derived from TfRefBase . This is useful if you have a ref counted object with a ref count that should’ve gone to zero but didn’t. This tracker can tell you every TfRefPtr that’s holding the TfRefBase and a stack trace where it was created or last assigned to.

Clients can get a report of all watched instances and how many TfRefPtr objects are holding them using ReportAllWatchedCounts() (in python use Tf.RefPtrTracker() .GetAllWatchedCountsReport()). You can see all of the stack traces using ReportAllTraces() (in python use Tf.RefPtrTracker() .GetAllTracesReport()).

Clients will typically enable tracking using code like this:

#include "pxr/base/tf/refPtrTracker.h"

class MyRefBaseType;
typedef TfRefPtr<MyRefBaseType> MyRefBaseTypeRefPtr;

TF_DECLARE_REFPTR_TRACK(MyRefBaseType);

class MyRefBaseType {
\.\.\.
public:
    static bool _ShouldWatch(const MyRefBaseType\*);
\.\.\.
};

TF_DEFINE_REFPTR_TRACK(MyRefBaseType, MyRefBaseType::_ShouldWatch);

Note that the TF_DECLARE_REFPTR_TRACK() macro must be invoked before any use of the MyRefBaseTypeRefPtr type.

The MyRefBaseType::_ShouldWatch() function returns true if the given instance of MyRefBaseType should be tracked. You can also use TfRefPtrTracker::WatchAll() to watch every instance (but that might use a lot of memory and time).

If you have a base type, B , and a derived type, D , and you hold instances of D in a TfRefPtr < ``B>`` (i.e. a pointer to the base) then you must track both type B and type D . But you can use TfRefPtrTracker::WatchNone() when tracking B if you’re not interested in instances of B .

Methods:

`GetAllTracesReport`
`GetAllWatchedCountsReport`
`GetTracesReportForWatched`

Attributes:

expired

True if this object has expired, False otherwise.

GetAllTracesReport()

GetAllWatchedCountsReport()

GetTracesReportForWatched()

property expired: True if this object has expired, False otherwise.

class pxr.Tf.ScopeDescription

This class is used to provide high-level descriptions about scopes of execution that could possibly block, or to provide relevant information about high-level action that would be useful in a crash report.

This class is reasonably fast to use, especially if the message strings are not dynamically created, however it should not be used in very highly performance sensitive contexts. The cost to push & pop is essentially a TLS lookup plus a couple of atomic operations.

Methods:

SetDescription(description)

Replace the description stack entry for this scope description.

SetDescription(description) → None

Replace the description stack entry for this scope description.

Caller guarantees that the string description lives at least as long as this TfScopeDescription object.

Parameters: description (str) –

SetDescription(description) -> None

Replace the description stack entry for this scope description.

This object adopts ownership of the rvalue description .

Parameters: description (str) –

SetDescription(description) -> None

Replace the description stack entry for this scope description.

Caller guarantees that the string description lives at least as long as this TfScopeDescription object.

Parameters: description (char) –

class pxr.Tf.ScriptModuleLoader

Provides low-level facilities for shared modules with script bindings to register themselves with their dependences, and provides a mechanism whereby those script modules will be loaded when necessary. Currently, this is when one of our script modules is loaded, when TfPyInitialize is called, and when Plug opens shared modules.

Generally, user code will not make use of this.

Methods:

`GetModuleNames`()	Return a list of all currently known modules in a valid dependency order.
`GetModulesDict`()	Return a python dict containing all currently known modules under their canonical names.
`WriteDotFile`(file)	Write a graphviz dot-file for the dependency graph of all.

Attributes:

expired

True if this object has expired, False otherwise.

GetModuleNames() → list[str]: Return a list of all currently known modules in a valid dependency order.

GetModulesDict() → python.dict: Return a python dict containing all currently known modules under their canonical names.

WriteDotFile(file) → None

Write a graphviz dot-file for the dependency graph of all.

currently known modules/modules to file.

Parameters: file (str) –

property expired: True if this object has expired, False otherwise.

class pxr.Tf.Singleton

class pxr.Tf.StatusObject

class pxr.Tf.Stopwatch

Methods:

`AddFrom`(t)	Adds the accumulated time and sample count from `t` into the `TfStopwatch` .
`Reset`()	Resets the accumulated time and the sample count to zero.
`Start`()	Record the current time for use by the next `Stop()` call.
`Stop`()	Increases the accumulated time stored in the `TfStopwatch` .

Attributes:

`microseconds`	int
`milliseconds`	int
`nanoseconds`	int
`sampleCount`	int
`seconds`	float

AddFrom(t) → None

Adds the accumulated time and sample count from t into the TfStopwatch .

If you have several timers taking measurements, and you wish to combine them together, you can add one timer’s results into another; for example, t2.AddFrom(t1) will add t1 ‘s time and sample count into t2 .

Parameters: t (Stopwatch) –

Reset() → None: Resets the accumulated time and the sample count to zero.

Start() → None

Record the current time for use by the next Stop() call.

The Start() function records the current time. A subsequent call to Start() before a call to Stop() simply records a later current time, but does not change the accumulated time of the TfStopwatch .

Stop() → None

Increases the accumulated time stored in the TfStopwatch .

The Stop() function increases the accumulated time by the duration between the current time and the last time recorded by a Start() call. A subsequent call to Stop() before another call to Start() will therefore double-count time and throw off the results.

A TfStopwatch also counts the number of samples it has taken. The”sample count”is simply the number of times that Stop() has been called.

property microseconds

int

Return the accumulated time in microseconds.

Note that 45 minutes will overflow a 32-bit counter, so take care to save the result in an int64_t , and not a regular int or long .

Type: type

property milliseconds

int

Return the accumulated time in milliseconds.

Type: type

property nanoseconds

int

Return the accumulated time in nanoseconds.

Note that this number can easily overflow a 32-bit counter, so take care to save the result in an int64_t , and not a regular int or long .

Type: type

property sampleCount

int

Return the current sample count.

The sample count, which is simply the number of calls to Stop() since creation or a call to Reset() , is useful for computing average running times of a repeated task.

Type: type

property seconds

float

Return the accumulated time in seconds as a double .

Type: type

class pxr.Tf.TemplateString

Methods:

`GetEmptyMapping`()	Returns an empty mapping for the current template.
`GetParseErrors`()	Returns any error messages generated during template parsing.
`SafeSubstitute`(arg1)	Like Substitute() , except that if placeholders are missing from the mapping, instead of raising a coding error, the original placeholder will appear in the resulting string intact.
`Substitute`(arg1)	Performs the template substitution, returning a new string.

Attributes:

`template`	str
`valid`	bool

GetEmptyMapping() → Mapping

Returns an empty mapping for the current template.

This method first calls IsValid to ensure that the template is valid.

GetParseErrors() → list[str]: Returns any error messages generated during template parsing.

SafeSubstitute(arg1) → str

Like Substitute() , except that if placeholders are missing from the mapping, instead of raising a coding error, the original placeholder will appear in the resulting string intact.

Parameters: arg1 (Mapping) –

Substitute(arg1) → str

Performs the template substitution, returning a new string.

The mapping contains keys which match the placeholders in the template. If a placeholder is found for which no mapping is present, a coding error is raised.

Parameters: arg1 (Mapping) –

property template

str

Returns the template source string supplied to the constructor.

Type: type

property valid

bool

Returns true if the current template is well formed.

Empty templates are valid.

Type: type

class pxr.Tf.Tf_PyEnumWrapper

Attributes:

`displayName`
`fullName`
`name`
`value`

property displayName

property fullName

property name

property value

class pxr.Tf.Tf_TestAnnotatedBoolResult

Attributes:

annotation

property annotation

class pxr.Tf.Tf_TestPyContainerConversions

Methods:

`GetPairTimesTwo`
`GetTokens`
`GetVectorTimesTwo`

static GetPairTimesTwo()

static GetTokens()

static GetVectorTimesTwo()

class pxr.Tf.Tf_TestPyOptional

Methods:

`TakesOptional`
`TestOptionalChar`
`TestOptionalDouble`
`TestOptionalFloat`
`TestOptionalInt`
`TestOptionalLong`
`TestOptionalShort`
`TestOptionalString`
`TestOptionalStringVector`
`TestOptionalUChar`
`TestOptionalUInt`
`TestOptionalULong`
`TestOptionalUShort`

static TakesOptional()

static TestOptionalChar()

static TestOptionalDouble()

static TestOptionalFloat()

static TestOptionalInt()

static TestOptionalLong()

static TestOptionalShort()

static TestOptionalString()

static TestOptionalStringVector()

static TestOptionalUChar()

static TestOptionalUInt()

static TestOptionalULong()

static TestOptionalUShort()

class pxr.Tf.Type

TfType represents a dynamic runtime type.

TfTypes are created and discovered at runtime, rather than compile time.

Features:

unique typename

safe across DSO boundaries

can represent C++ types, pure Python types, or Python subclasses of wrapped C++ types

lightweight value semantics you can copy and default construct TfType, unlike std::type_info .

totally ordered can use as a std::map key

Methods:

`AddAlias`	classmethod AddAlias(base, name) -> None
`Define`	classmethod Define() -> Type
`Find`	classmethod Find() -> Type
`FindByName`	classmethod FindByName(name) -> Type
`FindDerivedByName`	classmethod FindDerivedByName(name) -> Type
`GetAliases`(derivedType)	Returns a vector of the aliases registered for the derivedType under this, the base type.
`GetAllAncestorTypes`(result)	Build a vector of all ancestor types inherited by this type.
`GetAllDerivedTypes`(result)	Return the set of all types derived (directly or indirectly) from this type.
`GetRoot`	classmethod GetRoot() -> Type
`IsA`(queryType)	Return true if this type is the same as or derived from `queryType`

Attributes:

`Unknown`
`baseTypes`	list[Type]
`derivedTypes`
`isEnumType`	bool
`isPlainOldDataType`	bool
`isUnknown`	bool
`pythonClass`	TfPyObjWrapper
`sizeof`	int
`typeName`	str

AddAlias()

classmethod AddAlias(base, name) -> None

Add an alias name for this type under the given base type.

Aliases are similar to typedefs in C++: they provide an alternate name for a type. The alias is defined with respect to the given base type. Aliases must be unique with respect to both other aliases beneath that base type and names of derived types of that base.

Parameters

base (Type) –
name (str) –

AddAlias(name) -> None

Add an alias for DERIVED beneath BASE.

This is a convenience method, that declares both DERIVED and BASE as TfTypes before adding the alias.

Parameters: name (str) –

static Define()

classmethod Define() -> Type

Define a TfType with the given C++ type T and C++ base types B.

Each of the base types will be declared (but not defined) as TfTypes if they have not already been.

The typeName of the created TfType will be the canonical demangled RTTI type name, as defined by GetCanonicalTypeName() .

It is an error to attempt to define a type that has already been defined.

Define() -> Type

Define a TfType with the given C++ type T and no bases.

See the other Define() template for more details.

C++ does not allow default template arguments for function templates, so we provide this separate definition for the case of no bases.

static Find()

classmethod Find() -> Type

Retrieve the TfType corresponding to type T .

The type T must have been declared or defined in the type system or the TfType corresponding to an unknown type is returned.

IsUnknown()

Find(obj) -> Type

Retrieve the TfType corresponding to obj .

The TfType corresponding to the actual object represented by obj is returned; this may not be the object returned by TfType::Find<T>() if T is a polymorphic type.

This works for Python subclasses of the C++ type T as well, as long as T has been wrapped using TfPyPolymorphic.

Of course, the object’s type must have been declared or defined in the type system or the TfType corresponding to an unknown type is returned.

IsUnknown()

Parameters: obj (T) –

Find(t) -> Type

Retrieve the TfType corresponding to an obj with the given type_info .

Parameters: t (type_info) –

static FindByName()

classmethod FindByName(name) -> Type

Retrieve the TfType corresponding to the given name .

Every type defined in the TfType system has a unique, implementation independent name. In addition, aliases can be added to identify a type underneath a specific base type; see TfType::AddAlias() . The given name will first be tried as an alias under the root type, and subsequently as a typename.

This method is equivalent to:

TfType::GetRoot().FindDerivedByName(name)

For any object obj ,

Find(obj) == FindByName( Find(obj).GetTypeName() )

Parameters: name (str) –

FindDerivedByName()

classmethod FindDerivedByName(name) -> Type

Retrieve the TfType that derives from this type and has the given alias or typename.

AddAlias

Parameters: name (str) –

FindDerivedByName(name) -> Type

Retrieve the TfType that derives from BASE and has the given alias or typename.

This is a convenience method, and is equivalent to:

TfType::Find<BASE>().FindDerivedByName(name)

Parameters: name (str) –

GetAliases(derivedType) → list[str]

Returns a vector of the aliases registered for the derivedType under this, the base type.

AddAlias()

Parameters: derivedType (Type) –

GetAllAncestorTypes(result) → None

Build a vector of all ancestor types inherited by this type.

The starting type is itself included, as the first element of the results vector.

Types are given in”C3”resolution order, as used for new-style classes starting in Python 2.3. This algorithm is more complicated than a simple depth-first traversal of base classes, in order to prevent some subtle errors with multiple-inheritance. See the references below for more background.

This can be expensive; consider caching the results. TfType does not cache this itself since it is not needed internally.

Guido van Rossum.”Unifying types and classes in Python 2.2: Method resolution order.” http://www.python.org/download/releases/2.2.2/descrintro/#mro

Barrett, Cassels, Haahr, Moon, Playford, Withington.”A Monotonic Superclass Linearization for Dylan.”OOPSLA 96. http://www.webcom.com/haahr/dylan/linearization-oopsla96.html

Parameters: result (list[Type]) –

GetAllDerivedTypes(result) → None

Return the set of all types derived (directly or indirectly) from this type.

Parameters: result (set[Type]) –

static GetRoot()

classmethod GetRoot() -> Type

Return the root type of the type hierarchy.

All known types derive (directly or indirectly) from the root. If a type is specified with no bases, it is implicitly considered to derive from the root type.

IsA(queryType) → bool

Return true if this type is the same as or derived from queryType .

If queryType is unknown, this always returns false .

Parameters: queryType (Type) –

IsA() -> bool

Return true if this type is the same as or derived from T.

This is equivalent to:

IsA(Find<T>())

Unknown = Tf.Type.Unknown

property baseTypes

list[Type]

Return a vector of types from which this type was derived.

Type: type

property derivedTypes

property isEnumType

bool

Return true if this is an enum type.

Type: type

property isPlainOldDataType

bool

Return true if this is a plain old data type, as defined by C++.

Type: type

property isUnknown

bool

Return true if this is the unknown type, representing a type unknown to the TfType system.

The unknown type does not derive from the root type, or any other type.

Type: type

property pythonClass

TfPyObjWrapper

Return the Python class object for this type.

If this type is unknown or has not yet had a Python class defined, this will return None , as an empty TfPyObjWrapper

DefinePythonClass()

Type: type

property sizeof

int

Return the size required to hold an instance of this type on the stack (does not include any heap allocated memory the instance uses).

This is what the C++ sizeof operator returns for the type, so this value is not very useful for Python types (it will always be sizeof(boost::python::object)).

Type: type

property typeName

str

Return the machine-independent name for this type.

This name is specified when the TfType is declared.

Declare()

Type: type

class pxr.Tf.Warning

class pxr.Tf.WindowsImportWrapper

pxr.Tf.Fatal(msg): Raise a fatal error to the Tf Diagnostic system.

pxr.Tf.GetCodeLocation(framesUp)

Returns a tuple (moduleName, functionName, fileName, lineNo).

To trace the current location of python execution, use GetCodeLocation(). By default, the information is returned at the current stack-frame; thus:

info = GetCodeLocation()

will return information about the line that GetCodeLocation() was called from. One can write:

def genericDebugFacility():
    info = GetCodeLocation(1)
    # print out data


def someCode():
    ...
    if bad:
        genericDebugFacility()

and genericDebugFacility() will get information associated with its caller, i.e. the function someCode().

pxr.Tf.PrepareModule(module, result): PrepareModule(module, result) – Prepare an extension module at import time. Generally, this should only be called by the __init__.py script for a module upon loading a boost python module (generally ‘_libName.so’).

pxr.Tf.PreparePythonModule(moduleName=None)

Prepare an extension module at import time. This will import the Python module associated with the caller’s module (e.g. ‘_tf’ for ‘pxr.Tf’) or the module with the specified moduleName and copy its contents into the caller’s local namespace.

Generally, this should only be called by the __init__.py script for a module upon loading a boost python module (generally ‘_libName.so’).

pxr.Tf.RaiseCodingError(msg): Raise a coding error to the Tf Diagnostic system.

pxr.Tf.RaiseRuntimeError(msg): Raise a runtime error to the Tf Diagnostic system.

pxr.Tf.Status(msg, verbose=True)

Issues a status update to the Tf diagnostic system.

If verbose is True (the default) then information about where in the code the status update was issued from is included.

pxr.Tf.Warn(msg, template='')

Issue a warning via the TfDiagnostic system.

At this time, template is ignored.