def test_GetAvailableResolvers(self):
"""Tests ArGetAvailableResolvers and ArCreateResolver APIs
via _TestResolver1 and _TestResolver2 subclasses."""
# Register test resolver plugin and verify we have the
# expected ArResolver subclasses.
pr = Plug.Registry()
plugins = pr.RegisterPlugins(testPluginsDsoSearch)
self.assertEqual(len(plugins), 1)
self.assertEqual(
set(pr.GetAllDerivedTypes('ArResolver')),
set([
Tf.Type.FindByName('ArDefaultResolver'),
Tf.Type.FindByName('_TestResolver1'),
Tf.Type.FindByName('_TestResolver2')
]))
# Set _TestResolver2 to be the preferred resolver;
# otherwise, _TestResolver1 would be initially constructed
# by the call to Ar.GetResolver() below since its typename
# comes before _TestResolver2.
Ar.SetPreferredResolver('_TestResolver2')
# Invoke Ar.GetResolver(). This will cause _TestResolver1
# and _TestResolver2 to be created. These classes test
# ArGetAvailableResolvers and ArCreateResolver internally.
resolver = Ar.GetResolver()
def setUpClass(cls):
# Force Ar to use the default resolver implementation.
Ar.SetPreferredResolver('ArDefaultResolver')
# Set up default search path for test_ResolveSearchPaths below. This
# must be done before any calls to Ar.GetResolver()
Ar.DefaultResolver.SetDefaultSearchPath(
[os.path.abspath('test1'),
os.path.abspath('test1/test2')])
def setUpClass(cls):
# Force Ar to use the default resolver implementation.
Ar.SetPreferredResolver('ArDefaultResolver')
# Set up default search path for test_ResolveSearchPaths below. This
# must be done before any calls to Ar.GetResolver()
Ar.DefaultResolver.SetDefaultSearchPath(
[os.path.abspath('test1'),
os.path.abspath('test1/test2')])
# Verify that the underlying resolver is an Ar.DefaultResolver.
assert (isinstance(Ar.GetUnderlyingResolver(), Ar.DefaultResolver))
def setUpClass(cls):
# Force Ar to use the hello resolver implementation.
Ar.SetPreferredResolver('ReplaceResolver')
# Verify that the underlying resolver is a ReplaceResolver.
assert (isinstance(Ar.GetUnderlyingResolver(),
ReplaceResolver.ReplaceResolver))
# Cleanup files from previous test
dirToRemove = os.path.abspath(TestReplaceResolver.rootDir)
if os.path.isdir(dirToRemove):
shutil.rmtree(dirToRemove)
_PrepAssets(TestReplaceResolver.rootDir,
TestReplaceResolver.assemblyRepo,
TestReplaceResolver.componentRepo)
def InitializeResolver():
"""Initialize the resolver so that search paths pointing to schema.usda
files are resolved to the directories where those files are installed"""
from pxr import Ar, Plug
# Force the use of the ArDefaultResolver so we can take advantage
# of its search path functionality.
Ar.SetPreferredResolver('ArDefaultResolver')
# Figure out where all the plugins that provide schemas are located
# and add their resource directories to the search path prefix list.
resourcePaths = set()
pr = Plug.Registry()
for t in pr.GetAllDerivedTypes('UsdSchemaBase'):
plugin = pr.GetPluginForType(t)
if plugin:
resourcePaths.add(plugin.resourcePath)
# The sorting shouldn't matter here, but we do it for consistency
# across runs.
Ar.DefaultResolver.SetDefaultSearchPath(sorted(list(resourcePaths)))
# Unless required by applicable law or agreed to in writing, software
# distributed under the Apache License with the above modification is
# distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
# KIND, either express or implied. See the Apache License for the specific
# language governing permissions and limitations under the Apache License.
import os, platform, itertools, sys, unittest
# Initialize Ar to use Sdf_TestResolver unless a different implementation
# is specified via the TEST_SDF_LAYER_RESOLVER to allow testing with other
# filesystem-based resolvers.
preferredResolver = os.environ.get("TEST_SDF_LAYER_RESOLVER",
"Sdf_TestResolver")
from pxr import Ar
Ar.SetPreferredResolver(preferredResolver)
# Import other modules from pxr after Ar to ensure we don't pull on Ar
# before the preferred resolver has been specified.
from pxr import Sdf, Tf, Plug
class TestSdfLayer(unittest.TestCase):
@classmethod
def setUpClass(cls):
# Register dso plugins.
testRoot = os.path.join(os.path.dirname(__file__), 'SdfPlugins')
testPluginsDso = testRoot + '/lib'
testPluginsDsoSearch = testPluginsDso + '/*/Resources/'
Plug.Registry().RegisterPlugins(testPluginsDsoSearch)
def setUpClass(cls):
# These test cases make use of ArDefaultResolver's
# search path functionality.
Ar.SetPreferredResolver('ArDefaultResolver')
pr = Plug.Registry()
testResolverPath = os.path.join(
testRoot, 'lib/TestArOptionalImplementation*/Resources/')
assert pr.RegisterPlugins(testResolverPath)
parser = argparse.ArgumentParser()
parser.add_argument("resolverName", type=str,
help=("Name of ArResolver subclass to test"))
args = parser.parse_args()
SetupPlugins()
Ar.SetPreferredResolver(args.resolverName)
r = Ar.GetResolver()
# Call each method to see whether the corresponding virtual method
# on the resolver is called.
# This context manager calls ArResolver::BindContext when entered
# and ArResolver::UnbindContext on exit.
with Ar.ResolverContextBinder(Ar.ResolverContext()):
pass
r.CreateDefaultContext()
r.CreateDefaultContextForAsset('foo')
r.CreateContextFromString('foo')
r.RefreshContext(Ar.ResolverContext())
r.GetCurrentContext()
