Add initial notebook tests (#63)

* Add notebook tests first pass
* Add test-tags to all cells that need to be tested.
* Reintroduce create_new_stage() for better interactive notebook experience.

Signed-off-by: Matias Codesal <mcodesal@nvidia.com>

* Improve notebook tests and cleanup AI mess.

Signed-off-by: Matias Codesal <mcodesal@nvidia.com>

* Bug fix

Signed-off-by: Matias Codesal <mcodesal@nvidia.com>

---------

Signed-off-by: Matias Codesal <mcodesal@nvidia.com>

Author: mati-nvidia

docs/beyond-basics/active-inactive-prims.md

@@ -63,14 +63,24 @@ We can use the following Python functions to set the "active" metadata on a prim
 * `UsdPrim.IsActive()` - Return whether a prim is currently active on the stage
 
 ## Examples
++++ {"tags": ["remove-cell"]}
+>**NOTE**: Before starting make sure to run the cell below. This will install the relevant OpenUSD libraries that will be used through this notebook.
++++
+```{code-cell}
+:tags: [remove-input]
+:test-tags: [active-inactive-setup]
+from lousd.utils.helperfunctions import create_new_stage
+```
+
 
 ### Example 1: Setting Prims as Active/Inactive
 
 +++ {"tags": ["remove-cell"]}
->**NOTE**: The next cell is content setup for this example..
+>**NOTE**: The next cell is content setup for this example.
 +++
 ```{code-cell}
 :tags: [remove-input]
+:test-tags: [active-inactive-content-setup]
 
 from pxr import Usd, UsdGeom, UsdLux, UsdShade
 
@@ -102,6 +112,7 @@ stage.Save()
 In this example, we will print out the contents of a stage at the start and then see how the contents change after deactivating a prim. Here's is what the USDA for this stage looks like:
 
 ```{code-cell}
+:test-tags: [active-inactive-deactivate]
 :emphasize-lines: 15-16
 
 from pxr import Usd

docs/beyond-basics/custom-properties.md

@@ -106,7 +106,9 @@ Lastly, notice the `my_namespace:` prefix on the attribute. It's good practice t
 +++
 ```{code-cell}
 :tags: [remove-input]
+:test-tags: [custom-properties-setup]
 from lousd.utils.visualization import DisplayUSD, DisplayCode
+from lousd.utils.helperfunctions import create_new_stage
 ```
 
 ### Example 1: Creating Custom Attributes
@@ -116,6 +118,7 @@ from lousd.utils.visualization import DisplayUSD, DisplayCode
 +++
 ```{code-cell}
 :tags: [remove-input, remove-output]
+:test-tags: [custom-properties-setup-asset]
 import shutil
 # cleanup any existing copy
 try:
@@ -131,12 +134,13 @@ Custom attributes in OpenUSD are used to define additional, user-specific proper
 In this example, we will author custom attributes to add more contextual information to a package asset.
 
 ```{code-cell}
+:test-tags: [custom-properties-create-attributes]
 :emphasize-lines: 13-23
 
 from pxr import Usd, UsdGeom, Sdf
 
 file_path = "_assets/custom_attributes.usda"
-stage: Usd.Stage = Usd.Stage.CreateNew(file_path)
+stage: Usd.Stage = create_new_stage(file_path)
 
 world_xform: UsdGeom.Xform = UsdGeom.Xform.Define(stage, "/World")
 geometry_xform: UsdGeom.Xform = UsdGeom.Xform.Define(stage, world_xform.GetPath().AppendPath("Packages"))
@@ -176,7 +180,8 @@ After creating an attribute, we can set and get the value of the attribute, simi
 
 Try applying the same logic to the other attributes.
 
-```{code-cell} 
+```{code-cell}
+:test-tags: [custom-properties-modify-attributes]
 :emphasize-lines: 7-10
 
 from pxr import Usd
@@ -207,12 +212,13 @@ When working with grouped or compound data from other sources, namespace-prefixe
 Notice the double namespacing pattern `acme:sensor:temperature`. The first namespace (`acme:`) identifies the organization that created these custom properties, while the second namespace (`sensor:`) groups related properties together. This hierarchical approach allows you to both claim ownership of your custom properties and logically organize them into functional groups. It's a common pattern when mapping compound data types from other formats into USD.
 
 ```{code-cell}
+:test-tags: [custom-properties-namespaces]
 :emphasize-lines: 9-20
 
 from pxr import Usd, UsdGeom, Sdf
 
 file_path = "_assets/sensor_data.usda"
-stage: Usd.Stage = Usd.Stage.CreateNew(file_path)
+stage: Usd.Stage = create_new_stage(file_path)
 
 # Create a prim to represent a sensor device
 sensor_prim = stage.DefinePrim("/EnvironmentSensor", "Xform")

docs/beyond-basics/model-kinds.md

@@ -122,6 +122,7 @@ prim.IsModel()
 +++
 ```{code-cell}
 :tags: [remove-input]
+:test-tags: [model-kinds-setup]
 from lousd.utils.visualization import DisplayUSD, DisplayCode
 from lousd.utils.helperfunctions import create_new_stage
 ```
@@ -131,12 +132,13 @@ from lousd.utils.helperfunctions import create_new_stage
 This example shows the practical benefit of Model Kinds.  `/World` is marked as a group so children can qualify as models, `/World/Component` is classified as a component, and `/World/Markers` is left untagged. Model‑only traversal allow for edits only to the component while the markers remain untouched.
 
 ```{code-cell}
+:test-tags: [model-kinds-component-traversal]
 :emphasize-lines: 9-40
 from pxr import Usd, UsdGeom, Kind, Gf
 
 # Create stage and model root
 file_path = "_assets/model_kinds_component.usda"
-stage = Usd.Stage.CreateNew(file_path)
+stage = create_new_stage(file_path)
 world_xform = UsdGeom.Xform.Define(stage, "/World")
 stage.SetDefaultPrim(world_xform.GetPrim())
 

docs/beyond-basics/primvars.md

@@ -84,6 +84,7 @@ values = primvar.Get()
 +++
 ```{code-cell}
 :tags: [remove-input]
+:test-tags: [primvars-setup]
 from lousd.utils.visualization import DisplayUSD, DisplayCode
 from lousd.utils.helperfunctions import create_new_stage
 ```
@@ -93,12 +94,13 @@ from lousd.utils.helperfunctions import create_new_stage
 This example builds the same two‑quad mesh three times and authors the displayColor primvar with three {term}`interpolation <Interpolation>` modes: constant (one value for the whole gprim), uniform (one per face), and vertex (one per point).
 
 ```{code-cell}
+:test-tags: [primvars-displaycolor-interpolation]
 :emphasize-lines: 28-53
 from pxr import Usd, UsdGeom, Gf
 
 # Create stage and default prim
 file_path = "_assets/primvars_displaycolor.usda"
-stage = Usd.Stage.CreateNew(file_path)
+stage = create_new_stage(file_path)
 world = UsdGeom.Xform.Define(stage, "/World")
 stage.SetDefaultPrim(world.GetPrim())
 
@@ -164,6 +166,7 @@ DisplayCode(file_path)
 This example writes two vertex primvars on a quad: rest_state and deformation. It computes new points as rest_state + deformation, then {term}`time samples <Time Sample>` Mesh.points
 
 ```{code-cell}
+:test-tags: [primvars-mesh-deformation]
 :emphasize-lines: 34-57
 from pxr import Usd, UsdGeom, Sdf, Gf
 
@@ -174,7 +177,7 @@ time_code_per_second = 30
 
 # create stage and default prim
 file_path = "_assets/primvars_mesh_deformation.usda"
-stage = Usd.Stage.CreateNew(file_path)
+stage = create_new_stage(file_path)
 stage.SetStartTimeCode(start_tc)
 stage.SetEndTimeCode(end_tc)
 stage.SetTimeCodesPerSecond(time_code_per_second)

docs/beyond-basics/stage-traversal.md

@@ -108,13 +108,15 @@ BAD_predicate = Usd.PrimIsActive and Usd.PrimIsLoaded
 +++
 ```{code-cell}
 :tags: [remove-input]
+:test-tags: [stage-traversal-setup]
 from lousd.utils.visualization import DisplayUSD, DisplayCode
+from lousd.utils.helperfunctions import create_new_stage
 
 
 from pxr import Usd, UsdGeom, UsdLux, UsdShade
 
 file_path = "_assets/stage_traversal.usda"
-stage: Usd.Stage = Usd.Stage.CreateNew(file_path)
+stage: Usd.Stage = create_new_stage(file_path)
 
 world: UsdGeom.Xform = UsdGeom.Xform.Define(stage, "/World")
 stage.SetDefaultPrim(world.GetPrim())
@@ -146,6 +148,7 @@ DisplayCode(file_path)
 To traverse through the stage, we can use the [`Traverse()`](https://openusd.org/release/api/class_usd_stage.html#adba675b55f41cc1b305bed414fc4f178) method. This traversal will yield prims that are active, loaded, defined, non-abstract on the stage in depth-first order.
 
 ```{code-cell}
+:test-tags: [stage-traversal-traverse]
 :emphasize-lines: 7-10
 
 # Import the Usd module from the pxr package
@@ -169,6 +172,7 @@ For this practical example, we will traverse the stage to operate on specific pr
 We can filter based on the type of the prim. For example, we can check if the prim is of type `scope` or `xform`. To do this we pass the prim into the constructor method for the prim type we are interested in. For example,`UsdGeom.Scope(prim)` is equivalent to [`UsdGeom.Scope.Get(prim.GetStage(), prim.GetPath())`](https://openusd.org/release/api/class_usd_geom_scope.html#a538339c2aa462ebcf1eb07fed16f9be4) for a valid prim. If the prim's type does not match, it will return an invalid prim.
 
 ```{code-cell}
+:test-tags: [stage-traversal-filter-types]
 :emphasize-lines: 7-21
 
 # Import necessary modules from the pxr package
@@ -201,6 +205,7 @@ Using [`Traverse()`](https://openusd.org/release/api/class_usd_stage.html#adba67
 If you need to work within a specific scope or hierarchy in the stage, you can perform a traversal starting from a particular prim. Let's take a look at how we can traverse through the children of the default prim.
 
 ```{code-cell}
+:test-tags: [stage-traversal-children]
 :emphasize-lines: 10-13
 
 # Import the `Usd` module from the `pxr` package:
@@ -227,6 +232,7 @@ Let's see an example of [`UsdPrimRange`](https://openusd.org/release/api/class_u
 
 
 ```{code-cell}
+:test-tags: [stage-traversal-prim-range]
 :emphasize-lines: 7-9
 
 # Import the Usd module from the pxr package

docs/beyond-basics/units.md

@@ -152,7 +152,9 @@ print(f"Updated to: {UsdPhysics.GetStageKilogramsPerUnit(stage)}")
 +++
 ```{code-cell}
 :tags: [remove-input]
+:test-tags: [units-setup]
 from lousd.utils.visualization import DisplayUSD, DisplayCode
+from lousd.utils.helperfunctions import create_new_stage
 ```
 
 ### Example 1: Demonstrating metersPerUnit Composition Behavior
@@ -165,12 +167,13 @@ This example shows what happens when assets with different `metersPerUnit` value
 Both cubes represent the same real-world size—1 meter. If USD automatically converted units during composition, both cubes would appear identical when referenced into any scene regardless of that scene's `metersPerUnit`. Let's see what actually happens when we reference both into a millimeter-scale scene.
 
 ```{code-cell}
+:test-tags: [units-meters-per-unit]
 :emphasize-lines: 7,10-11,25,28-29,50-51,54-55
 from pxr import Usd, UsdGeom, Sdf, Gf
 
 # Create a cube asset in CENTIMETERS (metersPerUnit = 0.01)
 cm_asset_path = "_assets/1m_cube_centimeters.usda"
-cm_stage = Usd.Stage.CreateNew(cm_asset_path)
+cm_stage = create_new_stage(cm_asset_path)
 UsdGeom.SetStageUpAxis(cm_stage, UsdGeom.Tokens.y)
 UsdGeom.SetStageMetersPerUnit(cm_stage, 0.01)  # Centimeters
 
@@ -188,7 +191,7 @@ print(f"  -> Represents a {cube_in_cm.GetSizeAttr().Get() * UsdGeom.GetStageMete
 
 # Create a cube asset in MILLIMETERS (metersPerUnit = 0.001)
 mm_asset_path = "_assets/cube_in_millimeters.usda"
-mm_stage = Usd.Stage.CreateNew(mm_asset_path)
+mm_stage = create_new_stage(mm_asset_path)
 UsdGeom.SetStageUpAxis(mm_stage, UsdGeom.Tokens.y)
 UsdGeom.SetStageMetersPerUnit(mm_stage, 0.001)  # Millimeters
 
@@ -206,7 +209,7 @@ print(f"  -> Represents a {cube_in_mm.GetSizeAttr().Get() * UsdGeom.GetStageMete
 
 # Create a scene that references both cubes (using millimeter scale)
 scene_path = "_assets/units_mismatch_scene.usda"
-scene_stage = Usd.Stage.CreateNew(scene_path)
+scene_stage = create_new_stage(scene_path)
 UsdGeom.SetStageUpAxis(scene_stage, UsdGeom.Tokens.y)
 UsdGeom.SetStageMetersPerUnit(scene_stage, 0.001)  # Scene is in millimeters
 
@@ -253,12 +256,13 @@ print(scene_stage.ExportToString(addSourceFileComment=False))
 This example demonstrates that USD **does** automatically handle `timeCodesPerSecond` differences during composition. We'll create an animated asset at 60 fps and reference it into a 24 fps scene.
 
 ```{code-cell}
+:test-tags: [units-timecodes-per-second]
 :emphasize-lines: 8-10, 17-20, 25-27, 34-36, 52-55, 57-59, 63-67
 from pxr import Usd, UsdGeom, Gf
 
 # Create animated asset at 60 fps
 anim_asset_path = "_assets/animated_60fps.usda"
-anim_stage = Usd.Stage.CreateNew(anim_asset_path)
+anim_stage = create_new_stage(anim_asset_path)
 UsdGeom.SetStageUpAxis(anim_stage, UsdGeom.Tokens.y)
 UsdGeom.SetStageMetersPerUnit(anim_stage, 1.0)
 anim_stage.SetTimeCodesPerSecond(60)  # 60 fps
@@ -284,7 +288,7 @@ print(f"  -> Animates from x=-5 to x=5\n")
 
 # Create scene at 24 fps that references the 60fps animation
 scene_24fps_path = "_assets/units_timecode_scene.usda"
-scene_stage = Usd.Stage.CreateNew(scene_24fps_path)
+scene_stage = create_new_stage(scene_24fps_path)
 UsdGeom.SetStageUpAxis(scene_stage, UsdGeom.Tokens.y)
 UsdGeom.SetStageMetersPerUnit(scene_stage, 1.0)
 scene_stage.SetTimeCodesPerSecond(24)  # Scene is 24 fps

docs/beyond-basics/value-resolution.md

@@ -108,6 +108,7 @@ When you get an attribute value without an explicit time code, the default time
 +++
 ```{code-cell}
 :tags: [remove-input]
+:test-tags: [value-resolution-setup]
 from lousd.utils.visualization import DisplayUSD, DisplayCode
 from lousd.utils.helperfunctions import create_new_stage
 ```
@@ -117,6 +118,7 @@ from lousd.utils.helperfunctions import create_new_stage
 This example shows how a transform attribute (the `xformOp:scale` authored by `XformCommonAPI`) resolves from four sources: a {term}`fallback <Fallback>` value when no authored value exists, an authored default value, authored time sample values, and interpolated values between time samples.
 
 ```{code-cell}
+:test-tags: [value-resolution-attribute-animation]
 :emphasize-lines: 27-67
 from pxr import Usd, UsdGeom
 
@@ -208,13 +210,14 @@ Notice `Get(..., Usd.TimeCode.Default())` returns the user defined default (non
 This example composes {term}`layers <Layer>` to show two resolution rules for dictionary metadata like `customData` (per key by strength) as well as relationships `list editing semantics`.
 
 ```{code-cell}
+:test-tags: [value-resolution-customdata-relationship]
 :emphasize-lines: 37-60
 from pxr import Usd, UsdGeom
 import os
 
 # --- Layer 1 (weaker)
 layer_1_path = "_assets/value_resolution_layer_1.usda"
-layer_1_stage = Usd.Stage.CreateNew(layer_1_path)
+layer_1_stage = create_new_stage(layer_1_path)
 
 layer_1_xform = UsdGeom.Xform.Define(layer_1_stage, "/World/XformPrim")
 layer_1_xform_prim = layer_1_xform.GetPrim()
@@ -231,7 +234,7 @@ layer_1_stage.Save()
 
 # --- Layer 2 (stronger)
 layer_2_path = "_assets/value_resolution_layer_2.usda"
-layer_2_stage = Usd.Stage.CreateNew(layer_2_path)
+layer_2_stage = create_new_stage(layer_2_path)
 
 layer_2_xform = UsdGeom.Xform.Define(layer_2_stage, "/World/XformPrim")
 layer_2_xform_prim = layer_2_xform.GetPrim()
@@ -247,7 +250,7 @@ layer_2_stage.Save()
 
 # --- Composed stage. First sublayer listed (layer_2) is strongest
 composed_path = "_assets/value_resolution_composed.usda"
-composed_stage = Usd.Stage.CreateNew(composed_path)
+composed_stage = create_new_stage(composed_path)
 composed_stage.GetRootLayer().subLayerPaths = [os.path.basename(layer_2_path), os.path.basename(layer_1_path)]
 
 xform_prim = composed_stage.GetPrimAtPath("/World/XformPrim")

docs/composition-basics/default-prim.md

@@ -98,7 +98,9 @@ assert stage.GetDefaultPrim() == default_prim
 +++
 ```{code-cell}
 :tags: [remove-input]
+:test-tags: [default-prim-setup]
 from lousd.utils.visualization import DisplayUSD, DisplayCode
+from lousd.utils.helperfunctions import create_new_stage
 ```
 
 ### Example 1: Setting a Default Prim
@@ -109,12 +111,13 @@ A `defaultPrim` is layer metadata. If the stage's root layer is used as a refere
 
 
 ```{code-cell}
+:test-tags: [default-prim-set]
 :emphasize-lines: 9-10
 
 from pxr import Usd
 
 file_path = "_assets/default_prim.usda"
-stage: Usd.Stage = Usd.Stage.CreateNew(file_path)
+stage: Usd.Stage = create_new_stage(file_path)
 stage.DefinePrim("/hello")
 stage.DefinePrim("/hello/world")
 hello_prim: Usd.Prim = stage.GetPrimAtPath("/hello")