def Execute(result):
   result["Cache"].__doc__ = """
PcpCache is the context required to make requests of the Pcp
composition algorithm and cache the results.

Because the algorithms are recursive  making a request typically makes
other internal requests to solve subproblems  caching subproblem
results is required for reasonable performance, and so this cache is
the only entrypoint to the algorithms.

There is a set of parameters that affect the composition results:

   - variant fallbacks: per named variant set, an ordered list of
     fallback values to use when composing a prim that defines a variant
     set but does not specify a selection

   - payload inclusion set: an SdfPath set used to identify which
     prims should have their payloads included during composition; this is
     the basis for explicit control over the"working set"of composition

   - file format target: the file format target that Pcp will request
     when opening scene description layers

   - "USD mode"configures the Pcp composition algorithm to provide
     only a custom, lighter subset of the full feature set, as needed by
     the Universal Scene Description system
     There are a number of different computations that can be requested.
     These include computing a layer stack from a PcpLayerStackIdentifier,
     computing a prim index or prim stack, and computing a property index.

"""
   result["Cache"].GetLayerStackIdentifier.func_doc = """GetLayerStackIdentifier() -> LayerStackIdentifier


Get the identifier of the layerStack used for composition.



"""
   result["Cache"].HasRootLayerStack.func_doc = """HasRootLayerStack(layerStack) -> bool


Return true if this cache's root layer stack is ``layerStack`` , false
otherwise.


This is functionally equivalent to comparing against the result of
GetLayerStack() , but does not require constructing a TfWeakPtr or any
refcount operations.


Parameters
----------
layerStack : LayerStack



----------------------------------------------------------------------

HasRootLayerStack(layerStack) -> bool


This is an overloaded member function, provided for convenience. It
differs from the above function only in what argument(s) it accepts.


Parameters
----------
layerStack : LayerStack


"""
   result["Cache"].GetVariantFallbacks.func_doc = """GetVariantFallbacks() -> PcpVariantFallbackMap


Get the list of fallbacks to attempt to use when evaluating variant
sets that lack an authored selection.



"""
   result["Cache"].SetVariantFallbacks.func_doc = """SetVariantFallbacks(map, changes) -> None


Set the list of fallbacks to attempt to use when evaluating variant
sets that lack an authored selection.


If ``changes`` is not ``None`` then it's adjusted to reflect the
changes necessary to see the change in standin preferences, otherwise
those changes are applied immediately.


Parameters
----------
map : PcpVariantFallbackMap

changes : PcpChanges


"""
   result["Cache"].IsPayloadIncluded.func_doc = """IsPayloadIncluded(path) -> bool


Return true if the payload is included for the given path.


Parameters
----------
path : Path


"""
   result["Cache"].RequestPayloads.func_doc = """RequestPayloads(pathsToInclude, pathsToExclude, changes) -> None


Request payloads to be included or excluded from composition.


pathsToInclude

is a set of paths to add to the set for payload inclusion.
pathsToExclude

is a set of paths to remove from the set for payload inclusion.
changes

if not ``None`` , is adjusted to reflect the changes necessary to see
the change in payloads; otherwise those changes are applied
immediately.

If a path is listed in both pathsToInclude and pathsToExclude, it will
be treated as an inclusion only.


Parameters
----------
pathsToInclude : SdfPathSet

pathsToExclude : SdfPathSet

changes : PcpChanges


"""
   result["Cache"].RequestLayerMuting.func_doc = """RequestLayerMuting(layersToMute, layersToUnmute, changes, newLayersMuted, newLayersUnmuted) -> None


Request layers to be muted or unmuted in this cache.


Muted layers are ignored during composition and do not appear in any
layer stacks. The root layer of this stage may not be muted;
attempting to do so will generate a coding error. If the root layer of
a reference or payload layer stack is muted, the behavior is as if the
muted layer did not exist, which means a composition error will be
generated.

A canonical identifier for each layer in ``layersToMute`` will be
computed using ArResolver::CreateIdentifier using the cache's root
layer as the anchoring asset. Any layer encountered during composition
with the same identifier will be considered muted and ignored.

Note that muting a layer will cause this cache to release all
references to that layer. If no other client is holding on to
references to that layer, it will be unloaded. In this case, if there
are unsaved edits to the muted layer, those edits are lost.  Since
anonymous layers are not serialized, muting an anonymous layer will
cause that layer and its contents to be lost in this case.

If ``changes`` is not ``nullptr`` , it is adjusted to reflect the
changes necessary to see the change in muted layers. Otherwise, those
changes are applied immediately.

``newLayersMuted`` and ``newLayersUnmuted`` contains the pruned vector
of layers which are muted or unmuted by this call to
RequestLayerMuting.


Parameters
----------
layersToMute : list[str]

layersToUnmute : list[str]

changes : PcpChanges

newLayersMuted : list[str]

newLayersUnmuted : list[str]


"""
   result["Cache"].GetMutedLayers.func_doc = """GetMutedLayers() -> list[str]


Returns the list of canonical identifiers for muted layers in this
cache.


See documentation on RequestLayerMuting for more details.



"""
   result["Cache"].IsLayerMuted.func_doc = """IsLayerMuted(layerIdentifier) -> bool


Returns true if the layer specified by ``layerIdentifier`` is muted in
this cache, false otherwise.


If ``layerIdentifier`` is relative, it is assumed to be relative to
this cache's root layer. See documentation on RequestLayerMuting for
more details.


Parameters
----------
layerIdentifier : str



----------------------------------------------------------------------

IsLayerMuted(anchorLayer, layerIdentifier, canonicalMutedLayerIdentifier) -> bool


Returns true if the layer specified by ``layerIdentifier`` is muted in
this cache, false otherwise.


If ``layerIdentifier`` is relative, it is assumed to be relative to
``anchorLayer`` . If ``canonicalMutedLayerIdentifier`` is supplied, it
will be populated with the canonical identifier of the muted layer if
this function returns true. See documentation on RequestLayerMuting
for more details.


Parameters
----------
anchorLayer : Layer

layerIdentifier : str

canonicalMutedLayerIdentifier : str


"""
   result["Cache"].ComputeLayerStack.func_doc = """ComputeLayerStack(identifier, allErrors) -> LayerStack


Returns the layer stack for ``identifier`` if it exists, otherwise
creates a new layer stack for ``identifier`` .


This returns ``None`` if ``identifier`` is invalid (i.e. its root
layer is ``None`` ). ``allErrors`` will contain any errors encountered
while creating a new layer stack. It'll be unchanged if the layer
stack already existed.


Parameters
----------
identifier : LayerStackIdentifier

allErrors : list[PcpError]


"""
   result["Cache"].UsesLayerStack.func_doc = """UsesLayerStack(layerStack) -> bool


Return true if ``layerStack`` is used by this cache in its
composition, false otherwise.


Parameters
----------
layerStack : LayerStack


"""
   result["Cache"].ComputePrimIndex.func_doc = """ComputePrimIndex(primPath, allErrors) -> PrimIndex


Compute and return a reference to the cached result for the prim index
for the given path.


``allErrors`` will contain any errors encountered while performing
this operation.


Parameters
----------
primPath : Path

allErrors : list[PcpError]


"""
   result["Cache"].FindPrimIndex.func_doc = """FindPrimIndex(primPath) -> PrimIndex


Returns a pointer to the cached computed prim index for the given
path, or None if it has not been computed.


Parameters
----------
primPath : Path


"""
   result["Cache"].ComputePropertyIndex.func_doc = """ComputePropertyIndex(propPath, allErrors) -> PropertyIndex


Compute and return a reference to the cached result for the property
index for the given path.


``allErrors`` will contain any errors encountered while performing
this operation.


Parameters
----------
propPath : Path

allErrors : list[PcpError]


"""
   result["Cache"].FindPropertyIndex.func_doc = """FindPropertyIndex(propPath) -> PropertyIndex


Returns a pointer to the cached computed property index for the given
path, or None if it has not been computed.


Parameters
----------
propPath : Path


"""
   result["Cache"].ComputeRelationshipTargetPaths.func_doc = """ComputeRelationshipTargetPaths(relationshipPath, paths, localOnly, stopProperty, includeStopProperty, deletedPaths, allErrors) -> None


Compute the relationship target paths for the relationship at
``relationshipPath`` into ``paths`` .


If ``localOnly`` is ``true`` then this will compose relationship
targets from local nodes only. If ``stopProperty`` is not ``None``
then this will stop composing relationship targets at ``stopProperty``
, including ``stopProperty`` iff ``includeStopProperty`` is ``true`` .
If not ``None`` , ``deletedPaths`` will be populated with target paths
whose deletion contributed to the computed result. ``allErrors`` will
contain any errors encountered while performing this operation.


Parameters
----------
relationshipPath : Path

paths : list[SdfPath]

localOnly : bool

stopProperty : Spec

includeStopProperty : bool

deletedPaths : list[SdfPath]

allErrors : list[PcpError]


"""
   result["Cache"].ComputeAttributeConnectionPaths.func_doc = """ComputeAttributeConnectionPaths(attributePath, paths, localOnly, stopProperty, includeStopProperty, deletedPaths, allErrors) -> None


Compute the attribute connection paths for the attribute at
``attributePath`` into ``paths`` .


If ``localOnly`` is ``true`` then this will compose attribute
connections from local nodes only. If ``stopProperty`` is not ``None``
then this will stop composing attribute connections at
``stopProperty`` , including ``stopProperty`` iff
``includeStopProperty`` is ``true`` . If not ``None`` ,
``deletedPaths`` will be populated with connection paths whose
deletion contributed to the computed result. ``allErrors`` will
contain any errors encountered while performing this operation.


Parameters
----------
attributePath : Path

paths : list[SdfPath]

localOnly : bool

stopProperty : Spec

includeStopProperty : bool

deletedPaths : list[SdfPath]

allErrors : list[PcpError]


"""
   result["Cache"].GetUsedLayers.func_doc = """GetUsedLayers() -> SdfLayerHandleSet


Returns set of all layers used by this cache.



"""
   result["Cache"].GetUsedLayersRevision.func_doc = """GetUsedLayersRevision() -> int


Return a number that can be used to determine whether or not the set
of layers used by this cache may have changed or not.


For example, if one calls GetUsedLayers() and saves the
GetUsedLayersRevision() , and then later calls GetUsedLayersRevision()
again, if the number is unchanged, then GetUsedLayers() is guaranteed
to be unchanged as well.



"""
   result["Cache"].FindAllLayerStacksUsingLayer.func_doc = """FindAllLayerStacksUsingLayer(layer) -> list[PcpLayerStackPtr]


Returns every computed & cached layer stack that includes ``layer`` .


Parameters
----------
layer : Layer


"""
   result["Cache"].FindSiteDependencies.func_doc = """FindSiteDependencies(siteLayerStack, sitePath, depMask, recurseOnSite, recurseOnIndex, filterForExistingCachesOnly) -> list[PcpDependency]


Returns dependencies on the given site of scene description, as
discovered by the cached index computations.


depMask

specifies what classes of dependency to include; see
PcpDependencyFlags for details recurseOnSite

includes incoming dependencies on children of sitePath recurseOnIndex

extends the result to include all PcpCache child indexes below
discovered results filterForExistingCachesOnly

filters the results to only paths representing computed prim and
property index caches; otherwise a recursively-expanded result can
include un-computed paths that are expected to depend on the site


Parameters
----------
siteLayerStack : LayerStack

sitePath : Path

depMask : PcpDependencyFlags

recurseOnSite : bool

recurseOnIndex : bool

filterForExistingCachesOnly : bool



----------------------------------------------------------------------

FindSiteDependencies(siteLayer, sitePath, depMask, recurseOnSite, recurseOnIndex, filterForExistingCachesOnly) -> list[PcpDependency]


Returns dependencies on the given site of scene description, as
discovered by the cached index computations.


This method overload takes a site layer rather than a layer stack. It
will check every layer stack using that layer, and apply any relevant
sublayer offsets to the map functions in the returned
PcpDependencyVector.

See the other method for parameter details.


Parameters
----------
siteLayer : Layer

sitePath : Path

depMask : PcpDependencyFlags

recurseOnSite : bool

recurseOnIndex : bool

filterForExistingCachesOnly : bool


"""
   result["Cache"].IsInvalidSublayerIdentifier.func_doc = """IsInvalidSublayerIdentifier(identifier) -> bool


Returns true if ``identifier`` was used as a sublayer path in a layer
stack but did not identify a valid layer.


This is functionally equivalent to examining the values in the vector
returned by GetInvalidSublayerIdentifiers, but more efficient.


Parameters
----------
identifier : str


"""
   result["Cache"].IsInvalidAssetPath.func_doc = """IsInvalidAssetPath(resolvedAssetPath) -> bool


Returns true if ``resolvedAssetPath`` was used by a prim (e.g.


in a reference) but did not resolve to a valid asset. This is
functionally equivalent to examining the values in the map returned by
GetInvalidAssetPaths, but more efficient.


Parameters
----------
resolvedAssetPath : str


"""
   result["Cache"].HasAnyDynamicFileFormatArgumentDependencies.func_doc = """HasAnyDynamicFileFormatArgumentDependencies() -> bool


Returns true if any prim index in this cache has a dependency on a
dynamic file format argument field.





"""
   result["Cache"].IsPossibleDynamicFileFormatArgumentField.func_doc = """IsPossibleDynamicFileFormatArgumentField(field) -> bool


Returns true if the given ``field`` is the name of a field that was
composed while generating dynamic file format arguments for any prim
index in this cache.




Parameters
----------
field : str


"""
   result["Cache"].GetDynamicFileFormatArgumentDependencyData.func_doc = """GetDynamicFileFormatArgumentDependencyData(primIndexPath) -> DynamicFileFormatDependencyData


Returns the dynamic file format dependency data object for the prim
index with the given ``primIndexPath`` .


This will return an empty dependency data if either there is no cache
prim index for the path or if the prim index has no dynamic file
formats that it depends on.


Parameters
----------
primIndexPath : Path


"""
   result["Cache"].Reload.func_doc = """Reload(changes) -> None


Reload the layers of the layer stack, except session layers and
sublayers of session layers.


This will also try to load sublayers in this cache's layer stack that
could not be loaded previously. It will also try to load any
referenced or payloaded layer that could not be loaded previously.
Clients should subsequently ``Apply()`` ``changes`` to use any now-
valid layers.


Parameters
----------
changes : PcpChanges


"""
   result["Cache"].PrintStatistics.func_doc = """PrintStatistics() -> None


Prints various statistics about the data stored in this cache.



"""
   result["Cache"].__init__.func_doc = """__init__(arg1)


Parameters
----------
arg1 : Cache



----------------------------------------------------------------------

__init__(layerStackIdentifier, fileFormatTarget, usd)


Construct a PcpCache to compose results for the layer stack identified
by *layerStackIdentifier*.


If ``fileFormatTarget`` is given, Pcp will specify
``fileFormatTarget`` as the file format target when searching for or
opening a layer.

If ``usd`` is true, computation of prim indices and composition of
prim child names are performed without relocates, inherits,
permissions, symmetry, or payloads, and without populating the prim
stack and gathering its dependencies.


Parameters
----------
layerStackIdentifier : LayerStackIdentifier

fileFormatTarget : str

usd : bool


"""
   result["Dependency"].__doc__ = """
Description of a dependency.

"""
   result["DynamicFileFormatDependencyData"].__doc__ = """
Contains the necessary information for storing a prim index's
dependency on dynamic file format arguments and determining if a field
change affects the prim index. This data structure does not store the
prim index or its path itself and is expected to be the data in some
other data structure that maps prim indexes to its dependencies.

"""
   result["DynamicFileFormatDependencyData"].IsEmpty.func_doc = """IsEmpty() -> bool


Returns whether this dependency data is empty.



"""
   result["DynamicFileFormatDependencyData"].GetRelevantFieldNames.func_doc = """GetRelevantFieldNames() -> str.Set


Returns a list of field names that were composed for any of the
dependency contexts that were added to this dependency.



"""
   result["DynamicFileFormatDependencyData"].CanFieldChangeAffectFileFormatArguments.func_doc = """CanFieldChangeAffectFileFormatArguments(fieldName, oldValue, newValue) -> bool


Given a ``field`` name and the changed field values in
``oldAndNewValues`` this return whether this change can affect any of
the file format arguments generated by any of the contexts stored in
this dependency.


Parameters
----------
fieldName : str

oldValue : VtValue

newValue : VtValue


"""
   result["ErrorArcCycle"].__doc__ = """
Arcs between PcpNodes that form a cycle.

"""
   result["ErrorArcPermissionDenied"].__doc__ = """
Arcs that were not made between PcpNodes because of permission
restrictions.

"""
   result["ErrorBase"].__doc__ = """
Base class for all error types.

"""
   result["ErrorCapacityExceeded"].__doc__ = """
Exceeded the capacity for composition arcs at a single site.

"""
   result["ErrorInconsistentAttributeType"].__doc__ = """
Attributes that have specs with conflicting definitions.

"""
   result["ErrorInconsistentAttributeVariability"].__doc__ = """
Attributes that have specs with conflicting variability.

"""
   result["ErrorInconsistentPropertyType"].__doc__ = """
Properties that have specs with conflicting definitions.

"""
   result["ErrorInvalidAssetPath"].__doc__ = """
Invalid asset paths used by references or payloads.

"""
   result["ErrorInvalidAssetPathBase"].__doc__ = """"""
   result["ErrorInvalidExternalTargetPath"].__doc__ = """
Invalid target or connection path in some scope that points to an
object outside of that scope.

"""
   result["ErrorInvalidInstanceTargetPath"].__doc__ = """
Invalid target or connection path authored in an inherited class that
points to an instance of that class.

"""
   result["ErrorInvalidPrimPath"].__doc__ = """
Invalid prim paths used by references or payloads.

"""
   result["ErrorInvalidReferenceOffset"].__doc__ = """
References or payloads that use invalid layer offsets.

"""
   result["ErrorInvalidSublayerOffset"].__doc__ = """
Sublayers that use invalid layer offsets.

"""
   result["ErrorInvalidSublayerOwnership"].__doc__ = """
Sibling layers that have the same owner.

"""
   result["ErrorInvalidSublayerPath"].__doc__ = """
Asset paths that could not be both resolved and loaded.

"""
   result["ErrorInvalidTargetPath"].__doc__ = """
Invalid target or connection path.

"""
   result["ErrorMutedAssetPath"].__doc__ = """
Muted asset paths used by references or payloads.

"""
   result["ErrorOpinionAtRelocationSource"].__doc__ = """
Opinions were found at a relocation source path.

"""
   result["ErrorPrimPermissionDenied"].__doc__ = """
Layers with illegal opinions about private prims.

"""
   result["ErrorPropertyPermissionDenied"].__doc__ = """
Layers with illegal opinions about private properties.

"""
   result["ErrorSublayerCycle"].__doc__ = """
Layers that recursively sublayer themselves.

"""
   result["ErrorTargetPathBase"].__doc__ = """
Base class for composition errors related to target or connection
paths.

"""
   result["ErrorTargetPermissionDenied"].__doc__ = """
Paths with illegal opinions about private targets.

"""
   result["ErrorUnresolvedPrimPath"].__doc__ = """
Asset paths that could not be both resolved and loaded.

"""
   result["InstanceKey"].__doc__ = """
A PcpInstanceKey identifies instanceable prim indexes that share the
same set of opinions. Instanceable prim indexes with equal instance
keys are guaranteed to have the same opinions for name children and
properties beneath those name children. They are NOT guaranteed to
have the same opinions for direct properties of the prim indexes
themselves.

"""
   result["InstanceKey"].__init__.func_doc = """__init__()




----------------------------------------------------------------------

__init__(primIndex)


Create an instance key for the given prim index.


Parameters
----------
primIndex : PrimIndex


"""
   result["LayerStack"].__doc__ = """
Represents a stack of layers that contribute opinions to composition.

Each PcpLayerStack is identified by a PcpLayerStackIdentifier. This
identifier contains all of the parameters needed to construct a layer
stack, such as the root layer, session layer, and path resolver
context.

PcpLayerStacks are constructed and managed by a
Pcp_LayerStackRegistry.

"""
   result["LayerStackIdentifier"].__doc__ = """
Arguments used to identify a layer stack.

Objects of this type are immutable.

"""
   result["LayerStackIdentifier"].__init__.func_doc = """__init__()


Construct with all empty pointers.




----------------------------------------------------------------------

__init__(rootLayer_, sessionLayer_, pathResolverContext_)


Construct with given pointers.


If all arguments are ``TfNullPtr`` then the result is identical to the
default constructed object.


Parameters
----------
rootLayer_ : Layer

sessionLayer_ : Layer

pathResolverContext_ : ResolverContext


"""
   result["LayerStackSite"].__doc__ = """
A site specifies a path in a layer stack of scene description.

"""
   result["MapExpression"].__doc__ = """
An expression that yields a PcpMapFunction value.

Expressions comprise constant values, variables, and operators applied
to sub-expressions. Expressions cache their computed values
internally. Assigning a new value to a variable automatically
invalidates the cached values of dependent expressions. Common
(sub-)expressions are automatically detected and shared.

PcpMapExpression exists solely to support efficient incremental
handling of relocates edits. It represents a tree of the namespace
mapping operations and their inputs, so we can narrowly redo the
computation when one of the inputs changes.

"""
   result["MapExpression"].Compose.func_doc = """Compose(f) -> MapExpression


Create a new PcpMapExpression representing the application of f's
value, followed by the application of this expression's value.


Parameters
----------
f : MapExpression


"""
   result["MapExpression"].Inverse.func_doc = """Inverse() -> MapExpression


Create a new PcpMapExpression representing the inverse of f.



"""
   result["MapExpression"].AddRootIdentity.func_doc = """AddRootIdentity() -> MapExpression


Return a new expression representing this expression with an added (if
necessary) mapping from</>to</>.



"""
   result["MapExpression"].Identity.func_doc = """**classmethod** Identity() -> MapExpression


Return an expression representing PcpMapFunction::Identity() .



"""
   result["MapExpression"].Constant.func_doc = """**classmethod** Constant(constValue) -> MapExpression


Create a new constant.


Parameters
----------
constValue : Value


"""
   result["MapExpression"].MapSourceToTarget.func_doc = """MapSourceToTarget(path) -> Path


Map a path in the source namespace to the target.


If the path is not in the domain, returns an empty path.


Parameters
----------
path : Path


"""
   result["MapExpression"].MapTargetToSource.func_doc = """MapTargetToSource(path) -> Path


Map a path in the target namespace to the source.


If the path is not in the co-domain, returns an empty path.


Parameters
----------
path : Path


"""
   result["MapExpression"].Evaluate.func_doc = """Evaluate() -> Value


Evaluate this expression, yielding a PcpMapFunction value.


The computed result is cached. The return value is a reference to the
internal cached value. The cache is automatically invalidated as
needed.



"""
   result["MapExpression"].__init__.func_doc = """__init__()


Default-construct a None expression.




----------------------------------------------------------------------

__init__(node)


Parameters
----------
node : _Node


"""
   result["MapFunction"].__doc__ = """
A function that maps values from one namespace (and time domain) to
another. It represents the transformation that an arc such as a
reference arc applies as it incorporates values across the arc.

Take the example of a reference arc, where a source path</Model>is
referenced as a target path,</Model_1>. The source path</Model>is the
source of the opinions; the target path</Model_1>is where they are
incorporated in the scene. Values in the model that refer to paths
relative to</Model>must be transformed to be relative
to</Model_1>instead. The PcpMapFunction for the arc provides this
service.

Map functions have a specific *domain*, or set of values they can
operate on. Any values outside the domain cannot be mapped. The domain
precisely tracks what areas of namespace can be referred to across
various forms of arcs.

Map functions can be chained to represent a series of map operations
applied in sequence. The map function represent the cumulative effect
as efficiently as possible. For example, in the case of a chained
reference from</Model>to</Model>to</Model>to</Model_1>, this is
effectively the same as a mapping directly from</Model>to</Model_1>.
Representing the cumulative effect of arcs in this way is important
for handling larger scenes efficiently.

Map functions can be *inverted*. Formally, map functions are
bijections (one-to-one and onto), which ensures that they can be
inverted. Put differently, no information is lost by applying a map
function to set of values within its domain; they retain their
distinct identities and can always be mapped back.

One analogy that may or may not be helpful: In the same way a
geometric transform maps a model's points in its rest space into the
world coordinates for a particular instance, a PcpMapFunction maps
values about a referenced model into the composed scene for a
particular instance of that model. But rather than translating and
rotating points, the map function shifts the values in namespace (and
time).

"""
   result["MapFunction"].__init__.func_doc = """__init__()


Construct a null function.




----------------------------------------------------------------------

__init__(sourceToTargetBegin, sourceToTargetEnd, offset, hasRootIdentity)


Parameters
----------
sourceToTargetBegin : PathPair

sourceToTargetEnd : PathPair

offset : LayerOffset

hasRootIdentity : bool


"""
   result["MapFunction"].MapSourceToTarget.func_doc = """MapSourceToTarget(path) -> Path


Map a path in the source namespace to the target.


If the path is not in the domain, returns an empty path.


Parameters
----------
path : Path


"""
   result["MapFunction"].MapTargetToSource.func_doc = """MapTargetToSource(path) -> Path


Map a path in the target namespace to the source.


If the path is not in the co-domain, returns an empty path.


Parameters
----------
path : Path


"""
   result["MapFunction"].Compose.func_doc = """Compose(f) -> MapFunction


Compose this map over the given map function.


The result will represent the application of f followed by the
application of this function.


Parameters
----------
f : MapFunction


"""
   result["MapFunction"].ComposeOffset.func_doc = """ComposeOffset(newOffset) -> MapFunction


Compose this map function over a hypothetical map function that has an
identity path mapping and ``offset`` .


This is equivalent to building such a map function and invoking
Compose() , but is faster.


Parameters
----------
newOffset : LayerOffset


"""
   result["MapFunction"].GetInverse.func_doc = """GetInverse() -> MapFunction


Return the inverse of this map function.


This returns a true inverse ``inv:`` for any path p in this function's
domain that it maps to p', inv(p') ->p.



"""
   result["MapFunction"].Identity.func_doc = """**classmethod** Identity() -> MapFunction


Construct an identity map function.



"""
   result["MapFunction"].IdentityPathMap.func_doc = """**classmethod** IdentityPathMap() -> PathMap


Returns an identity path mapping.



"""
   result["NodeRef"].__doc__ = """
PcpNode represents a node in an expression tree for compositing scene
description.

A node represents the opinions from a particular site. In addition, it
may have child nodes, representing nested expressions that are
composited over/under this node.

Child nodes are stored and composited in strength order.

Each node holds information about the arc to its parent. This captures
both the relative strength of the sub-expression as well as any value-
mapping needed, such as to rename opinions from a model to use in a
particular instance.

"""
   result["NodeRef"].GetOriginRootNode.func_doc = """GetOriginRootNode() -> NodeRef


Walk up to the root origin node for this node.


This is the very first node that caused this node to be added to the
graph. For instance, the root origin node of an implied inherit is the
original inherit node.



"""
   result["NodeRef"].GetRootNode.func_doc = """GetRootNode() -> NodeRef


Walk up to the root node of this expression.



"""
   result["NodeRef"].GetDepthBelowIntroduction.func_doc = """GetDepthBelowIntroduction() -> int


Return the number of levels of namespace this node's site is below the
level at which it was introduced by an arc.



"""
   result["NodeRef"].GetPathAtIntroduction.func_doc = """GetPathAtIntroduction() -> Path


Returns the path for this node's site when it was introduced.



"""
   result["NodeRef"].GetIntroPath.func_doc = """GetIntroPath() -> Path


Get the path that introduced this node.


Specifically, this is the path the parent node had at the level of
namespace where this node was added as a child. For a root node, this
returns the absolute root path. See also GetDepthBelowIntroduction() .



"""
   result["NodeRef"].IsRootNode.func_doc = """IsRootNode() -> bool


Returns true if this node is the root node of the prim index graph.



"""
   result["NodeRef"].IsDueToAncestor.func_doc = """IsDueToAncestor() -> bool



"""
   result["NodeRef"].CanContributeSpecs.func_doc = """CanContributeSpecs() -> bool


Returns true if this node is allowed to contribute opinions for
composition, false otherwise.



"""
   result["PrimIndex"].__doc__ = """
PcpPrimIndex is an index of the all sites of scene description that
contribute opinions to a specific prim, under composition semantics.

PcpComputePrimIndex() builds an index ("indexes") the given prim site.
At any site there may be scene description values expressing arcs that
represent instructions to pull in further scene description.
PcpComputePrimIndex() recursively follows these arcs, building and
ordering the results.

"""
   result["PrimIndex"].GetNodeProvidingSpec.func_doc = """GetNodeProvidingSpec(primSpec) -> NodeRef


Returns the node that brings opinions from ``primSpec`` into this prim
index.


If no such node exists, returns an invalid PcpNodeRef.


Parameters
----------
primSpec : PrimSpec



----------------------------------------------------------------------

GetNodeProvidingSpec(layer, path) -> NodeRef


Returns the node that brings opinions from the Sd prim spec at
``layer`` and ``path`` into this prim index.


If no such node exists, returns an invalid PcpNodeRef.


Parameters
----------
layer : Layer

path : Path


"""
   result["PrimIndex"].PrintStatistics.func_doc = """PrintStatistics() -> None


Prints various statistics about this prim index.



"""
   result["PrimIndex"].DumpToString.func_doc = """DumpToString(includeInheritOriginInfo, includeMaps) -> str


Dump the prim index contents to a string.


If ``includeInheritOriginInfo`` is ``true`` , output for implied
inherit nodes will include information about the originating inherit
node. If ``includeMaps`` is ``true`` , output for each node will
include the mappings to the parent and root node.


Parameters
----------
includeInheritOriginInfo : bool

includeMaps : bool


"""
   result["PrimIndex"].DumpToDotGraph.func_doc = """DumpToDotGraph(filename, includeInheritOriginInfo, includeMaps) -> None


Dump the prim index in dot format to the file named ``filename`` .


See Dump(\\.\\.\\.) for information regarding arguments.


Parameters
----------
filename : str

includeInheritOriginInfo : bool

includeMaps : bool


"""
   result["PrimIndex"].ComputePrimChildNames.func_doc = """ComputePrimChildNames(nameOrder, prohibitedNameSet) -> None


Compute the prim child names for the given path.


``errors`` will contain any errors encountered while performing this
operation.


Parameters
----------
nameOrder : list[TfToken]

prohibitedNameSet : PcpTokenSet


"""
   result["PrimIndex"].ComputePrimPropertyNames.func_doc = """ComputePrimPropertyNames(nameOrder) -> None


Compute the prim property names for the given path.


``errors`` will contain any errors encountered while performing this
operation. The ``nameOrder`` vector must not contain any duplicate
entries.


Parameters
----------
nameOrder : list[TfToken]


"""
   result["PrimIndex"].ComposeAuthoredVariantSelections.func_doc = """ComposeAuthoredVariantSelections() -> SdfVariantSelectionMap


Compose the authored prim variant selections.


These are the variant selections expressed in scene description. Note
that these selections may not have actually been applied, if they are
invalid.

This result is not cached, but computed each time.



"""
   result["PrimIndex"].GetSelectionAppliedForVariantSet.func_doc = """GetSelectionAppliedForVariantSet(variantSet) -> str


Return the variant selection applied for the named variant set.


If none was applied, this returns an empty string. This can be
different from the authored variant selection; for example, if the
authored selection is invalid.


Parameters
----------
variantSet : str


"""
   result["PrimIndex"].IsValid.func_doc = """IsValid() -> bool


Return true if this index is valid.


A default-constructed index is invalid.



"""
   result["PrimIndex"].IsInstanceable.func_doc = """IsInstanceable() -> bool


Returns true if this prim index is instanceable.


Instanceable prim indexes with the same instance key are guaranteed to
have the same set of opinions, but may not have local opinions about
name children.

PcpInstanceKey



"""
   result["PropertyIndex"].__doc__ = """
PcpPropertyIndex is an index of all sites in scene description that
contribute opinions to a specific property, under composition
semantics.

"""
   result["Site"].__doc__ = """
A site specifies a path in a layer stack of scene description.

"""
   result["Cache"].layerStack = property(result["Cache"].layerStack.fget, result["Cache"].layerStack.fset, result["Cache"].layerStack.fdel, """type : LayerStack


Get the layer stack for GetLayerStackIdentifier() .


Note that this will neither compute the layer stack nor report errors.
So if the layer stack has not been computed yet this will return
``None`` . Use ComputeLayerStack() if you need to compute the layer
stack if it hasn't been computed already and/or get errors caused by
computing the layer stack.

""")
   result["Cache"].fileFormatTarget = property(result["Cache"].fileFormatTarget.fget, result["Cache"].fileFormatTarget.fset, result["Cache"].fileFormatTarget.fdel, """type : str


Returns the file format target this cache is configured for.

""")
   result["LayerStack"].identifier = property(result["LayerStack"].identifier.fget, result["LayerStack"].identifier.fset, result["LayerStack"].identifier.fdel, """type : LayerStackIdentifier


Returns the identifier for this layer stack.

""")
   result["LayerStack"].layers = property(result["LayerStack"].layers.fget, result["LayerStack"].layers.fset, result["LayerStack"].layers.fdel, """type : list[SdfLayerRefPtr]


Returns the layers in this layer stack in strong-to-weak order.


Note that this is only the *local* layer stack  it does not include
any layers brought in by references inside prims.

""")
   result["LayerStack"].layerTree = property(result["LayerStack"].layerTree.fget, result["LayerStack"].layerTree.fset, result["LayerStack"].layerTree.fdel, """type : LayerTree


Returns the layer tree representing the structure of this layer stack.

""")
   result["LayerStack"].mutedLayers = property(result["LayerStack"].mutedLayers.fget, result["LayerStack"].mutedLayers.fset, result["LayerStack"].mutedLayers.fdel, """type : set[str]


Returns the set of layers that were muted in this layer stack.

""")
   result["LayerStack"].localErrors = property(result["LayerStack"].localErrors.fget, result["LayerStack"].localErrors.fset, result["LayerStack"].localErrors.fdel, """type : list[PcpError]


Return the list of errors local to this layer stack.

""")
   result["LayerStack"].relocatesSourceToTarget = property(result["LayerStack"].relocatesSourceToTarget.fget, result["LayerStack"].relocatesSourceToTarget.fset, result["LayerStack"].relocatesSourceToTarget.fdel, """type : SdfRelocatesMap


Returns relocation source-to-target mapping for this layer stack.


This map combines the individual relocation entries found across all
layers in this layer stack; multiple entries that affect a single prim
will be combined into a single entry. For instance, if this layer
stack contains relocations { /A: /B} and { /A/C: /A/D}, this map will
contain { /A: /B} and { /B/C: /B/D}. This allows consumers to go from
unrelocated namespace to relocated namespace in a single step.

""")
   result["LayerStack"].relocatesTargetToSource = property(result["LayerStack"].relocatesTargetToSource.fget, result["LayerStack"].relocatesTargetToSource.fset, result["LayerStack"].relocatesTargetToSource.fdel, """type : SdfRelocatesMap


Returns relocation target-to-source mapping for this layer stack.


See GetRelocatesSourceToTarget for more details.

""")
   result["LayerStack"].incrementalRelocatesSourceToTarget = property(result["LayerStack"].incrementalRelocatesSourceToTarget.fget, result["LayerStack"].incrementalRelocatesSourceToTarget.fset, result["LayerStack"].incrementalRelocatesSourceToTarget.fdel, """type : SdfRelocatesMap


Returns incremental relocation source-to-target mapping for this layer
stack.


This map contains the individual relocation entries found across all
layers in this layer stack; it does not combine ancestral entries with
descendant entries. For instance, if this layer stack contains
relocations { /A: /B} and { /A/C: /A/D}, this map will contain { /A:
/B} and { /A/C: /A/D}.

""")
   result["LayerStack"].incrementalRelocatesTargetToSource = property(result["LayerStack"].incrementalRelocatesTargetToSource.fget, result["LayerStack"].incrementalRelocatesTargetToSource.fset, result["LayerStack"].incrementalRelocatesTargetToSource.fdel, """type : SdfRelocatesMap


Returns incremental relocation target-to-source mapping for this layer
stack.


See GetIncrementalRelocatesTargetToSource for more details.

""")
   result["LayerStack"].pathsToPrimsWithRelocates = property(result["LayerStack"].pathsToPrimsWithRelocates.fget, result["LayerStack"].pathsToPrimsWithRelocates.fset, result["LayerStack"].pathsToPrimsWithRelocates.fdel, """type : list[SdfPath]


Returns a list of paths to all prims across all layers in this layer
stack that contained relocates.

""")
   result["MapExpression"].isIdentity = property(result["MapExpression"].isIdentity.fget, result["MapExpression"].isIdentity.fset, result["MapExpression"].isIdentity.fdel, """type : bool


Return true if the evaluated map function is the identity function.


For identity, MapSourceToTarget() always returns the path unchanged.

""")
   result["MapExpression"].timeOffset = property(result["MapExpression"].timeOffset.fget, result["MapExpression"].timeOffset.fset, result["MapExpression"].timeOffset.fdel, """type : LayerOffset


The time offset of the mapping.

""")
   result["MapExpression"].isNull = property(result["MapExpression"].isNull.fget, result["MapExpression"].isNull.fset, result["MapExpression"].isNull.fdel, """type : bool


Return true if this is a null expression.

""")
   result["MapFunction"].isNull = property(result["MapFunction"].isNull.fget, result["MapFunction"].isNull.fset, result["MapFunction"].isNull.fdel, """type : bool


Return true if this map function is the null function.


For a null function, MapSourceToTarget() always returns an empty path.

""")
   result["MapFunction"].isIdentity = property(result["MapFunction"].isIdentity.fget, result["MapFunction"].isIdentity.fset, result["MapFunction"].isIdentity.fdel, """type : bool


Return true if the map function is the identity function.


The identity function has an identity path mapping and time offset.

""")
   result["MapFunction"].isIdentityPathMapping = property(result["MapFunction"].isIdentityPathMapping.fget, result["MapFunction"].isIdentityPathMapping.fset, result["MapFunction"].isIdentityPathMapping.fdel, """type : bool


Return true if the map function uses the identity path mapping.


If true, MapSourceToTarget() always returns the path unchanged.
However, this map function may have a non-identity time offset.

""")
   result["MapFunction"].sourceToTargetMap = property(result["MapFunction"].sourceToTargetMap.fget, result["MapFunction"].sourceToTargetMap.fset, result["MapFunction"].sourceToTargetMap.fdel, """type : PathMap


The set of path mappings, from source to target.

""")
   result["MapFunction"].timeOffset = property(result["MapFunction"].timeOffset.fget, result["MapFunction"].timeOffset.fset, result["MapFunction"].timeOffset.fdel, """type : LayerOffset


The time offset of the mapping.

""")
   result["NodeRef"].arcType = property(result["NodeRef"].arcType.fget, result["NodeRef"].arcType.fset, result["NodeRef"].arcType.fdel, """type : ArcType


Returns the type of arc connecting this node to its parent node.

""")
   result["NodeRef"].mapToParent = property(result["NodeRef"].mapToParent.fget, result["NodeRef"].mapToParent.fset, result["NodeRef"].mapToParent.fdel, """type : MapExpression


Returns mapping function used to translate paths and values from this
node to its parent node.

""")
   result["NodeRef"].mapToRoot = property(result["NodeRef"].mapToRoot.fget, result["NodeRef"].mapToRoot.fset, result["NodeRef"].mapToRoot.fdel, """type : MapExpression


Returns mapping function used to translate paths and values from this
node directly to the root node.

""")
   result["NodeRef"].siblingNumAtOrigin = property(result["NodeRef"].siblingNumAtOrigin.fget, result["NodeRef"].siblingNumAtOrigin.fset, result["NodeRef"].siblingNumAtOrigin.fdel, """type : int


Returns this node's index among siblings with the same arc type at
this node's origin.

""")
   result["NodeRef"].namespaceDepth = property(result["NodeRef"].namespaceDepth.fget, result["NodeRef"].namespaceDepth.fset, result["NodeRef"].namespaceDepth.fdel, """type : int


Returns the absolute namespace depth of the node that introduced this
node.


Note that this does *not* count any variant selections.

""")
   result["NodeRef"].site = property(result["NodeRef"].site.fget, result["NodeRef"].site.fset, result["NodeRef"].site.fdel, """type : LayerStackSite


Get the site this node represents.

""")
   result["NodeRef"].path = property(result["NodeRef"].path.fget, result["NodeRef"].path.fset, result["NodeRef"].path.fdel, """type : Path


Returns the path for the site this node represents.

""")
   result["NodeRef"].layerStack = property(result["NodeRef"].layerStack.fget, result["NodeRef"].layerStack.fset, result["NodeRef"].layerStack.fdel, """type : LayerStack


Returns the layer stack for the site this node represents.

""")
   result["NodeRef"].hasSymmetry = property(result["NodeRef"].hasSymmetry.fget, result["NodeRef"].hasSymmetry.fset, result["NodeRef"].hasSymmetry.fdel, """type : None


Get/set whether this node provides any symmetry opinions, either
directly or from a namespace ancestor.

""")
   result["NodeRef"].permission = property(result["NodeRef"].permission.fget, result["NodeRef"].permission.fset, result["NodeRef"].permission.fdel, """type : Permission

----------------------------------------------------------------------

type : None


Get/set the permission for this node.


This indicates whether specs on this node can be accessed from other
nodes.

""")
   result["NodeRef"].isInert = property(result["NodeRef"].isInert.fget, result["NodeRef"].isInert.fset, result["NodeRef"].isInert.fdel, """type : bool

""")
   result["NodeRef"].isCulled = property(result["NodeRef"].isCulled.fget, result["NodeRef"].isCulled.fset, result["NodeRef"].isCulled.fdel, """type : bool

""")
   result["NodeRef"].isRestricted = property(result["NodeRef"].isRestricted.fget, result["NodeRef"].isRestricted.fset, result["NodeRef"].isRestricted.fdel, """type : bool

""")
   result["NodeRef"].hasSpecs = property(result["NodeRef"].hasSpecs.fget, result["NodeRef"].hasSpecs.fset, result["NodeRef"].hasSpecs.fdel, """type : None


Returns true if this node has opinions authored for composition, false
otherwise.

""")
   result["PrimIndex"].localErrors = property(result["PrimIndex"].localErrors.fget, result["PrimIndex"].localErrors.fset, result["PrimIndex"].localErrors.fdel, """type : list[PcpError]


Return the list of errors local to this prim.

""")
   result["PrimIndex"].rootNode = property(result["PrimIndex"].rootNode.fget, result["PrimIndex"].rootNode.fset, result["PrimIndex"].rootNode.fdel, """type : NodeRef


Returns the root node of the prim index graph.

""")
   result["PropertyIndex"].localErrors = property(result["PropertyIndex"].localErrors.fget, result["PropertyIndex"].localErrors.fset, result["PropertyIndex"].localErrors.fdel, """type : list[PcpError]


Return the list of errors local to this property.

""")