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()