file_path
stringlengths 21
207
| content
stringlengths 5
1.02M
| size
int64 5
1.02M
| lang
stringclasses 9
values | avg_line_length
float64 1.33
100
| max_line_length
int64 4
993
| alphanum_fraction
float64 0.27
0.93
|
|---|---|---|---|---|---|---|
omniverse-code/kit/exts/omni.graph/omni/graph/core/_impl/versions.py | """Management of version compatibility information for the extensions (where not handled by the extension manager)"""
from enum import Enum, auto
from typing import Tuple
import carb
import omni.kit.app
# Version information returned from the extension manager
VersionType = Tuple[int, int, int, str, str]
class Compatibility(Enum):
"""Potential types of version compatibility"""
Incompatible = auto()
FullyCompatible = auto()
MajorVersionCompatible = auto()
# Cached values for the current generator and target versions
__CURRENT_GENERATOR_VERSION = None
__CURRENT_TARGET_VERSION = None
# ================================================================================
def get_generator_extension_version() -> VersionType:
"""Returns the current version of the extension omni.graph.tools, raising AttributeError if it could not be found
since the fact that this script is running dictates that there should be a valid enabled version of this extension.
"""
global __CURRENT_GENERATOR_VERSION
if __CURRENT_GENERATOR_VERSION is None:
enabled_version = None
mgr = omni.kit.app.get_app().get_extension_manager()
for version in mgr.fetch_extension_versions("omni.graph.tools"):
if version["enabled"]:
enabled_version = version["version"]
if enabled_version is None:
carb.log_error("Failed to get the generator extension version")
__CURRENT_GENERATOR_VERSION = (0, 0, 0, "", "Unknown")
else:
__CURRENT_GENERATOR_VERSION = enabled_version
return __CURRENT_GENERATOR_VERSION
# ================================================================================
def get_target_extension_version() -> VersionType:
"""Returns the current version of the extension omni.graph.core, raising AttributeError if it could not be found
since the fact that this script is running dictates that there should be a valid enabled version of this extension.
"""
global __CURRENT_TARGET_VERSION
if __CURRENT_TARGET_VERSION is None:
enabled_version = None
mgr = omni.kit.app.get_app().get_extension_manager()
for version in mgr.fetch_extension_versions("omni.graph.core"):
if version["enabled"]:
enabled_version = version["version"]
if enabled_version is None:
carb.log_error("Failed to get the target extension version")
__CURRENT_TARGET_VERSION = (0, 0, 0, "", "Unknown")
else:
__CURRENT_TARGET_VERSION = enabled_version
return __CURRENT_TARGET_VERSION
# ==============================================================================================================
def check_version_compatibility(generator_version: VersionType, target_version: VersionType) -> Compatibility:
"""Checks to see how compatible the given versions are against the current extension versions enabled"""
def __version_compatibility(actual_version: VersionType, expected_version: VersionType) -> Compatibility:
"""Returns the compatibility of the two versions, assumed to reference the same extension"""
if actual_version[0] != expected_version[0]:
return Compatibility.Incompatible
if actual_version[1] != expected_version[1]:
return Compatibility.MajorVersionCompatible
return Compatibility.FullyCompatible
# The target must at least be ABI compatible or we have real trouble
if __version_compatibility(target_version, get_target_extension_version()) == Compatibility.Incompatible:
return Compatibility.Incompatible
# After that the generator is the one that determines what to do next with the generated file
return __version_compatibility(generator_version, get_generator_extension_version())
| 3,826 | Python | 44.023529 | 119 | 0.651856 |
omniverse-code/kit/exts/omni.graph/omni/graph/core/_impl/extension_information.py | """Helper to manage information about nodes, node types and their extensions"""
import json
import os
from collections import defaultdict
from typing import Dict, List, Tuple
import omni.ext
import omni.graph.core as og
import omni.kit
import omni.usd
class ExtensionInformation:
"""Class that manages information about the relationships between nodes and node types, and extensions
Public Interface:
get_node_types_by_extension()
get_nodes_by_extension()
"""
# The extension name used when a node type cannot be found in the known extension list
KEY_UNKNOWN_EXTENSION = "Unknown"
def __init__(self):
"""Initialize the caches to be empty"""
self.__known_extensions = None
# If any extension configurations change the answers change so invalidate the locally cached results
# when that happens.
hooks = omni.kit.app.get_app_interface().get_extension_manager().get_hooks()
self.__extension_enabled_hook = hooks.create_extension_state_change_hook(
self.__reset_internal_cache, omni.ext.ExtensionStateChangeType.AFTER_EXTENSION_ENABLE
)
assert self.__extension_enabled_hook
self.__extension_disabled_hook = hooks.create_extension_state_change_hook(
self.__reset_internal_cache, omni.ext.ExtensionStateChangeType.BEFORE_EXTENSION_DISABLE
)
assert self.__extension_disabled_hook
# ----------------------------------------------------------------------
def __reset_internal_cache(self, ext_id: str, *_):
"""Reset the internal cache so that it can be rebuilt later on demand"""
self.__known_extensions = None
# ----------------------------------------------------------------------
def __get_extensions_matching_node_types(self) -> Dict[str, Dict]:
"""Extract the set of node names per extension from the OGN data stored in the extension.
The data will be in the file ogn/nodes.json in the root extension directory. It contains
various information about the nodes in the extension as follows:
{
"nodes": [
{
"name": FULL_NAME_OF_NODE,
"version": VERSION_NUMBER_OF_NODE,
"description": FULL_DESCRIPTION_OF_NODE
}
]
}
The returned information is a combination of node_type:extension and extension:node_type dictionaries,
with a special entry in the latter to indicate whether the extension is currently enabled or not.
{
"extensions": {
"omni.graph.nodes": {
"enabled": true,
"nodes": ["omni.graph.node.A", "omni.graph.node.B"]
}
},
"nodes": {
"omni.graph.node.A": "omni.graph.nodes",
"omni.graph.node.B": "omni.graph.nodes"
}
}
"""
if self.__known_extensions is None: # noqa: PLR1702
extension_per_node_type = {}
self.__known_extensions = defaultdict(dict)
manager = omni.kit.app.get_app_interface().get_extension_manager()
for extension in manager.get_extensions():
node_types_per_extension = []
# If the generated node information exists, use it
node_information = os.path.join(extension["path"], "ogn", "nodes.json")
if os.path.isfile(node_information):
with open(node_information, "r", encoding="utf-8") as node_fd:
node_data = json.load(node_fd)
node_types_per_extension = list(node_data["nodes"].keys())
# If there is no generated information some nodes can still be found by searching the path
elif os.path.isdir(extension["path"]):
for root, dirs, _ in os.walk(extension["path"]):
if "ogn" in dirs:
ogn_dir = os.path.join(root, "ogn")
for ogn_root, _, ogn_files in os.walk(ogn_dir, followlinks=True):
for file_name in ogn_files:
_, ext = os.path.splitext(file_name)
if ext == ".ogn":
ogn_file = os.path.join(ogn_root, file_name)
with open(ogn_file, "r", encoding="utf-8") as ogn_fd:
ogn_json = json.load(ogn_fd)
node_name = list(ogn_json.keys())[0]
if node_name.find(".") < 0:
node_name = f"{extension['name']}.{node_name}"
node_types_per_extension.append(node_name)
break
if node_types_per_extension:
self.__known_extensions["extensions"][extension["name"]] = {
"enabled": extension["enabled"],
"nodes": node_types_per_extension,
}
extension_per_node_type.update(
{node_type: extension["name"] for node_type in node_types_per_extension}
)
self.__known_extensions["nodes"] = extension_per_node_type
# Prims may have node types attached to them that are not known to OmniGraph. They should not be in any
# of the known extensions, though that will be checked just in case something wasn't created properly.
prim_node_types = []
for _, node_type_name in self.__get_prims_with_node_types().items():
if node_type_name in extension_per_node_type:
continue
prim_node_types.append(node_type_name)
if prim_node_types:
self.__known_extensions["extensions"][self.KEY_UNKNOWN_EXTENSION] = {
"enabled": False,
"nodes": prim_node_types,
}
return dict(self.__known_extensions)
# ----------------------------------------------------------------------
def get_node_types_by_extension(self) -> Dict[str, List[str]]:
"""Returns a tuple of two dictionaries. The first is the dictionary of enabled extensions to the list of
nodes in the scene whose node types they implement, the second is the same thing for disabled extensions."""
mapping_information = self.__get_extensions_matching_node_types()["extensions"]
return (
{extension: value["nodes"] for extension, value in mapping_information.items() if value["enabled"]},
{extension: value["nodes"] for extension, value in mapping_information.items() if not value["enabled"]},
)
# ----------------------------------------------------------------------
def __get_prims_with_node_types(self) -> Dict[str, str]:
"""Returns a dictionary of non-OmniGraph prims that have the node:type attribute set.
These occur when the extension that created them is entirely unknown, possibly because
it has not been installed.
"""
prims_with_node_types = {}
for prim in omni.usd.get_context().get_stage().TraverseAll():
prim_path = str(prim.GetPath())
node_type_attribute = prim.GetAttribute("node:type")
if node_type_attribute:
prims_with_node_types[prim_path] = node_type_attribute.Get()
return prims_with_node_types
# ----------------------------------------------------------------------
def get_nodes_by_extension(self) -> Tuple[Dict[str, List[str]], Dict[str, List[str]]]:
"""Returns a tuple of three dictionaries.
- Map of enabled extensions to the list of nodes in the scene whose node types they implement
- Map of disabled extensions to the list of nodes in the scene whose node types they implement"""
mapping_information = self.__get_extensions_matching_node_types()
node_type_extensions = mapping_information["nodes"]
enabled_extensions = [
extension for extension, value in mapping_information["extensions"].items() if value["enabled"]
]
node_extensions_enabled = defaultdict(list)
node_extensions_disabled = defaultdict(list)
# Next walk all of the OmniGraph graphs to find nodes known to it
nodes_found = {}
for graph in og.get_all_graphs():
nodes_in_graph = graph.get_nodes()
for node in nodes_in_graph:
node_type_name = node.get_node_type().get_node_type()
if node_type_name is None:
# This came from an unloaded extension, but it will still have the node type information
node_type_name = og.Controller.get(og.Controller.attribute(("node:type", node)))
try:
extension = node_type_extensions[node_type_name]
except KeyError:
extension = self.KEY_UNKNOWN_EXTENSION
if extension in enabled_extensions:
node_extensions_enabled[extension].append(str(node.get_prim_path()))
else:
node_extensions_disabled[extension].append(str(node.get_prim_path()))
nodes_found[str(node.get_prim_path())] = extension
# If any of the prims haven't been found in the OmniGraph traversal, check them for the telltale
# "node:type" attribute that is present in all OmniGraph nodes and add them to the unknown extension category
for prim_path, node_type_name in self.__get_prims_with_node_types().items():
if prim_path in nodes_found:
continue
try:
extension = mapping_information["nodes"][node_type_name]
except KeyError:
extension = self.KEY_UNKNOWN_EXTENSION
if extension in enabled_extensions:
node_extensions_enabled[extension].append(prim_path)
else:
node_extensions_disabled[extension].append(prim_path)
return (dict(node_extensions_enabled), dict(node_extensions_disabled))
| 10,463 | Python | 50.80198 | 117 | 0.549842 |
omniverse-code/kit/exts/omni.graph/omni/graph/core/_impl/settings.py | """Management for the OmniGraph settings.
The setting can be checked directly using this model:
import omni.graph.core as og
if og.Settings()(og.Settings.MY_SETTING_NAME):
# the setting value is True (for a boolean setting)
else:
# the setting value if False
You can also use the class as a context manager to temporarily modify the setting:
import omni.graph.core as og
while og.Settings.temporary(og.Settings.MY_SETTING_NAME, False):
# Do something that needs the setting off
"""
from contextlib import contextmanager
from dataclasses import dataclass
from typing import Any
import carb
import omni.graph.tools as ogt
@dataclass
class Settings:
"""Class that packages up all of the OmniGraph settings handling into a common location. The settings themselves
are handled through the Carbonite settings ABI, this just provides a nicer and more focused interface.
Values here should also be reflected in the C++ OmniGraphSettings class.
"""
ALLOW_IMPLICIT_GRAPH: str = "/persistent/omnigraph/allowGlobalImplicitGraph"
"""Constant for the setting to selectively disable the global implicit graph"""
USE_SCHEMA_PRIMS: str = "/persistent/omnigraph/useSchemaPrims"
"""Constant for the setting to force OmniGraph prims to follow the schema"""
ENABLE_LEGACY_PRIM_CONNECTIONS: str = "/persistent/omnigraph/enableLegacyPrimConnections"
"""Constant for the setting to enable connections between legacy Prims and OG Nodes"""
DISABLE_PRIM_NODES: str = "/persistent/omnigraph/disablePrimNodes"
"""Constant for the setting to enable legacy Prim nodes to exist in the scene"""
VERSION: str = "/persistent/omnigraph/settingsVersion"
"""Version number of these settings"""
DEFAULT_EVALUATOR: str = "/persistent/omnigraph/defaultEvaluator"
"""Default evaluator type for new graphs"""
PRIM_NODES: str = "/persistent/omnigraph/createPrimNodes"
"""Allow creation of the deprecated Prim node type"""
UPDATE_TO_USD: str = "/persistent/omnigraph/updateToUsd"
"""Always update changes in OmniGraph to USD (can be slow)"""
UPDATE_MESH_TO_HYDRA: str = "/persistent/omnigraph/updateMeshPointsToHydra"
"""Update mesh points directly to Hydra"""
USE_DYNAMIC_SCHEDULER: str = "/persistent/omnigraph/useDynamicScheduler"
"""Force use of the dynamic scheduler"""
REALM_ENABLED: str = "/persistent/omnigraph/realmEnabled"
"""Enable use of Realm for scheduling"""
CACHED_CONNECTIONS_IN_FILE: str = "/persistent/omnigraph/useCachedConnectionsForFileLoad"
"""Use USD metadata with connection information as a cache to speed up file load"""
USE_LEGACY_PIPELINE: str = "/persistent/omnigraph/useLegacySimulationPipeline"
"""Use the pre-1.3 simulation pipeline rather than the orchestration graph"""
ENABLE_LEGACY_GRAPH_EDITOR: str = "REMOVED"
"""This setting has been removed"""
PLAY_COMPUTE_GRAPH: str = "/app/player/playComputegraph"
"""Evaluate OmniGraph when the Kit 'Play' button is pressed"""
OPTIMIZE_GENERATED_PYTHON: str = "/persistent/omnigraph/generator/pyOptimize"
"""Optimize the Python code being output by the node generator"""
ENABLE_PATH_CHANGED_CALLBACK: str = "/persistent/omnigraph/enablePathChangedCallback"
"""Enable the deprecated Node.pathChangedCallback. This will affect performance."""
DEPRECATIONS_ARE_ERRORS: str = "/persistent/omnigraph/deprecationsAreErrors"
"""Modify deprecation paths to raise errors or exceptions instead of logging warnings."""
DISABLE_INFO_NOTICE_HANDLING_IN_PLAYBACK = "/persistent/omnigraph/disableInfoNoticeHandlingInPlayback"
"""Disable all processing of info-only notices by OG. This is an optimization for applications which do not
require any triggering of OG via USD (value_changed and path_changed callbacks, lazy-graph etc"""
ENABLE_USD_IN_PRERENDER = "/persistent/omnigraph/enableUSDInPreRender"
"""Enable nodes that read USD data to be safely used within a pre-render graph"""
# --------------------------------------------------------------------------------------------------------------
def __str__(self) -> str:
"""Returns a representation of all current settings"""
settings = carb.settings.get_settings()
return "\n".join(
[
f"{name} = {settings.get(field.default)}"
for name, field in self.__dataclass_fields__.items() # noqa: PLE1101
]
)
# --------------------------------------------------------------------------------------------------------------
def __call__(self, setting_name: str) -> Any:
"""Look up and return the current value of the passed-in setting
Call as og.Settings()(og.Settings.UPDATE_TO_USD)"""
return carb.settings.get_settings().get(setting_name)
# --------------------------------------------------------------------------------------------------------------
@staticmethod
def generator_settings() -> ogt.Settings:
"""Return the generator settings object corresponding to the current carb settings"""
settings = ogt.Settings()
carb_settings = carb.settings.get_settings()
for setting_name in settings.all().keys():
if carb_settings.get(f"/persistent/omnigraph/generator/{setting_name}"):
setattr(settings, setting_name, True)
return settings
# --------------------------------------------------------------------------------------------------------------
@staticmethod
@contextmanager
def temporary(setting_name: str, setting_value: Any):
"""Generator to temporarily use a new setting value
with og.Settings.temporary(og.Settings.ALLOW_IMPLICIT_GLOBAL_GRAPH, True):
do_something_that_needs_global_graph()
"""
settings = carb.settings.get_settings()
original_setting = settings.get(setting_name)
try:
settings.set(setting_name, setting_value)
yield
finally:
settings.set(setting_name, original_setting)
| 6,145 | Python | 43.215827 | 116 | 0.649797 |
omniverse-code/kit/exts/omni.graph/omni/graph/core/_impl/typing.py | """Houses all of the type definitions for the various interface argument types.
For clarity these types are stored in a structure that gives them a unified naming:
.. code-block:: python
from omni.graph.core.typing import NodeSpec_t
def get_node(node_spec: NodeSpec_t):
pass
The convention used is that X_t is a singular item and Xs_t is a union of the singular item and a list of them.
"""
from typing import Any, Dict, List, Tuple, Union
import omni.graph.core as og
from pxr import Sdf, Usd
# ======================================================================
# Values for type hints on methods that take a variety of convertible types as parameters
Graph_t = Union[str, Sdf.Path, og.Graph]
"""Typing that identifies an existing omni.graph.core.Graph object"""
Graphs_t = Union[Graph_t, List[Graph_t]]
"""Typing that identifies a list of existing omni.graph.core.Graph objects"""
# Added specs for consistency, though for graphs no extra information is currently needed to identify them
GraphSpec_t = Graph_t
"""Typing that identifies an existing omni.graph.core.Graph object"""
GraphSpecs_t = Graphs_t
"""Typing that identifies a list of existing omni.graph.core.Graph objects"""
NewNode_t = Union[str, Sdf.Path, Tuple[str, og.Graph]]
"""Typing for information required to create a new node"""
Node_t = Union[str, og.Node, Sdf.Path, Usd.Prim, Usd.Typed]
"""Typing that identifies an existing omni.graph.core.Node object"""
Nodes_t = Union[Node_t, List[Node_t]]
"""Typing that identifies a list of existing omni.graph.core.Node objects"""
NodeSpec_t = Union[Node_t, Tuple[str, GraphSpec_t]]
"""Typing that identifies an existing omni.graph.core.Node object, with optional graph for disambiguation"""
NodeSpecs_t = Union[NodeSpec_t, List[NodeSpec_t]]
"""Typing that identifies a list of existing omni.graph.core.Node objects, with optional graph for disambiguation"""
NodeType_t = Union[str, og.NodeType, og.Node, Usd.Prim, Usd.Typed]
"""Typing that identifies an existing omni.graph.core.NodeType object"""
NodeTypes_t = Union[NodeType_t, List[NodeType_t]]
"""Typing that identifies a list of existing omni.graph.core.NodeType objects"""
Attribute_t = Union[str, Sdf.Path, og.Attribute, Usd.Attribute]
"""Typing that identifies an existing omni.graph.core.Attribute object"""
Attributes_t = Union[Attribute_t, List[Attribute_t]]
"""Typing that identifies a list of existing omni.graph.core.Attribute objects"""
AttributeWithValue_t = Union[Attribute_t, og.AttributeData]
"""Typing for an attribute-like object that references a value in FlatCache"""
AttributesWithValues_t = Union[AttributeWithValue_t, List[AttributeWithValue_t]]
"""Typing for a list of attribute-like objects that reference values in FlatCache"""
AttributeType_t = Union[str, og.Type]
"""Typing that identifies an existing omni.graph.core.Type definition"""
ExtendedAttribute_t = Union[og.AttributePortType, Tuple[og.AttributePortType, Union[str, List[str]]]]
"""Typing for an extended attribute type description"""
Path_t = Union[str, Sdf.Path]
"""Typing for a path in the USD stage"""
Prim_t = Union[str, Sdf.Path, og.Node, Usd.Prim, Usd.Typed]
"""Typing for an existing USD prim"""
Prims_t = Union[Prim_t, List[Prim_t]]
"""Typing for a list of existing USD prims"""
PrimAttrs_t = Dict[str, Tuple[Union[str, og.Type], Any]]
"""Typing for a description of attribute values for a prim - a dictionary of name:(type,value)"""
CreatePrim_t = Tuple[Path_t, PrimAttrs_t]
"""Typing for information required to create a prim with a predefined set of values"""
CreatePrimst_t = Union[CreatePrim_t, List[CreatePrim_t]]
"""Typing for information required to create a list of prims with a predefined set of values"""
# An attribute that is either unique by itself or which has optional node and graph parts to help look it up.
# This would be passed in as arguments to a function that needs to uniquely identify an existing attribute.
# It differs from a regular attribute in allowing a relative path to the attribute within the node/graph
AttributeSpec_t = Union[og.Attribute, str, Sdf.Path, Tuple[str, Node_t], Tuple[str, Node_t, Graph_t]]
"""Typing for information required to identify an existing og.Attribute"""
AttributeSpecs_t = Union[AttributeSpec_t, List[AttributeSpec_t]]
"""Typing for information required to identify a list of existing og.Attributes"""
VariableName_t = str
"""Typing information required to specify a variable name"""
VariableType_t = Union[str, og.Type]
"""Typing information required to specify a variable type"""
Variable_t = Union[og.IVariable, Tuple[GraphSpec_t, VariableName_t]]
"""Typing information required to specify a variable"""
Variables_t = Union[Variable_t, List[Variable_t]]
"""Typing information required to specify a list of variable"""
| 4,786 | Python | 48.350515 | 116 | 0.744672 |
omniverse-code/kit/exts/omni.graph/omni/graph/core/_impl/dtypes.py | """This file contains the implementation for the dtype information describing Python data types.
It's mostly a repackaging of the information understood by OGN and FlatCache of the supported data types.
They can be passed around to provide identification of data whose type is not explicit, or ambiguous. (e.g. a Python
int is used to represent all of the integer and unsigned integer types so these types can disambiguate)
The dtype information is analagous to the dtype information in numpy, just tuned to our particular data types.
All of these types are exported into the omni.graph.core namespace so type names are generic. Typical usage is:
import omni.graph.core as og
my_float3_type = og.Float3
"""
import ctypes
from dataclasses import dataclass
from typing import Optional
import omni.graph.core as og
# ==============================================================================================================
@dataclass
class Dtype:
"""Common base type for dtypes, defining the members each needs to populate
tuple_count (int): The number of atomic elements in this type
size (int): The total size in bytes of this type
base_type (og.BaseDataType): The base data type of this type
ctype (object): The ctypes representation used by this data type in FlatCache
"""
tuple_count: Optional[int] = None
size: Optional[int] = None
base_type: Optional[int] = None
ctype: Optional[object] = None
@classmethod
def is_matrix_type(cls) -> bool:
"""Returns true if the dtype is a matrix. Uses derived class knowledge to keep it simple"""
return hasattr(cls, "matrix_dim")
# ==============================================================================================================
@dataclass
class Bool(Dtype):
tuple_count: int = 1
size: int = 1
base_type: og.BaseDataType = og.BaseDataType.BOOL
ctype: object = ctypes.c_bool
# ==============================================================================================================
# TODO: Really the bundle should have an identifying role as well so that it can be more easily identified.
# Neither RELATIONSHIP nor PRIM speak to what the intended type is.
@dataclass
class BundleInput(Dtype):
tuple_count: int = 1
size: int = 8
base_type: og.BaseDataType = og.BaseDataType.RELATIONSHIP
ctype: object = ctypes.c_uint64
# ==============================================================================================================
@dataclass
class BundleOutput(Dtype):
tuple_count: int = 1
size: int = 8
base_type: og.BaseDataType = og.BaseDataType.PRIM
ctype: object = ctypes.c_uint64
# ==============================================================================================================
@dataclass
class Double(Dtype):
tuple_count: int = 1
size: int = 8
base_type: og.BaseDataType = og.BaseDataType.DOUBLE
ctype: object = ctypes.c_double
# --------------------------------------------------------------------------------------------------------------
@dataclass
class Double2(Dtype):
tuple_count: int = 2
size: int = 16
base_type: og.BaseDataType = og.BaseDataType.DOUBLE
ctype: object = ctypes.c_double
# --------------------------------------------------------------------------------------------------------------
@dataclass
class Double3(Dtype):
tuple_count: int = 3
size: int = 24
base_type: og.BaseDataType = og.BaseDataType.DOUBLE
ctype: object = ctypes.c_double
# --------------------------------------------------------------------------------------------------------------
@dataclass
class Double4(Dtype):
tuple_count: int = 4
size: int = 32
base_type: og.BaseDataType = og.BaseDataType.DOUBLE
ctype: object = ctypes.c_double
# ==============================================================================================================
@dataclass
class Float(Dtype):
tuple_count: int = 1
size: int = 4
base_type: og.BaseDataType = og.BaseDataType.FLOAT
ctype: object = ctypes.c_float
# --------------------------------------------------------------------------------------------------------------
@dataclass
class Float2(Dtype):
tuple_count: int = 2
size: int = 8
base_type: og.BaseDataType = og.BaseDataType.FLOAT
ctype: object = ctypes.c_float
# --------------------------------------------------------------------------------------------------------------
@dataclass
class Float3(Dtype):
tuple_count: int = 3
size: int = 12
base_type: og.BaseDataType = og.BaseDataType.FLOAT
ctype: object = ctypes.c_float
# --------------------------------------------------------------------------------------------------------------
@dataclass
class Float4(Dtype):
tuple_count: int = 4
size: int = 16
base_type: og.BaseDataType = og.BaseDataType.FLOAT
ctype: object = ctypes.c_float
# ==============================================================================================================
@dataclass
class Half(Dtype):
tuple_count: int = 1
size: int = 2
# Physically this is a 2-byte int, but the size implication is the same for a 2-byte float
base_type: og.BaseDataType = og.BaseDataType.HALF
ctype: object = ctypes.c_ushort
# --------------------------------------------------------------------------------------------------------------
@dataclass
class Half2(Dtype):
tuple_count: int = 2
size: int = 4
base_type: og.BaseDataType = og.BaseDataType.HALF
ctype: object = ctypes.c_ushort
# --------------------------------------------------------------------------------------------------------------
@dataclass
class Half3(Dtype):
tuple_count: int = 3
size: int = 6
base_type: og.BaseDataType = og.BaseDataType.HALF
ctype: object = ctypes.c_ushort
# --------------------------------------------------------------------------------------------------------------
@dataclass
class Half4(Dtype):
tuple_count: int = 4
size: int = 8
base_type: og.BaseDataType = og.BaseDataType.HALF
ctype: object = ctypes.c_ushort
# ==============================================================================================================
@dataclass
class Int(Dtype):
tuple_count: int = 1
size: int = 4
base_type: og.BaseDataType = og.BaseDataType.INT
ctype: object = ctypes.c_int
# --------------------------------------------------------------------------------------------------------------
@dataclass
class Int2(Dtype):
tuple_count: int = 2
size: int = 8
base_type: og.BaseDataType = og.BaseDataType.INT
ctype: object = ctypes.c_int
# --------------------------------------------------------------------------------------------------------------
@dataclass
class Int3(Dtype):
tuple_count: int = 3
size: int = 12
base_type: og.BaseDataType = og.BaseDataType.INT
ctype: object = ctypes.c_int
# --------------------------------------------------------------------------------------------------------------
@dataclass
class Int4(Dtype):
tuple_count: int = 4
size: int = 16
base_type: og.BaseDataType = og.BaseDataType.INT
ctype: object = ctypes.c_int
# --------------------------------------------------------------------------------------------------------------
@dataclass
class Int64(Dtype):
tuple_count: int = 1
size: int = 8
base_type: og.BaseDataType = og.BaseDataType.INT64
ctype: object = ctypes.c_longlong
# ==============================================================================================================
@dataclass
class Matrix2d(Dtype):
tuple_count: int = 4
size: int = 32
base_type: og.BaseDataType = og.BaseDataType.DOUBLE
ctype: object = ctypes.c_double
matrix_dim: int = 2
# --------------------------------------------------------------------------------------------------------------
@dataclass
class Matrix3d(Dtype):
tuple_count: int = 9
size: int = 72
base_type: og.BaseDataType = og.BaseDataType.DOUBLE
ctype: object = ctypes.c_double
matrix_dim: int = 3
# --------------------------------------------------------------------------------------------------------------
@dataclass
class Matrix4d(Dtype):
tuple_count: int = 16
size: int = 128
base_type: og.BaseDataType = og.BaseDataType.DOUBLE
ctype: object = ctypes.c_double
matrix_dim: int = 4
# ==============================================================================================================
@dataclass
class Token(Dtype):
tuple_count: int = 1
size: int = 8
base_type: og.BaseDataType = og.BaseDataType.TOKEN
ctype: object = ctypes.c_uint64
# ==============================================================================================================
@dataclass
class UChar(Dtype):
tuple_count: int = 1
size: int = 1
base_type: og.BaseDataType = og.BaseDataType.UCHAR
ctype: object = ctypes.c_ubyte
# --------------------------------------------------------------------------------------------------------------
@dataclass
class UInt(Dtype):
tuple_count: int = 1
size: int = 4
base_type: og.BaseDataType = og.BaseDataType.UINT
ctype: object = ctypes.c_uint32
# --------------------------------------------------------------------------------------------------------------
@dataclass
class UInt64(Dtype):
tuple_count: int = 1
size: int = 8
base_type: og.BaseDataType = og.BaseDataType.UINT64
ctype: object = ctypes.c_uint64
| 9,585 | Python | 32.16955 | 116 | 0.460198 |
omniverse-code/kit/exts/omni.graph/omni/graph/core/_impl/bundles.py | # The information bracketed here with begin/end describes the interface that is recommended for use with bundled
# attributes. The documentation uses these markers to perform a literal include of this code into the docs so that
# it can be the single source of truth. Note that the interface described here is not the complete set of functions
# functions available, merely the ones that make sense for the user to access when dealing with bundles.
#
# begin-bundle-interface-description
"""
# A bundle can be described as an opaque collection of attributes that travel together through the graph, whose
# contents and types can be introspected in order to determine how to deal with them. This section describes how
# the typical node will interface with the bundle content access. Use of the attributes within the bundles is the
# same as for the extended type attributes, described with their access methods.
#
# An important note regarding GPU bundles is that the bundle itself always lives on the CPU, specifying a memory
# space of "GPU/CUDA" for the bundle actually means that the default location of the attributes it contains will
# be on the GPU.
#
# The main bundle is extracted the same as any other attribute, by referencing its generated database location.
# For this example the bundle will be called "color" and it will have members that could either be the set
# ("r", "g", "b", "a") or the set ("c", "m", "y", "k") with the obvious implications of implied color space.
# As with other attribute types the bundle attribute functions are available through an accessor
color_bundle = db.inputs.color
# The accessor can determine if it points to valid data through a property
valid_color = color_bundle.valid
# If you want to call the underlying Bundle ABI directly you can access the og.Bundle object
bundle_object = color_bundle.bundle
# It can be queried for the number of attributes it holds
bundle_attribute_count = color_bundle.size
# It can have its contents iterated over, where each element in the iteration is an accessor of the bundled attribute
for (bundled_attribute in color_bundle.attributes)
pass
# It can be queried for an attribute in it with a specific name
bundled_attribute = color_bundle.attribute_by_name(db.tokens.red)
# You can get naming information to identify where the bundle is stored you can also get a path
bundle_path = color_bundle.path
# *** The rest of these methods are for output bundles only, as they change the makeup of the bundle
# It can have its contents (i.e. attribute membership) cleared
computed_color_bundle.clear()
# It can be assigned to an output bundle, which merely transfers ownership of the bundle.
# The property setter for the bundle member is the mechanism for this.
color_bundle.bundle = some_other_bundle
# This is accomplished with the insert utility function, which can insert a number of different types of objects
# into a bundle. (The type of data it is passed determines what will be inserted.)
#
# The above function uses this variation, which inserts the bundle members into an existing bundle
computed_color_bundle.insert(color_bundle)
# It can have a single attribute from another bundle inserted into its current list, like if you don't want
# the transparency value in your output color
computed_color_bundle.clear()
computed_color_bundle.insert(color_bundle.attribute_by_name(db.tokens.red))
computed_color_bundle.insert(color_bundle.attribute_by_name(db.tokens.green))
computed_color_bundle.insert(color_bundle.attribute_by_name(db.tokens.blue))
# Optionally, the attribute can be renamed when adding to the bundle by passing the attribute and name as a 2-tuple
red_attribute = color_bundle.attribute_by_name(db.tokens.red)
computed_color_bundle.insert((red_attribute, db.tokens.scarlett))
# It can also add a brand new attribute with a specific type and name as a 2-tuple
og.Type FLOAT_TYPE(og.BaseDataType.FLOAT)
computed_color_bundle.insert((FLOAT_TYPE, db.tokens.opacity)
# *** When attributes are extracted from a bundle they will also be enclosed in a wrapper class og.RuntimeAttribute
# The wrapper class has access to the attribute description information, specifically the name and type
red_name = red_attribute.name
red_type = red_attribute.type
# Array attributes have a "size" property, which can also be set on output or state attributes
point_array = db.inputs.mesh.attribute_by_name(db.tokens.points)
deformed_point_array = db.outputs.mesh.attribute_by_name(db.tokens.points)
deformed_point_array.size = point_array.size
# Default value access is done through the value property, which is writable on output or state attributes
red_input = db.inputs.color.attribute_by_name(db.tokens.red)
red_output = db.outputs.color.attribute_by_name(db.tokens.red)
red_output.value = 1.0 - red_input.value
# By default the above functions operate in the same memory space as was defined by the bundled that contained the
# attribute. If you wish to be more explicit about where the memory lives you can access the specific versions of
# value properties that force either CPU or GPU memory space
if on_gpu:
call_cuda_code(red_output.gpu_value, red_input.gpu_value)
else:
red_output.cpu_value = 1.0 - red_input.cpu_value
# Lastly, on the rare occasion you need direct access to the attribute's ABI through the underlying type
# og.AttributeData you can access it through the abi property
my_attribute_data = red_attribute.abi
"""
# end-bundle-interface-description
from __future__ import annotations
from contextlib import suppress
from typing import Any, Dict, List, Optional, Set, Tuple, Union
import omni.graph.core as og
import omni.graph.tools.ogn as ogn
from carb import log_warn
from .autonode.type_definitions import AutoNodeTypeConversion
from .runtime import RuntimeAttribute
from .utils import non_const
# Information required to create a new bundled attribute from scratch
AttributeDescription = Tuple[og.Type, str]
# ================================================================================
class BundleContents:
"""Manage the allowed types of attributes, providing a static set of convenience values
Internal Attributes:
__bundle: The bundle attached to the attribute
__gpu_by_default: Are the bundle members on the GPU by default?
Properties:
context: Evaluation context from which this bundle was extracted
read_only: Is the bundle data read-only?
"""
def __init__(
self,
context: og.GraphContext,
node: og.Node,
attribute_name: str,
read_only: bool,
gpu_by_default: bool,
gpu_ptr_kind: og.PtrToPtrKind = og.PtrToPtrKind.NA,
):
"""Initialize the access points for the bundle attribute
Args:
context: Evaluation context from which this bundle was extracted
node: Node owning the bundle
attribute_name: Name of the bundle attribute
read_only: Is the bundle data read-only?
gpu_by_default: Are the bundle members on the GPU by default?
gpu_ptr_kind: On which device to pointers to GPU bundles live?
"""
self.context = context
self.read_only = read_only
self.__gpu_by_default = gpu_by_default
self.__gpu_ptr_kind = gpu_ptr_kind
if read_only:
self.__bundle = context.get_input_bundle(node, attribute_name)
else:
self.__bundle = context.get_output_bundle(node, attribute_name)
# ------------------------------------------------------------------------------------------
@property
def size(self) -> int:
"""Returns the number of attributes within this bundle, 0 if the bundle is not valid"""
return self.__bundle.get_attribute_data_count() if self.__bundle.is_valid() else 0
# ------------------------------------------------------------------------------------------
@property
def valid(self) -> bool:
"""Returns true if the underlying bundle is valid, else false"""
return self.__bundle.is_valid()
# ------------------------------------------------------------------------------------------
@non_const
def clear(self):
"""Empties out the bundle contents
Raises:
og.OmniGraphError if the bundle is not writable
"""
# Silently accept that clearing an invalid bundle is a null operation
if self.__bundle.is_valid():
self.__bundle.clear()
# ------------------------------------------------------------------------------------------
@non_const
def add_attributes(self, types: List[og.Type], names: List[str]):
"""Add attributes to the bundle
Args:
types: Vector of types
names: The names of each attribute
Note it is required that size(types) == size(names)
Returns:
nope
"""
if not self.__bundle.is_valid:
log_warn("Attempting to insert something into an invalid bundle")
return
if len(types) != len(names):
log_warn("mismatched size of types and names")
return
self.__bundle.add_attributes(types, names)
# ------------------------------------------------------------------------------------------
@non_const
def remove_attributes(self, names: List[str]):
"""Remove attributes from the bundle
Args:
names: The names of each attribute to be removed
Note it is required that size(types) == size(names)
Returns:
nope
"""
if not self.__bundle.is_valid:
log_warn("Attempting to remove something from an invalid bundle")
return
self.__bundle.remove_attributes(names)
# ------------------------------------------------------------------------------------------
@non_const
def insert(
self, to_insert: Union[BundleContents, RuntimeAttribute, Tuple[RuntimeAttribute, str], AttributeDescription]
) -> RuntimeAttribute:
"""Insert new content in the existing bundle
Args:
to_insert: Object to insert. It can be one of three different types of object:
Bundle: Another bundle, whose contents are entirely copied into this one
RuntimeAttribute: A single attribute from another bundle to be copied with the same name
(RuntimeAttribute, str): A single attribute from another bundle and the name to use for the copy
AttributeDescription: Information required to create a brand new typed attribute
Returns:
RuntimeAttribute of the new attribute if inserting an attribute, else None
"""
if not self.__bundle.is_valid:
log_warn("Attempting to insert something into an invalid bundle")
return None
if isinstance(to_insert, BundleContents):
self.__bundle.insert_bundle(to_insert.__bundle) # noqa: PLW0212
return None
if isinstance(to_insert, RuntimeAttribute):
new_attribute = self.__bundle.insert_attribute(to_insert.attribute_data, to_insert.name)
return RuntimeAttribute(
new_attribute, self.context, self.read_only, self.__gpu_by_default, self.__gpu_ptr_kind
)
if isinstance(to_insert, tuple):
if isinstance(to_insert[0], og.Type):
new_attribute = self.__bundle.add_attribute(to_insert[0], to_insert[1])
return RuntimeAttribute(
new_attribute, self.context, self.read_only, self.__gpu_by_default, self.__gpu_ptr_kind
)
with suppress(AttributeError):
new_attribute = self.__bundle.insert_attribute(to_insert[0].attribute_data, to_insert[1])
return RuntimeAttribute(
new_attribute, self.context, self.read_only, self.__gpu_by_default, self.__gpu_ptr_kind
)
raise og.OmniGraphError(f"Unknown type of object being inserted into a bundle ({to_insert})")
# ------------------------------------------------------------------------------------------
def attribute_by_name(self, attribute_name: str) -> Optional[RuntimeAttribute]:
"""Returns the named attribute within the bundle, or None if no such attribute exists in the bundle"""
all_attributes = self.__bundle.get_attribute_data(not self.read_only) if self.__bundle.is_valid() else []
for attribute in all_attributes:
if attribute.get_name() == attribute_name:
return RuntimeAttribute(
attribute, self.context, self.read_only, self.__gpu_by_default, self.__gpu_ptr_kind
)
return None
# ------------------------------------------------------------------------------------------
def remove(self, attribute_name: str):
"""Removes the attribute with the given name from the bundle, silently succeeding if it is not in the bundle"""
if not self.__bundle.is_valid():
log_warn(f"Attempted to remove attribute {attribute_name} from an invalid bundle")
else:
self.__bundle.remove_attribute(attribute_name)
# ------------------------------------------------------------------------------------------
@property
def bundle(self) -> og.Bundle:
"""Returns the bundle being wrapped by this object"""
return self.__bundle
@bundle.setter
@non_const
def bundle(self, bundle_to_assign: BundleContents):
"""Copies the contents of the bundle into this one, clearing first.
Use insert() to add to the contents of a bundle without clearing.
Good for assigning the entire contents of an input bundle to an output bundle before performing operations:
db.outputs.transformedBundle = db.inputs.bundle
"""
if self.__bundle.is_valid() and bundle_to_assign.bundle.is_valid():
self.clear()
self.insert(bundle_to_assign)
else:
log_warn("Attempting to assign a bundle to an invalid bundle")
# ------------------------------------------------------------------------------------------
@property
def attributes(self) -> List[RuntimeAttribute]:
"""Returns the list of interface objects corresponding to the attributes contained within the bundle"""
all_attributes = self.__bundle.get_attribute_data(not self.read_only) if self.__bundle.is_valid() else []
return [
RuntimeAttribute(attribute, self.context, self.read_only, self.__gpu_by_default, self.__gpu_ptr_kind)
for attribute in all_attributes
]
@attributes.setter
@non_const
def attributes(self, attributes_to_assign: List[RuntimeAttribute]):
"""Populate the bundle with the list of attributes, clearing before assignment.
Good for assigning a subset of the contents of another bundle's attributes to this one:
db.outputs.filteredBundle = db.inputs.bundle.attributes[0:3]
"""
if not self.__bundle.is_valid():
log_warn("Attempted to assign attributes to invalid bundle")
return
self.clear()
raise og.OmniGraphError("TODO: Assigning list of attributes to a bundle not implemented")
# ------------------------------------------------------------------------------------------
@property
def path(self) -> str:
"""Returns the path where this bundle's data is stored"""
return self.__bundle.get_prim_path()
# ================================================================================
class BundleContainer:
"""-------- FOR GENERATED CODE USE ONLY --------
Simple container to manage the set of bundle objects used during a compute function by a node.
This is initialized alongside attribute data in order to minimize the generated code. It will house
a set of BundleContents objects, one per attribute that is a bundle type, with properties named after
the attributes they represent
Args:
context: Evaluation context for these bundles
node: Owner of these bundles
attributes: Subset of node attributes to check for being bundles
gpu_bundles: Subset of bundle attributes whose memory lives on the GPU
read_only: True if these attributes are read-only
"""
# TODO: gpu_bundles is a hacky way of passing the information "is the bundle on the GPU by default".
# It's probably better in the long run to make this a property of the attribute.
# The gpu_ptr_kinds is an even hackier way of deciding if the GPU bundle returns pointers on the CPU or not,
# but it was a tradeoff between that and creating a new version of this container class.
def __init__(
self,
context: og.GraphContext,
node: og.Node,
attributes,
gpu_bundles: List[str],
read_only: bool = False,
gpu_ptr_kinds: Optional[Dict[str, og.PtrToPtrKind]] = None,
):
"""Set up the list of members based on the list of node attributes. These will usually be a subset,
e.g. just the inputs, to keep the higher level access simple
Args:
context: Evaluation context for which the bundles are valid
node: OmniGraph node owning the bundles
attributes: Object containing the attributes as properties
read_only: If True then the bundles cannot be modified
"""
for property_name in vars(attributes):
attribute = getattr(attributes, property_name)
if not isinstance(attribute, og.Attribute):
continue
if attribute.get_type_name() == "bundle":
attribute_name = attribute.get_name()
gpu_by_default = attribute_name in gpu_bundles
gpu_ptr_kind = og.PtrToPtrKind.GPU if gpu_by_default else og.PtrToPtrKind.NA
if gpu_ptr_kinds is not None and attribute_name in gpu_ptr_kinds:
gpu_ptr_kind = gpu_ptr_kinds[attribute_name]
full_name = attribute_name
setattr(
self,
ogn.attribute_name_as_python_property(full_name),
BundleContents(context, node, full_name, read_only, gpu_by_default, gpu_ptr_kind),
)
# ================================================================================
class Bundle:
"""Deferred implementation of the bundle concept"""
def __init__(self, attribute_name: str, read_only: bool):
"""Initialize the access points for the bundle attribute
Args:
attribute_name: the bundle's name. This name will only be used if the bundle is nested.
read_only: Is the bundle data read-only?
"""
self.__buffer: Dict[str, Union[Bundle, OmniAttribute]] = {}
self.__delete_buffer: Set[str] = set()
self._bundle_contents = None
self._attribute_name = attribute_name
self.read_only = read_only
# ------------------------------------------------------------------------------------------
@staticmethod
def commit_to_graph_bundle_contents(source: Bundle, bundle_contents: BundleContents):
"""-------- FOR GENERATED CODE USE ONLY --------
Copy all attributes from the buffer to the runtime BundleContents class.
Args:
source: the Bundle object to be copied
bundle_contents: the BundleContets object to be copied into into
"""
for attr_name in source.attribute_names:
# optimization only create attributes that have been touched
if attr_name in source._Bundle__buffer: # noqa: PLW0212
attr = source.attribute_by_name(attr_name)
if attr.is_dirty:
bundle_contents.insert((attr.og_type, attr.name)).value = attr.value
else:
bundle_contents.insert(attr.runtime_accessor)
else: # copy untouched attributes
bundle_contents.insert(source.runtime_accessor.attribute_by_name(attr_name))
# ------------------------------------------------------------------------------------------
@classmethod
def from_accessor(cls, bundle_contents: BundleContents):
"""-------- FOR GENERATED CODE USE ONLY --------
Convert a BundleContents object to a python Bundle.
Args:
bundle_contents: the graph object representing the bundle
"""
bundle = cls("bundle", False)
if bundle_contents.valid:
bundle._bundle_contents = bundle_contents
return bundle
# ------------------------------------------------------------------------------------------
@property
def runtime_accessor(self) -> BundleContents:
"""exposes the runtime bundle accessor.
Returns:
the BundleContents object if it exists, None otherwise.
"""
return self._bundle_contents
# ------------------------------------------------------------------------------------------
def create_attribute(self, name: str, type_desc: type) -> OmniAttribute:
"""Create an attribute inside the buffered bundle data structure
Args:
name: name of the attribute to create
type_desc: python type object of the attribute to create. Accepts all Omnigraph types.
Will attempt to convert non-omnigraph types, but raise an error if it fails.
Returns:
the OmniAttribute it created.
Raises:
OmniGraphError if no type conversion was found.
"""
attr = OmniAttribute(name, type_desc)
self.insert(attr)
return attr
# ------------------------------------------------------------------------------------------
@property
def is_runtime_resident(self):
return self._bundle_contents is not None and self._bundle_contents.valid
# ------------------------------------------------------------------------------------------
@property
def size(self) -> int:
"""Returns the number of attributes within this bundle, 0 if the bundle is not valid"""
return len(self.attribute_names)
# ------------------------------------------------------------------------------------------
@property
def valid(self) -> Optional[bool]:
"""Returns:
True if the underlying bundle is valid, False if the underlying bundle is not valid,
None if the
"""
if self.is_runtime_resident:
return self._bundle_contents.valid
return None
# ------------------------------------------------------------------------------------------
@non_const
def clear(self):
"""Empties out the bundle contents
Raises:
og.OmniGraphError if the bundle is not writable
"""
# Silently accept that clearing an invalid bundle is a null operation
if self.is_runtime_resident:
for attr in self._bundle_contents.attributes:
self.__delete_buffer.add(attr)
else:
self.__buffer.clear()
# ------------------------------------------------------------------------------------------
@non_const
def insert(self, to_insert: Union[Bundle, OmniAttribute, Tuple[OmniAttribute, str], AttributeDescription]):
"""Insert new content in the existing bundle
Args:
to_insert: Object to insert. It can be one of three different types of object:
Bundle: Another bundle, whose contents are entirely copied into this one
RuntimeAttribute: A single attribute from another bundle to be copied with the same name
(RuntimeAttribute, str): A single attribute from another bundle and the name to use for the copy
AttributeDescription: Information required to create a brand new typed attribute
Returns:
Attribute object of the new attribute if inserting an attribute, else None
"""
name = to_insert.name
if isinstance(to_insert, Bundle):
self.__buffer[to_insert.attribute_name] = to_insert
self.__delete_buffer.discard(name)
return to_insert
if isinstance(to_insert, OmniAttribute):
self.__buffer[to_insert.name] = to_insert
self.__delete_buffer.discard(name)
return to_insert
raise og.OmniGraphError(f"Unknown type of object being inserted into a bundle ({to_insert})")
# ------------------------------------------------------------------------------------------
def attribute_by_name(self, attribute_name: str) -> Optional[RuntimeAttribute]:
"""
Get an attribute by name from the underlying buffer or the buffer masking it.
Args:
attribute_name: the attribute being queried.
Returns:
the named attribute within the bundle, or None if no such attribute exists in the bundle"""
if attribute_name in self.__delete_buffer:
return None
if attribute_name in self.__buffer:
return self.__buffer.get(attribute_name, None)
if self.is_runtime_resident:
attr = self._bundle_contents.attribute_by_name(attribute_name)
if attr is None:
return None
wrapped_attr = OmniAttribute.from_accessor(attr)
self.__buffer[attribute_name] = wrapped_attr
return wrapped_attr
return None
# ------------------------------------------------------------------------------------------
def remove(self, attribute_name: str):
"""Removes the attribute with the given name from the bundle, silently succeeding if it is not in the bundle.
Args:
attribute_name: attribute to be deleted.
"""
if self.is_runtime_resident:
self.__delete_buffer.add(attribute_name)
else:
self.__buffer.pop(attribute_name, None)
# --------------------------------------------------------------------------------------------
@property
def name(self):
"""The bundle's name"""
return self._attribute_name
# ------------------------------------------------------------------------------------------
@property
def attribute_names(self) -> List[OmniAttribute]:
"""Returns the list of interface objects corresponding to the attributes contained within the bundle"""
attributes = set(self.__buffer)
if self.is_runtime_resident:
attributes.update(attr.name for attr in self._bundle_contents.attributes)
for name in self.__delete_buffer:
attributes.discard(name)
return list(attributes)
# ================================================================================
class OmniAttribute:
"""Simple attribute type to use for python bundles"""
def __init__(self, name: str, type_desc: type, read_only: bool = False, required: bool = True):
self.__name = name
self.__value = None
self.__type_desc = type_desc
self.__metadata = {}
self._runtime_attr = None
self.required = required
self.read_only = read_only
# ------------------------------------------------------------------------------------------
@property
def name(self):
"""The attribute's name"""
return self.__name
# ------------------------------------------------------------------------------------------
@classmethod
def from_accessor(cls, attr: RuntimeAttribute):
# Runtime attributes come as og.Type
type_name = attr.type.get_ogn_type_name()
conversion = AutoNodeTypeConversion.from_ogn_type(type_name)
if not conversion:
raise og.OmniGraphError(f"Can't find an appropriate type conversion for {attr.type_name}")
new_attr = cls(attr.name, conversion.type)
new_attr._runtime_attr = attr
return new_attr
# ------------------------------------------------------------------------------------------
@property
def is_runtime_resident(self) -> bool:
"""Property indidcating whether the attribute represents a concrete graph/fastcache attribtue."""
return self._runtime_attr is not None
# ------------------------------------------------------------------------------------------
@property
def runtime_accessor(self) -> RuntimeAttribute:
return self._runtime_attr
# ------------------------------------------------------------------------------------------
@property
def is_dirty(self) -> bool:
"""Whether the python representation of this value needs to update the graph representation"""
return not self.is_runtime_resident and self.__value is not None
# ------------------------------------------------------------------------------------------
@property
def metadata(self):
return self.__metadata
# ------------------------------------------------------------------------------------------
@property # noqa: A003
def type(self):
return self.__type_desc
# ------------------------------------------------------------------------------------------
@property
def og_type(self):
# HACK (OS): Converts an OG type to a string
if isinstance(self.type, og.Type):
return self.type
conversion = AutoNodeTypeConversion.from_type(self.type)
if conversion is None:
raise og.OmniGraphError(f"No conversions found from type {self.type}")
type_str = conversion.og_type
return og.AttributeType.type_from_ogn_type_name(type_str)
# ------------------------------------------------------------------------------------------
@property
def value(self):
"""Get the local value, if it masks the underlying context representation value.
Otherwise get the value from the context representation.
"""
if self.is_runtime_resident:
return self.__value or self._runtime_attr.value
return self.__value
# ------------------------------------------------------------------------------------------
@value.setter
def value(self, val: Any):
self.__value = val
# ================================================================================
AutoNodeTypeConversion.register_type_conversion(
python_type=Bundle,
ogn_typename="bundle",
ogn_to_python=Bundle.from_accessor,
ogn_to_python_method=AutoNodeTypeConversion.Method.ASSIGN,
python_to_ogn=Bundle.commit_to_graph_bundle_contents,
python_to_ogn_method=AutoNodeTypeConversion.Method.MODIFY,
default=None,
)
| 31,002 | Python | 43.29 | 119 | 0.581221 |
omniverse-code/kit/exts/omni.graph/omni/graph/core/_impl/performance.py | """Helpers for running performance tests on OmniGraph objects."""
import re
from contextlib import suppress
from typing import Dict, List
import carb
import carb.profiler
import omni.graph.core as og
# Regular expression matching event descriptions for node compute timing
RE_COMPUTE_EVENT = re.compile(r"(Py)?Compute\s+(.*)")
class OmniGraphPerformance:
"""Provides simple interfaces for measuring performance of OmniGraph.
For simplicity, the collection is kept separate from the interpretation of the data. That way multiple
collections can be made and summarized separately.
Normal usage is something like this:
p = og.OmniGraphPerformance()
p.start_monitor()
profile_task = asyncio.create_task(measure_results())
p.end_monitor()
async def measure_results():
timing_task = p.measure_timing()
await timing_task
ids = timing_task.result()
display(ids, p.average_node_evaluation_time())
Internal Members:
__capture_enabled: True when the profiler capturing is running
__enabled_capture_mask: Profiler mask value to enable data capture, filtered for any settings
__nodes_captured: Union of all nodes in the various capture sessions; for convenience when reporting
__iprofiler: Interface for the profiler to collect CPU timing
__iprofiler_monitor: Interface for the profiler loading of collecting timing data
__old_capture_mask: Saved capture mask when the profiler is engaged (None when not running)
__results: List of dictionaries with timing results
__settings: Access to profiler settings
"""
def __init__(self):
"""Set up the profiling interface objects, logging a warning if it doesn't exist.
This allows the functions to silently fail, while still providing an alert to the user as to why their
operations might not work as expected.
"""
try:
self.__iprofiler = carb.profiler.acquire_profiler_interface()
self.__iprofiler_monitor = carb.profiler.acquire_profile_monitor_interface()
self.__settings = carb.settings.get_settings()
if self.__iprofiler is None:
raise RuntimeError("Could not load the profiler interface")
if self.__iprofiler_monitor is None:
raise RuntimeError("Could not load the profiler monitor interface")
except RuntimeError as error:
carb.log_warn(f"RuntimeError {error} - data will not be collected")
self.__results = []
self.__nodes_captured = set()
self.__old_capture_mask = None
self.__capture_enabled = False
if self.__settings:
mask = self.__settings.get_as_int("/app/profilerMask")
if mask < 0:
# since get_as_int() returns a signed value, and set_capture_mask() requires an unsigned value, and the
# default value is all bits set (which python interprets as -1), we convert to a positive number here.
mask = mask + 0x010000000000000000
self.__enabled_capture_mask = mask
else:
self.__enabled_capture_mask = 0x0FFFFFFFFFFFFFFFF
# ----------------------------------------------------------------------
def available(self) -> bool:
"""Returns true if the profiling capabilities are available"""
return self.__iprofiler is not None and self.__iprofiler_monitor is not None and self.__capture_enabled
# ----------------------------------------------------------------------
def clear(self):
"""Clear out any timing data saved so far"""
self.__results = []
# ----------------------------------------------------------------------
def memory_in_use(self) -> int:
"""Return the current number of bytes in use by FlatCache"""
return og.OmniGraphInspector().memory_use(og.get_compute_graph_contexts()[0])
# ----------------------------------------------------------------------
def start_monitor(self):
"""Set up the profiler for capturing - must be done before measuring timing"""
if not self.__capture_enabled:
self.__old_capture_mask = self.__iprofiler.get_capture_mask()
self.__iprofiler.set_capture_mask(self.__enabled_capture_mask)
self.__capture_enabled = True
else:
carb.log_warn("Tried to enable capture when it was already enabled")
# ----------------------------------------------------------------------
def end_monitor(self):
"""Set up the profiler to finish capturing"""
if self.__old_capture_mask is None or not self.__capture_enabled:
carb.log_warn("Tried to stop capture before starting")
else:
self.__iprofiler.set_capture_mask(self.__old_capture_mask)
self.__old_capture_mask = None
self.__capture_enabled = False
# ----------------------------------------------------------------------
async def measure_timing(self, iterations: int = 1) -> List[int]:
"""Add a set of evaluation timing information to the current data.
You can either take multiple sets of timing here by setting the iterations value, or you can call this
method multiple times when you make changes.
Args:
iterations: Number of times to measure the timing.
Returns:
List of IDs for the timing(s) taken.
"""
if not self.available():
return []
self.clear()
id_list = []
for _run in range(iterations):
id_list.append(len(self.__results))
this_run = {}
await og.Controller.evaluate()
events = self.__iprofiler_monitor.get_last_profile_events()
collected_data = events.get_profile_events(events.get_main_thread_id())
for data in collected_data:
node_match = RE_COMPUTE_EVENT.match(data["name"])
if node_match:
node_name = node_match.group(2)
this_run[node_name] = getattr(this_run, node_name, 0.0) + data["duration"]
self.__nodes_captured.add(node_name)
self.__results.append(this_run)
return id_list
# ----------------------------------------------------------------------
def average_node_evaluation_time(self) -> Dict[str, float]:
"""Average out the node evaluation timing information for all runs for each node.
Returns:
Dictionary of NodePath:EvaluationTime for each node in the timing set.
"""
if not self.available():
return {}
evaluation_times = {}
for node_name in self.__nodes_captured:
timing = 0.0
count = 0
for run in self.__results:
with suppress(KeyError):
timing += run[node_name]
count += 1
if count > 0:
evaluation_times[node_name] = timing / float(count)
return evaluation_times
# ----------------------------------------------------------------------
def average_event_time(self, event_regex: str) -> Dict[str, float]:
"""Average out the named event timing information for all runs for each node.
Args:
event_regex: Regular expression identifying the event specific to the type of node data being collected
Returns:
Dictionary of NodePath:EvaluationTime for each node in the timing set.
"""
if not self.available():
return {}
evaluation_times = {}
for node_name in self.__nodes_captured:
timing = 0.0
count = 0
for run in self.__results:
with suppress(KeyError):
timing += run[node_name]
count += 1
if count > 0:
evaluation_times[node_name] = timing / float(count)
return evaluation_times
| 8,090 | Python | 41.140625 | 119 | 0.566873 |
omniverse-code/kit/exts/omni.graph/omni/graph/core/_impl/value_commands.py | """
Commands that modify values of an existing OmniGraph
"""
from typing import Optional
import carb
import omni.graph.core as og
import omni.kit
import omni.kit.commands
import omni.usd
from omni.graph.core._impl.utils import ValueToSet_t
from pxr import Sdf
# ==============================================================================================================
class DisableNodeCommand(omni.kit.commands.Command):
"""
Disable Node **Command**. Causes a node to be disabled in the compute graph
Args:
node: The node to disable
"""
def __init__(self, node: og.Node):
self._node = node
self._did_doit = False
def do(self):
disabled = self._node.is_disabled()
if not disabled:
self._node.set_disabled(True)
self._did_doit = True
def undo(self):
if self._did_doit:
self._node.set_disabled(False)
# ==============================================================================================================
class EnableNodeCommand(omni.kit.commands.Command):
"""
Enable Node **Command**. Causes a node to be enabled in the compute graph
Args:
node: The node to enable
"""
def __init__(self, node: og.Node):
self._node = node
self._did_doit = False
def do(self):
disabled = self._node.is_disabled()
if disabled:
self._node.set_disabled(False)
self._did_doit = True
def undo(self):
if self._did_doit:
self._node.set_disabled(True)
# ==============================================================================================================
class DisableGraphCommand(omni.kit.commands.Command):
"""
Disable Graph **Command**. Causes a graph to be disabled
Args:
graph: The graph to disable
"""
def __init__(self, graph):
self._graph = graph
self._did_doit = False
def do(self):
disabled = self._graph.is_disabled()
if not disabled:
self._graph.set_disabled(True)
self._did_doit = True
def undo(self):
if self._did_doit:
self._graph.set_disabled(False)
# ==============================================================================================================
class EnableGraphCommand(omni.kit.commands.Command):
"""
Enable Graph **Command**. Causes a graph to be enabled
Args:
graph: The graph to enable
"""
def __init__(self, graph: og.Graph):
self._graph = graph
self._did_doit = False
def do(self):
disabled = self._graph.is_disabled()
if disabled:
self._graph.set_disabled(False)
self._did_doit = True
def undo(self):
if self._did_doit:
self._graph.set_disabled(True)
# ==============================================================================================================
class EnableGraphUSDHandlerCommand(omni.kit.commands.Command):
"""
Enable Graph USD Handler **Command**. Causes a graph's USD
notice handdler to be enabled.
Args:
graph: The graph to enable notice handling
"""
def __init__(self, graph: og.Graph):
self._graph = graph
self._did_doit = False
def do(self):
enabled = self._graph.usd_notice_handling_enabled()
if not enabled:
self._graph.set_usd_notice_handling_enabled(True)
self._did_doit = True
def undo(self):
if self._did_doit:
self._graph.set_usd_notice_handling_enabled(False)
# ==============================================================================================================
class DisableGraphUSDHandlerCommand(omni.kit.commands.Command):
"""
Disable Graph USD Handler **Command**. Causes a graph's USD
notice handdler to be disabled.
Args:
graph: The graph to disable enotice handling
"""
def __init__(self, graph: og.Graph):
self._graph = graph
self._did_doit = False
def do(self):
enabled = self._graph.usd_notice_handling_enabled()
if enabled:
self._graph.set_usd_notice_handling_enabled(False)
self._did_doit = True
def undo(self):
if self._did_doit:
self._graph.set_usd_notice_handling_enabled(True)
# ==============================================================================================================
class RenameNodeCommand(omni.kit.commands.Command):
"""
Rename Node **Command**. Renames an existing node in a compute graph
Args:
graph: The graph in which the node is located
path: The location in the USD stage
new_path: The new path of the node
"""
def __init__(self, graph: og.Graph, path: str, new_path: str):
self._graph = graph
self._node_path = path
self._new_node_path = new_path
self._did_doit = False
self._node = None
def do(self):
if not Sdf.Path.IsValidPathString(self._new_node_path):
carb.log_error(f"Cannot rename {self._node_path} to {self._new_node_path} as it is not a valid USD path")
elif self._graph.get_node(self._new_node_path).is_valid():
carb.log_error(f"Cannot rename {self._node_path} to {self._new_node_path} as it already exists")
else:
self._node = self._graph.get_node(self._node_path)
if self._node is not None and self._node.is_valid():
if self._node.is_backed_by_usd():
# TODO: we want to rename the prim inside graph.rename_node() instead of using MovePrimCommand
# see Graph::renameNodePath() in Graph.cpp for details
# Since we are doing it this hack'ish way, we need to disable USD notice handling in the graph
# so it doesn't respond to the move prim command, and so the subsequent call to rejig the graph
# state can happen free of interference from that other code path
omni.kit.commands.execute("DisableGraphUSDHandler", graph=self._graph)
omni.kit.commands.execute("MovePrim", path_from=self._node_path, path_to=self._new_node_path)
omni.kit.commands.execute("EnableGraphUSDHandler", graph=self._graph)
# rename_node should come after USD rename
self._graph.rename_node(self._node_path, self._new_node_path)
self._did_doit = True
def undo(self):
if self._did_doit:
# All the previously executed commands should undo automatically
self._graph.rename_node(self._new_node_path, self._node_path)
self._node = None
self._did_doit = False
# ==============================================================================================================
class RenameSubgraphCommand(omni.kit.commands.Command):
"""
Rename Subgraph **Command**. Renames an existing subgraph in a compute graph
Args:
graph: The graph in which the subgraph is located
path: The location in the USD stage
new_path: The new path of the subgraph
"""
def __init__(self, graph: og.Graph, path: str, new_path: str):
self._graph = graph
self._subgraph_path = path
self._new_subgraph_path = new_path
self._did_doit = False
self._subgraph = None
def do(self):
if not Sdf.Path.IsValidPathString(self._new_subgraph_path):
carb.log_error(
f"Cannot rename {self._subgraph_path} to {self._new_subgraph_path} as it is not a valid USD path"
)
elif self._graph.get_subgraph(self._new_subgraph_path).is_valid():
carb.log_error(f"Cannot rename {self._subgraph_path} to {self._new_subgraph_path} as it already exists")
else:
self._subgraph = self._graph.get_subgraph(self._subgraph_path)
if self._subgraph is not None and self._subgraph.is_valid():
# TODO: we want to rename the prim inside graph.rename_subgraph(), instead of using MovePrimCommand
# see Graph::renameSubgraphPath() in Graph.cpp for details
omni.kit.commands.execute("DisableGraphUSDHandler", graph=self._graph)
omni.kit.commands.execute("MovePrim", path_from=self._subgraph_path, path_to=self._new_subgraph_path)
omni.kit.commands.execute("EnableGraphUSDHandler", graph=self._graph)
# rename_subgraph should come after USD rename
self._graph.rename_subgraph(self._subgraph_path, self._new_subgraph_path)
self._did_doit = True
def undo(self):
if self._did_doit:
# All the previously executed commands should undo automatically
self._graph.rename_subgraph(self._new_subgraph_path, self._subgraph_path)
self._graph = None
self._did_doit = False
# ==============================================================================================================
class SetAttrCommand(omni.kit.commands.Command):
"""
SetAttr **Command**. Sets the value of an attribute on a node
Args:
attr: The attribute to set
value: The value to set the attribute to
set_type: The OGN type name to set the attribute to for extended attributes that require Type resolution.
You can also embed the type in the value using a TypedValue
on_gpu: If True then set the value in the GPU memory, otherwise CPU memory
update_usd: If True then immediately propagate the new value to the USD backing, if it exists
"""
def __init__(
self,
attr: og.Attribute,
value: ValueToSet_t,
set_type: str = None,
on_gpu: bool = False,
update_usd: bool = True,
):
self._did_doit = False
self._attr = attr
self._value = value
self._set_type = set_type
self._old_value = None
self._on_gpu = on_gpu
self._update_usd = update_usd
self._helper = og.AttributeValueHelper(attr)
@staticmethod
def do_immediate(
attr: og.Attribute,
value: ValueToSet_t,
on_gpu: bool = False,
update_usd: bool = True,
):
og.AttributeValueHelper(attr).set(value, on_gpu, update_usd)
def do(self):
try:
self._old_value = self._helper.get(self._on_gpu)
except og.OmniGraphError:
# This is expected for unresolved types
if self._attr.get_resolved_type().base_type != og.BaseDataType.UNKNOWN:
raise
self._old_value = None
self._helper.set(self._value, self._on_gpu, update_usd=self._update_usd)
self._did_doit = True
def undo(self):
if self._did_doit and self._old_value is not None:
# Blindly use the same memory type, so there will be a slight inefficiency in the case of calling this
# command to set values on the opposite device they are currently on (i.e. setting the GPU value for
# data currently on the CPU, and vice versa). Fabric will do that work for us.
self._helper.set(self._old_value, self._on_gpu, update_usd=self._update_usd)
# ==============================================================================================================
class SetAttrDataCommand(omni.kit.commands.Command):
"""
SetAttrData **Command**. Sets the value of an attribute data
Args:
attribute_data: The attribute data to set
value: The value to be set
graph: The graph to operate on (deprecated and unnecessary)
on_gpu: If True then set the value in the GPU memory, otherwise CPU memory
"""
def __init__(
self,
attribute_data: og.AttributeData,
value: ValueToSet_t,
graph: Optional[og.Graph] = None,
on_gpu: bool = False,
):
self._did_doit = False
self._attribute_data = attribute_data
self._value = value
self._on_gpu = on_gpu
self._old_value = None
self._helper = og.AttributeDataValueHelper(attribute_data)
if graph is not None:
carb.log_warn("'graph' parameter to SetAttrData is deprecated and unnecessary and will be ignored.")
@staticmethod
def do_immediate(
attribute_data: og.AttributeData,
value: ValueToSet_t,
on_gpu: bool = False,
):
helper = og.AttributeDataValueHelper(attribute_data)
if isinstance(value, og.TypedValue):
carb.log_warn("Type is ignored when using SetAttrData, use SetAttr instead to set explicitly typed data")
helper.set(value.value, on_gpu)
else:
helper.set(value, on_gpu)
def do(self):
self._old_value = self._helper.get(self._on_gpu)
if isinstance(self._value, og.TypedValue):
carb.log_warn("Type is ignored when using SetAttrData, use SetAttr instead to set explicitly typed data")
self._helper.set(self._value.value, self._on_gpu)
else:
self._helper.set(self._value, self._on_gpu)
self._did_doit = True
def undo(self):
if self._did_doit:
# Blindly use the same memory type, so there will be a slight inefficiency in the case of calling this
# command to set values on the opposite device they are currently on (i.e. setting the GPU value for
# data currently on the CPU, and vice versa). Fabric will do that work for us.
self._helper.set(self._old_value, self._on_gpu)
# ==============================================================================================================
class ChangePipelineStageCommand(omni.kit.commands.Command):
"""
Change Pipeline Stage **Command**. Change the pipeline stage of an existing graph.
Args:
graph: The graph whose pipeline stage needs to be changed
new_pipeline_stage: The new pipeline stage of the graph
"""
def __init__(self, graph: og.Graph, new_pipeline_stage: og.GraphPipelineStage):
self._graph = graph
self._new_pipeline_stage = new_pipeline_stage
self._old_pipeline_stage = None
self._did_doit = False
def do(self):
self._old_pipeline_stage = self._graph.get_pipeline_stage()
self._graph.change_pipeline_stage(self._new_pipeline_stage)
self._did_doit = True
def undo(self):
if self._did_doit:
self._graph.change_pipeline_stage(self._old_pipeline_stage)
# ==============================================================================================================
class SetEvaluationModeCommand(omni.kit.commands.Command):
"""
Set Evaluation Mode **Command**. Change the evaluation mode of an existing graph.
Args:
graph: The graph to change the evaluation mode on
new_evaluation_mode: The new graph evaluation mode
"""
def __init__(self, graph: og.Graph, new_evaluation_mode: og.GraphEvaluationMode):
self._graph = graph
self._new_evaluation_mode = new_evaluation_mode
self._old_evaluation_mode = None
def do(self):
self._old_evaluation_mode = self._graph.evaluation_mode
self._graph.evaluation_mode = self._new_evaluation_mode
def undo(self):
if self._old_evaluation_mode is not None:
self._graph.evaluation_mode = self._old_evaluation_mode
self._old_evaluation_mode = None
# ==============================================================================================================
class SetVariableTooltipCommand(omni.kit.commands.Command):
"""
Set Variable Tooltip **Command**. Set the tooltip/description of a variable.
Args:
variable: The variable to set the tooltip of
tooltip: The tooltip text to set
"""
def __init__(self, variable: og.IVariable, tooltip: str):
self._variable = variable
self._tooltip = tooltip
self._old_tooltip = None
self._set_tooltip = False
def do(self):
if not self._variable:
return
self._old_tooltip = self._variable.tooltip
if self._old_tooltip == self._tooltip:
return
self._variable.tooltip = self._tooltip
self._set_tooltip = True
def undo(self):
if not self._set_tooltip:
return
self._variable.tooltip = self._old_tooltip
| 16,636 | Python | 35.645374 | 117 | 0.557406 |
omniverse-code/kit/exts/omni.graph/omni/graph/core/_impl/lookup_tables.py | """
Support file for other functional modules. Kept separate just to keep the other scripts readable.
"""
from typing import Callable, Optional, Tuple
import omni.graph.core as og
__all__ = [
"IDX_ARRAY_GET",
"IDX_ARRAY_GET_TENSOR",
"IDX_ARRAY_SET",
"IDX_GET",
"IDX_GET_TENSOR",
"IDX_SET",
"type_access_methods",
"UNSUPPORTED_METHODS",
]
# ----------------------------------------------------------------------
# Lookup tables mapping attributes to the methods to use for getting or setting their data.
# Avoids deep if/else chain since there are over 50 types to support.
# 0 = Get array data
# 1 = Get array tensor data
# 2 = Set array data
# 3 = Get non-tensor data
# 4 = Get tensor data
# 5 = Set data
IDX_ARRAY_GET = 0
IDX_ARRAY_GET_TENSOR = 1
IDX_ARRAY_SET = 2
IDX_GET = 3
IDX_GET_TENSOR = 4
IDX_SET = 5
CTX = og.GraphContext # Syntactic sugar
# Helper constants that describe why a method is not available in the arrays below
UNSUPPORTED = None # TODO: The methods supporting the type have not yet been written
NOT_APPLICABLE = None # The method does not apply to the data type - e.g. tensors of a single integer value
UNSUPPORTED_METHODS = [UNSUPPORTED, UNSUPPORTED, UNSUPPORTED, UNSUPPORTED, UNSUPPORTED, UNSUPPORTED]
DOUBLE_MATRIX_METHODS = [
CTX.get_attribute_as_nested_doublearray,
CTX.get_attribute_as_nested_doublearray_tensor,
CTX.set_nested_doublearray_attribute,
CTX.get_attribute_as_doublearray,
UNSUPPORTED,
CTX.set_double_matrix_attribute,
]
BOOL_METHODS = [
CTX.get_attribute_as_boolarray,
UNSUPPORTED,
CTX.set_boolarray_attribute,
CTX.get_attribute_as_bool,
NOT_APPLICABLE,
CTX.set_bool_attribute,
]
DOUBLE_METHODS = [
CTX.get_attribute_as_doublearray,
CTX.get_attribute_as_doublearray_tensor,
CTX.set_doublearray_attribute,
CTX.get_attribute_as_double,
NOT_APPLICABLE,
CTX.set_double_attribute,
]
DOUBLE_ARRAY_METHODS = [
CTX.get_attribute_as_nested_doublearray,
CTX.get_attribute_as_nested_doublearray_tensor,
CTX.set_nested_doublearray_attribute,
CTX.get_attribute_as_doublearray,
CTX.get_attribute_as_doublearray_tensor,
CTX.set_doublearray_attribute,
]
FLOAT_METHODS = [
CTX.get_attribute_as_floatarray,
CTX.get_attribute_as_floatarray_tensor,
CTX.set_floatarray_attribute,
CTX.get_attribute_as_float,
NOT_APPLICABLE,
CTX.set_float_attribute,
]
FLOAT_ARRAY_METHODS = [
CTX.get_attribute_as_nested_floatarray,
CTX.get_attribute_as_nested_floatarray_tensor,
CTX.set_nested_floatarray_attribute,
CTX.get_attribute_as_floatarray,
CTX.get_attribute_as_floatarray_tensor,
CTX.set_floatarray_attribute,
]
HALF_METHODS = [
CTX.get_attribute_as_halfarray,
UNSUPPORTED,
CTX.set_halfarray_attribute,
CTX.get_attribute_as_half,
NOT_APPLICABLE,
CTX.set_half_attribute,
]
HALF_ARRAY_METHODS = [
CTX.get_attribute_as_nested_halfarray,
UNSUPPORTED,
CTX.set_nested_halfarray_attribute,
CTX.get_attribute_as_halfarray,
UNSUPPORTED,
CTX.set_halfarray_attribute,
]
INT_METHODS = [
CTX.get_attribute_as_intarray,
CTX.get_attribute_as_intarray_tensor,
CTX.set_intarray_attribute,
CTX.get_attribute_as_int,
NOT_APPLICABLE,
CTX.set_int_attribute,
]
INT_ARRAY_METHODS = [
CTX.get_attribute_as_nested_intarray,
CTX.get_attribute_as_nested_intarray_tensor,
CTX.set_nested_intarray_attribute,
CTX.get_attribute_as_intarray,
CTX.get_attribute_as_intarray_tensor,
CTX.set_intarray_attribute,
]
INT64_METHODS = [
CTX.get_attribute_as_int64array,
UNSUPPORTED,
CTX.set_int64array_attribute,
CTX.get_attribute_as_int64,
NOT_APPLICABLE,
CTX.set_int64_attribute,
]
INT64_ARRAY_METHODS = [
UNSUPPORTED,
UNSUPPORTED,
UNSUPPORTED,
CTX.get_attribute_as_int64array,
UNSUPPORTED,
CTX.set_int64array_attribute,
]
STRING_METHODS = [
CTX.get_attribute_as_stringlist,
UNSUPPORTED,
CTX.set_stringarray_attribute,
CTX.get_attribute_as_string,
NOT_APPLICABLE,
CTX.set_string_attribute,
]
UCHAR_METHODS = [
CTX.get_attribute_as_uchararray,
UNSUPPORTED,
CTX.set_uchararray_attribute,
CTX.get_attribute_as_uchar,
NOT_APPLICABLE,
CTX.set_uchar_attribute,
]
UCHAR_ARRAY_METHODS = [
UNSUPPORTED,
UNSUPPORTED,
UNSUPPORTED,
CTX.get_attribute_as_uchararray,
UNSUPPORTED,
CTX.set_uchararray_attribute,
]
UINT_METHODS = [
CTX.get_attribute_as_uintarray,
UNSUPPORTED,
CTX.set_uintarray_attribute,
CTX.get_attribute_as_uint,
NOT_APPLICABLE,
CTX.set_uint_attribute,
]
UINT_ARRAY_METHODS = [
UNSUPPORTED,
UNSUPPORTED,
UNSUPPORTED,
CTX.get_attribute_as_uintarray,
UNSUPPORTED,
CTX.set_uintarray_attribute,
]
UINT64_METHODS = [
CTX.get_attribute_as_uint64array,
UNSUPPORTED,
CTX.set_uint64array_attribute,
CTX.get_attribute_as_uint64,
NOT_APPLICABLE,
CTX.set_uint64_attribute,
]
UINT64_ARRAY_METHODS = [
UNSUPPORTED,
UNSUPPORTED,
UNSUPPORTED,
CTX.get_attribute_as_uint64array,
UNSUPPORTED,
CTX.set_uint64array_attribute,
]
# ==============================================================================================================
def type_access_methods(
ogn_type: og.Type,
) -> Tuple[Tuple[Callable, Callable, Callable, Callable, Callable, Callable], Optional[str]]:
"""Returns the tuple of lookup methods used for accessing attribute data of the passed in ogn_type"""
if ogn_type.role in [og.AttributeRole.TRANSFORM, og.AttributeRole.MATRIX, og.AttributeRole.FRAME]:
return [DOUBLE_MATRIX_METHODS, "double"]
if ogn_type.base_type == og.BaseDataType.BOOL:
return [BOOL_METHODS, None]
if ogn_type.role in [og.AttributeRole.TEXT, og.AttributeRole.PATH] or ogn_type.base_type == og.BaseDataType.TOKEN:
return [STRING_METHODS, None]
if ogn_type.base_type == og.BaseDataType.DOUBLE:
if ogn_type.tuple_count > 1:
return [DOUBLE_ARRAY_METHODS, "double"]
return [DOUBLE_METHODS, None]
if ogn_type.base_type == og.BaseDataType.FLOAT:
if ogn_type.tuple_count > 1:
return [FLOAT_ARRAY_METHODS, "float"]
return [FLOAT_METHODS, None]
if ogn_type.base_type == og.BaseDataType.HALF:
if ogn_type.tuple_count > 1:
return [HALF_ARRAY_METHODS, "half"]
return [HALF_METHODS, None]
if ogn_type.base_type == og.BaseDataType.INT:
if ogn_type.tuple_count > 1:
return [INT_ARRAY_METHODS, "int"]
return [INT_METHODS, None]
if ogn_type.base_type == og.BaseDataType.INT64:
return [INT64_METHODS, None]
if ogn_type.base_type == og.BaseDataType.UCHAR:
return [UCHAR_METHODS, None]
if ogn_type.base_type == og.BaseDataType.UINT:
return [UINT_METHODS, None]
if ogn_type.base_type == og.BaseDataType.UINT64:
return [UINT64_METHODS, None]
return [[], None]
# ====================================================================================================
# Conversion table for attribute base names in OGN to their base data type and role in the og.Type object
OGN_NAMES_TO_TYPES = {
"any": (og.BaseDataType.TOKEN, og.AttributeRole.NONE),
"bool": (og.BaseDataType.BOOL, og.AttributeRole.NONE),
"bundle": (og.BaseDataType.RELATIONSHIP, og.AttributeRole.BUNDLE),
"colord": (og.BaseDataType.DOUBLE, og.AttributeRole.COLOR),
"colorf": (og.BaseDataType.FLOAT, og.AttributeRole.COLOR),
"colorh": (og.BaseDataType.HALF, og.AttributeRole.COLOR),
"double": (og.BaseDataType.DOUBLE, og.AttributeRole.NONE),
"execution": (og.BaseDataType.UINT, og.AttributeRole.EXECUTION),
"float": (og.BaseDataType.FLOAT, og.AttributeRole.NONE),
"frame": (og.BaseDataType.DOUBLE, og.AttributeRole.FRAME),
"half": (og.BaseDataType.HALF, og.AttributeRole.NONE),
"int": (og.BaseDataType.INT, og.AttributeRole.NONE),
"int64": (og.BaseDataType.INT64, og.AttributeRole.NONE),
"matrixd": (og.BaseDataType.DOUBLE, og.AttributeRole.MATRIX),
"normald": (og.BaseDataType.DOUBLE, og.AttributeRole.NORMAL),
"normalf": (og.BaseDataType.FLOAT, og.AttributeRole.NORMAL),
"normalh": (og.BaseDataType.HALF, og.AttributeRole.NORMAL),
"objectId": (og.BaseDataType.UINT64, og.AttributeRole.OBJECT_ID),
"path": (og.BaseDataType.UCHAR, og.AttributeRole.PATH),
"pointd": (og.BaseDataType.DOUBLE, og.AttributeRole.POSITION),
"pointf": (og.BaseDataType.FLOAT, og.AttributeRole.POSITION),
"pointh": (og.BaseDataType.HALF, og.AttributeRole.POSITION),
"quatd": (og.BaseDataType.DOUBLE, og.AttributeRole.QUATERNION),
"quatf": (og.BaseDataType.FLOAT, og.AttributeRole.QUATERNION),
"quath": (og.BaseDataType.HALF, og.AttributeRole.QUATERNION),
"string": (og.BaseDataType.UCHAR, og.AttributeRole.TEXT),
"texcoordd": (og.BaseDataType.DOUBLE, og.AttributeRole.TEXCOORD),
"texcoordf": (og.BaseDataType.FLOAT, og.AttributeRole.TEXCOORD),
"texcoordh": (og.BaseDataType.HALF, og.AttributeRole.TEXCOORD),
"timecode": (og.BaseDataType.DOUBLE, og.AttributeRole.TIMECODE),
"token": (og.BaseDataType.TOKEN, og.AttributeRole.NONE),
"transform": (og.BaseDataType.DOUBLE, og.AttributeRole.TRANSFORM),
"uchar": (og.BaseDataType.UCHAR, og.AttributeRole.NONE),
"uint": (og.BaseDataType.UINT, og.AttributeRole.NONE),
"uint64": (og.BaseDataType.UINT64, og.AttributeRole.NONE),
"vectord": (og.BaseDataType.DOUBLE, og.AttributeRole.VECTOR),
"vectorf": (og.BaseDataType.FLOAT, og.AttributeRole.VECTOR),
"vectorh": (og.BaseDataType.HALF, og.AttributeRole.VECTOR),
}
# ====================================================================================================
# Conversion table for attribute base names in USD to their base data type and role in the og.Type object.
# There are some subtle differences here that are best explained through the table rather than programmatically.
# The extra parameter is an override for tuple count.
# In OGN they are all explicit (quatd[4]) in USD some are implicit (quatd)
USD_NAMES_TO_TYPES = {
"bool": (og.BaseDataType.BOOL, og.AttributeRole.NONE, None),
"colord": (og.BaseDataType.DOUBLE, og.AttributeRole.COLOR, None),
"colorf": (og.BaseDataType.FLOAT, og.AttributeRole.COLOR, None),
"colorh": (og.BaseDataType.HALF, og.AttributeRole.COLOR, None),
"double": (og.BaseDataType.DOUBLE, og.AttributeRole.NONE, None),
"float": (og.BaseDataType.FLOAT, og.AttributeRole.NONE, None),
"frame": (og.BaseDataType.DOUBLE, og.AttributeRole.FRAME, 16),
"half": (og.BaseDataType.HALF, og.AttributeRole.NONE, None),
"int": (og.BaseDataType.INT, og.AttributeRole.NONE, None),
"int64": (og.BaseDataType.INT64, og.AttributeRole.NONE, None),
"matrixd": (og.BaseDataType.DOUBLE, og.AttributeRole.NONE, None),
"normald": (og.BaseDataType.DOUBLE, og.AttributeRole.NORMAL, None),
"normalf": (og.BaseDataType.FLOAT, og.AttributeRole.NORMAL, None),
"normalh": (og.BaseDataType.HALF, og.AttributeRole.NORMAL, None),
"pointd": (og.BaseDataType.DOUBLE, og.AttributeRole.POSITION, None),
"pointf": (og.BaseDataType.FLOAT, og.AttributeRole.POSITION, None),
"pointh": (og.BaseDataType.HALF, og.AttributeRole.POSITION, None),
"quatd": (og.BaseDataType.DOUBLE, og.AttributeRole.QUATERNION, 4),
"quatf": (og.BaseDataType.FLOAT, og.AttributeRole.QUATERNION, 4),
"quath": (og.BaseDataType.HALF, og.AttributeRole.QUATERNION, 4),
"string": (og.BaseDataType.UCHAR, og.AttributeRole.TEXT, None),
"texCoordd": (og.BaseDataType.DOUBLE, og.AttributeRole.TEXCOORD, None),
"texCoordf": (og.BaseDataType.FLOAT, og.AttributeRole.TEXCOORD, None),
"texCoordh": (og.BaseDataType.HALF, og.AttributeRole.TEXCOORD, None),
"timecode": (og.BaseDataType.DOUBLE, og.AttributeRole.TIMECODE, None),
"token": (og.BaseDataType.TOKEN, og.AttributeRole.NONE, None),
"transform": (og.BaseDataType.DOUBLE, og.AttributeRole.TRANSFORM, 16),
"uchar": (og.BaseDataType.UCHAR, og.AttributeRole.NONE, None),
"uint": (og.BaseDataType.UINT, og.AttributeRole.NONE, None),
"uint64": (og.BaseDataType.UINT64, og.AttributeRole.NONE, None),
"vectord": (og.BaseDataType.DOUBLE, og.AttributeRole.VECTOR, None),
"vectorf": (og.BaseDataType.FLOAT, og.AttributeRole.VECTOR, None),
"vectorh": (og.BaseDataType.HALF, og.AttributeRole.VECTOR, None),
}
| 12,504 | Python | 37.009118 | 118 | 0.681462 |
omniverse-code/kit/exts/omni.graph/omni/graph/core/_impl/type_resolution.py | """
Utilities helpful for type resolution logic
"""
from typing import Sequence, Tuple
import omni.graph.core as og
__all__ = ["resolve_base_coupled", "resolve_fully_coupled"]
# ================================================================================
def resolve_fully_coupled(attributes: Sequence[og.Attribute]) -> None:
"""Resolves attribute types given a set of attributes which are fully type coupled.
For example if node 'Increment' has one input attribute 'a' and one output attribute 'b'
and we want the types of 'a' and 'b' to always match. This function will take under consideration
the available conversions
This function should only be called from `on_connection_type_resolve`.
Args:
attributes: list of extended attributes to be resolved
"""
attributes[0].get_node().resolve_coupled_attributes(attributes)
# ================================================================================
def resolve_base_coupled(attribute_specs: Sequence[Tuple[og.Attribute, int, int, og.AttributeRole]]) -> None:
"""Resolves attribute types given a set of attributes, that can have differing tuple counts and/or array depth,
and differing but convertible base data type.
For example if node 'makeTuple2' has two input attributes 'a' and 'b' and one output 'c'
and we want to resolve 'a':float, 'b':float, 'c':float[2] (convertible base types, different tuple counts)
we would use the input:
.. code-block:: python
[
(node.get_attribute("inputs:a"), None, None, None),
(node.get_attribute("inputs:b"), None, None, None),
(node.get_attribute("outputs:c"), None, 1, None)
]
Assuming `a` gets resolved first, the None will be set to the respective values for the resolved type (`a`).
For this example, it will use defaults tuple_count=1, array_depth=0, role=NONE.
This function should only be called from `on_connection_type_resolve`.
Args:
attribute_specs: list of (attribute, tuple_count, array_depth, role) of extended attributes to be resolved.
'None' for tuple_count, array_depth, or role means 'use the resolved type'.
"""
attributes = [a for a, _, _, _ in attribute_specs]
tuples = [255 if b is None else b for _, b, _, _ in attribute_specs]
arrays = [255 if c is None else c for _, _, c, _ in attribute_specs]
roles = [og.AttributeRole.NONE if d is None else d for _, _, _, d in attribute_specs]
attributes[0].get_node().resolve_partially_coupled_attributes(attributes, tuples, arrays, roles)
| 2,589 | Python | 45.249999 | 115 | 0.642719 |
omniverse-code/kit/exts/omni.graph/omni/graph/core/_impl/autonode/util.py | from contextlib import contextmanager
PROP_INFIX = "__PROP__"
FUNC_INFIX = "__FUNC__"
GET_SUFFIX = "__GET"
SET_SUFFIX = "__SET"
NAMESPACE_INFIX = "__NSP__"
# ================================================================================
def sanitize_qualname(name: str) -> str:
return name.replace(".", NAMESPACE_INFIX)
# ================================================================================
def python_name_to_ui_name(name: str) -> str:
# de-snake
strings = name.split("_")
case_corrected = [s.capitalize() if s.islower() else s for s in strings]
return " ".join(case_corrected)
# ================================================================================
def sanitized_name_to_ui_name(name: str) -> str:
def correct_case(s):
return s.capitalize() if s.islower() else s
strings = name.split(NAMESPACE_INFIX)
name = ".".join([correct_case(s) for s in strings])
strings = name.split(FUNC_INFIX)
name = " : ".join([correct_case(s) for s in strings])
strings = name.split(PROP_INFIX)
name = " : ".join([correct_case(s) for s in strings])
return name
# ================================================================================
def is_private(name: str) -> bool:
"""checks if a name should be considered private"""
return len(name) > 1 and name.startswith("_")
# ================================================================================
def is_class_private(name: str) -> bool:
"""Checks if a name is a class private member.
Used to warn if a name will get mangled. Based on
https://github.com/python/cpython/blob/bd46174a5a09a54e5ae1077909f923f56a7cf710/Python/compile.c#L236-L258
"""
return name.startswith("__") and not name.endswith("__")
# ================================================================================
def is_dunder(name: str) -> bool:
"""Checks if a name is an internal python name. Based on
https://github.com/python/cpython/blob/148f32913573c29250dfb3f0d079eb8847633621/Objects/typeobject.c#L3299-L3306
"""
return len(name) > 4 and name.isascii() and name.startswith("__") and name.endswith("__")
# ================================================================================
class GeneratedCode:
"""Tiny code generation utility"""
strbuf = ""
indent_level = 0
# --------------------------------------------------------------------------------
def line(self, txt: str):
self.strbuf += self.indent_level * " " + txt + "\n"
# --------------------------------------------------------------------------------
@contextmanager
def indent(self, txt):
try:
self.line(txt)
self.indent_level += 4
yield None
finally:
self.indent_level -= 4
# --------------------------------------------------------------------------------
def __repr__(self) -> str:
return self.strbuf
| 2,966 | Python | 33.103448 | 116 | 0.450101 |
omniverse-code/kit/exts/omni.graph/omni/graph/core/_impl/autonode/function.py | import copy
import functools
import inspect
import json
from collections import OrderedDict
from typing import Callable, Dict, List, _GenericAlias
import carb
from . import type_definitions
from .util import GeneratedCode
EXEC_ATTRIBUTE_PREFIX = "exec"
NODE_DATA_LITERAL = "node_data"
# ================================================================================
class AutoFunctionWrapper(type_definitions.AutoNodeDefinitionWrapper):
"""Class to wrap python functions and classmethods. Contains methods for creating an Ogn annotation from a python
function, and methods for applying values to the function.
"""
def __init__(
self, func: Callable, *, pure: bool, ui_name: str, unique_name: str, tags: List[str], annotation: Dict = None
) -> None:
super().__init__()
self._func_proto = func
self._func = func
self._is_bound = hasattr(func, "__self__")
self._returns_tuple = False
self._argument_cache: Dict = {}
self._has_node_data_signature = False
self._node_impl = None
self.python_name = func.__name__ or func.__qualname__
self.name = ui_name or self.python_name
self.pure = pure or False
if unique_name is None:
raise NameError(f"{func.__qualname__} does not have a specified unique name")
self.unique_name = unique_name
self.descriptor = {}
self.descriptor["uiName"] = self.name
self.descriptor["version"] = 1
self.descriptor["language"] = "Python"
self.descriptor["tags"] = tags or []
docstring = func.__doc__ or "[no documentation]"
self.descriptor["description"] = f"{self.name}: {docstring}. Autogenerated"
self.descriptor["inputs"] = OrderedDict(
{
f"_unique_name_{self.unique_name}": {
"uiName": "Function Name",
"type": "string",
"description": "autogenerated qualified name",
"metadata": {"hidden": 1},
"default": self.unique_name,
}
}
)
if not self.pure:
self.descriptor["tags"].append("action")
self.descriptor["inputs"][EXEC_ATTRIBUTE_PREFIX] = {
"uiName": "Exec",
"description": "exec input",
"type": "execution",
}
if annotation is not None:
# If the annotation shim exists, use it:
for key in annotation:
if key == "return":
self._set_output_type(annotation[key])
elif key == "self":
# FIXME (OS): func.__class__ will not contain the whole type
# in the case pybind is used
self._add_input(key, func.__class__)
else:
self._add_input(key, annotation[key])
else:
# fall back to inspection otherwise
sig = inspect.signature(func)
params = sig.parameters
for name in params:
item = params[name]
if name == NODE_DATA_LITERAL: # This node holds state
self._has_node_data_signature = True
elif name == "self" and item.annotation is inspect._empty:
self._add_input(item.name, func.__class__)
else:
self._add_input(item.name, item.annotation)
self._set_output_type(sig.return_annotation)
# --------------------------------------------------------------------------------
@staticmethod
def get_type_signature(type_desc: type) -> Dict:
"""Constructs an Ogn type signature from the incoming type. If the type can be converted to a native Ogn type,
the method attempts to do this automatically.
Args:
type_desc: a type object to describe an input type
Returns:
A dict object with Ogn properties
"""
if type_desc is None:
return None
conversion = type_definitions.AutoNodeTypeConversion.from_type(type_desc)
ret = {"description": "autogenerated python type"}
if conversion is not None:
ret["type"] = conversion.og_type
ret["default"] = conversion.default
else:
try:
type_name = type_desc.__name__
except AttributeError:
type_name = str(type_desc)
ret["type"] = "objectId"
ret["metadata"] = {"python_type_desc": type_name}
return ret
# --------------------------------------------------------------------------------
def _add_input(self, name: str, type_desc: type):
"""Adds an input to the function wrpper
Args:
name: a string to name the input in the node's public interface
type_desc: a type for the function's public interface
"""
self.descriptor["inputs"][name] = AutoFunctionWrapper.get_type_signature(type_desc)
self.descriptor["inputs"].move_to_end(name)
# --------------------------------------------------------------------------------
def _set_output_type(self, type_desc: type):
"""Sets the function's output signature. Adds an "exec" port if the function isn't marked as "pure"
If the function returns a 'Tuple' type, the Tuple is unpacked to individual node outputs,
labeled 'out_0', 'out_1', etc.
Args:
type_desc: a return type
"""
outputs = OrderedDict()
if not self.pure:
outputs[EXEC_ATTRIBUTE_PREFIX] = {"type": "execution", "description": "autogenerated output"}
if type_desc is None:
self.descriptor["outputs"] = outputs
return
# Handle case where tuples are returned
if isinstance(type_desc, _GenericAlias) and type_desc.__origin__ == tuple:
self._returns_tuple = True
if self._returns_tuple:
for num, tuple_type_desc in enumerate(reversed(type_desc.__args__)):
name = f"out_{num}"
outputs[name] = AutoFunctionWrapper.get_type_signature(tuple_type_desc)
outputs.move_to_end(name)
else:
outputs["out_0"] = AutoFunctionWrapper.get_type_signature(type_desc)
outputs.move_to_end("out_0")
self.descriptor["outputs"] = outputs
# --------------------------------------------------------------------------------
def clear(self):
"""Resets all bindings in the function argument cache."""
self._argument_cache = {}
self._func = self._func_proto
# --------------------------------------------------------------------------------
@property
def func(self) -> Callable:
"""Access to the bound function.
Returns:
A partially or fully bound function.
"""
if not self._func:
self._func = self.class_ref.__getattribute__(self.python_name) # noqa: PLC2801,PLE1101
return self._func
# --------------------------------------------------------------------------------
@property
def is_bound(self) -> bool:
"""Whether the underlying function dependes on a specific self parameter"""
return self._is_bound
# --------------------------------------------------------------------------------
@property
def has_node_data(self) -> bool:
"""Whether this function's signature has a "node data" component"""
return self._has_node_data_signature
# --------------------------------------------------------------------------------
def assign_input(self, name: str, value):
"""Assigns one of the function inputs into the function argument cache.
Args:
name: argument name
value: unwrapped value to be applied.
"""
self._argument_cache[name] = value
return self
# --------------------------------------------------------------------------------
def assign_input_with_wrapper(self, name: str, value: type_definitions.AutographDataWrapper):
"""Unwraps an object wrapper and applies it to the function argument cache.
Args:
name: argument name
value: object wrapper
"""
return self.assign_input(name, value.value)
# --------------------------------------------------------------------------------
def assign_input_by_id(self, name: str, obj_id: int):
"""Retrieves an input from the object store by its id and applies it to the function argument cache.
Args:
name: argument name
obj_id: the object ID for the argument wrapper, used to retrieve it from the object store
Raises:
KeyError in case the argument isn't found.
"""
try:
wrapper = type_definitions.TypeRegistry.instance().refs.pop(obj_id)
except KeyError as e:
carb.log_error(
f"""Input assignment error: Referenced input [{self.name}:{name}] not found in object store.
It may have been consumed: {e}"""
)
raise e
return self.assign_input_with_wrapper(name, wrapper)
# --------------------------------------------------------------------------------
def execute(self):
"""Executes the wrapped function and clears the argument cache.
Returns:
The function's return value, else None.
Raises:
ValueError if not all arguments in the argument cache are proerly filled
"""
args = {}
if self.is_bound and "self" in self.descriptor["inputs"]:
# method needs to provide its own 'self'
func_name = self._func_proto.__name__
func_source = self._argument_cache["self"]
# find the specific method bound to the 'self' we're after
self._func = getattr(func_source, func_name)
args.update({k: v for k, v in self._argument_cache.items() if k != "self"})
else:
args.update(self._argument_cache)
if len(args) > 0:
self._func = functools.partial(self._func, **args)
ret = self.func.__call__() # noqa: PLR1705,PLC2801
self.clear()
return ret
# --------------------------------------------------------------------------------
def execute_and_add_to_graph(self) -> int:
"""Executes the wrapped function and adds it to the object store if it has a return value.
Does not attempt to convert to an existing Ogn type.
Clears the underlying function argument cache.
Returns:
The object ID if added to the graph, 0 otherwise.
"""
ret = self.execute()
if ret is not None:
return type_definitions.TypeRegistry.add_to_graph(ret)
return 0
# --------------------------------------------------------------------------------
def get_ogn(self) -> str:
"""Gets the Ogn function representation
Returns:
A JSON String with the representation
"""
d = {self.unique_name: self.descriptor}
return json.dumps(d)
def get_module_name(self) -> str:
return self._func.__module__
def get_node_impl(self) -> type:
if self._node_impl is None:
class NodeImpl(
AutographGenericFunction,
unique_name=self.get_unique_name(),
annotation=self.get_ogn(),
# FIXME (OS): Change to actual type
autograph_data={} if self.has_node_data else None,
returns_tuple=self._returns_tuple,
):
pass
self._node_impl = NodeImpl
return self._node_impl
def get_unique_name(self) -> str:
return self.unique_name
# ================================================================================
class AutographGenericFunction:
"""Ogn Python function runner for single output"""
def __init_subclass__(cls, unique_name: str, annotation: Dict, autograph_data: Dict, returns_tuple: bool) -> None:
cls.unique_name = unique_name
cls.annotation = json.loads(annotation)[unique_name]
cls.autograph_data = autograph_data
cls.returns_tuple = returns_tuple
cls.generate_compute()
# --------------------------------------------------------------------------------
@classmethod
def generate_compute(cls):
"""Generates the compute function for an instntiated class.
This code generator aims to minimize the size of code that runs at every frame
"""
code = GeneratedCode()
code.line("@classmethod")
with code.indent("def compute(*args) -> bool:"):
code.line("cls = args[0]")
code.line("db = args[1]")
code.line(f"func_obj = type_definitions.TypeRegistry.get_func('{cls.unique_name}')")
def key_filter(x: str) -> bool:
ret = not x.startswith("_") # no private attributes
ret &= not x.startswith(EXEC_ATTRIBUTE_PREFIX) # no exec attributes
return not ret
for key in cls.annotation["inputs"]:
if key_filter(key):
continue
typename = cls.annotation["inputs"][key]["type"]
conversion = type_definitions.AutoNodeTypeConversion.from_ogn_type(typename)
if conversion:
if conversion.og_to_type is not None:
code.line(
f"value = type_definitions.AutoNodeTypeConversion.from_ogn_type('{typename}')"
f".og_to_type(db.inputs.{key})"
)
else:
code.line(f"value = db.inputs.{key}")
code.line(f"func_obj.assign_input('{key}',value)")
else:
with code.indent("try:"):
code.line(f"func_obj.assign_input_by_id('{key}', db.inputs.{key})")
with code.indent("except KeyError as e:"):
code.line(
f"""carb.log_error("Failed to assign input at [{cls.unique_name} : {key}] : " + str(e))"""
)
code.line("return False")
if cls.autograph_data is not None:
code.line(f"func_obj.assign_input('{NODE_DATA_LITERAL}', db.internal_state)")
output_list = [
output
for output in cls.annotation["outputs"]
if output.startswith("out_") and output[len("out_") :].isnumeric()
]
if len(output_list) == 0:
code.line("func_obj.execute()")
else: # this class returns something, unclear if native Ogn
# extract the output; if it's a tuple iterate over values, if not continue for single value
code.line("ret = func_obj.execute()")
by_keys = {int(output[len("out_") :]): output for output in output_list}
for key, output in by_keys.items():
if not cls.returns_tuple:
code.line("out_value = ret")
else:
code.line(f"out_value = ret[{key}]")
typename = cls.annotation["outputs"][output]["type"]
conversion = type_definitions.AutoNodeTypeConversion.from_ogn_type(typename)
if conversion: # convertible
if conversion.type_to_og is not None:
# converter = f"{conversion.type_to_og.__qualname__}"
if (
conversion.type_to_og_conversion_method
== type_definitions.AutoNodeTypeConversion.Method.ASSIGN
): # noqa
code.line(
f"db.outputs.out_{key} = type_definitions.AutoNodeTypeConversion"
f".from_ogn_type('{typename}').type_to_og(out_value)"
)
elif (
conversion.type_to_og_conversion_method
== type_definitions.AutoNodeTypeConversion.Method.MODIFY
): # noqa
code.line(
f"type_definitions.AutoNodeTypeConversion.from_ogn_type('{typename}')"
f".type_to_og(out_value, db.outputs.out_{key})"
)
else:
code.line(f"db.outputs.out_{key} = out_value")
else: # non-convertible
code.line("out_id = type_definitions.TypeRegistry.add_to_graph(out_value)")
code.line(f"db.outputs.out_{key} = out_id")
code.line("db.outputs.exec = True")
code.line("return True")
carb.log_verbose(f"Generated code for {cls.unique_name}:\n{str(code)}")
exec(str(code), globals()) # noqa: PLW0122
# makes this generated function a class function
cls.compute = compute # noqa - compute is defined by the exec
# ================================================================================
@classmethod
def internal_state(cls):
return None if cls.autograph_data is None else copy.copy(cls.autograph_data)
| 17,782 | Python | 39.600457 | 118 | 0.500112 |
omniverse-code/kit/exts/omni.graph/omni/graph/core/_impl/autonode/event.py | import codecs
import pickle
from abc import ABC, abstractmethod
from enum import Enum
from typing import Callable, Iterable, Optional, Tuple
import carb.events
# import omni.graph.core as og
import omni.kit.app
from .type_definitions import AutoNodeDefinitionGenerator, AutoNodeDefinitionWrapper, TypeRegistry
from .util import is_private, python_name_to_ui_name, sanitize_qualname
payload_path = "!path"
# ================================================================================
class IEventStream(ABC):
_event_type = None
def __init__(self):
raise RuntimeError("IEventStream: interfaces can't be instantiated.")
# --------------------------------------------------------------------------------
@abstractmethod
def create_subscription_to_pop(self, callback: Callable, name: Optional[str]):
pass
# --------------------------------------------------------------------------------
@abstractmethod
def create_subscription_to_self(self, callback: Callable, name: Optional[str]):
pass
# --------------------------------------------------------------------------------
@abstractmethod
def create_subscription_to_pop_by_type(self, callback: Callable, event_type: Enum, name: Optional[str]):
pass
# --------------------------------------------------------------------------------
@abstractmethod
def create_subscription_to_push_by_type(self, callback: Callable, event_type: Enum, name: Optional[str]):
pass
# --------------------------------------------------------------------------------
@classmethod
def get_event_type(cls):
return cls._event_type
# --------------------------------------------------------------------------------
@classmethod
def __class_getitem__(cls, key: Enum):
sanitized = sanitize_qualname(key.__name__)
def create_subscription_to_pop_by_type(self, callback: Callable, event_type: key, name: Optional[str]):
pass
def create_subscription_to_push_by_type(self, callback: Callable, event_type: key, name: Optional[str]):
pass
ret = type(
f"IEventStream_{sanitized}",
(cls,),
{
"_event_type": key,
"create_subscription_to_pop_by_type": create_subscription_to_pop_by_type,
"create_subscription_to_push_by_type": create_subscription_to_push_by_type,
},
)
return ret
# ================================================================================
class EventSubscriptionType(Enum):
NONE = 0
POP = 1
PUSH = 2
ALL = 3
# ================================================================================
class OgnOnEventInternalState:
"""Convenience class for maintaining per-node state information"""
def __init__(self, event_stream):
"""Instantiate the per-node state information."""
# This subscription object controls the lifetime of our callback, it will be
# cleaned up automatically when our node is destroyed
self.sub = None
# Set when the callback has triggered
self.is_set = False
# The last payload received
self.payload = None
# the event emitted
# FIXME (OS): Handle push too
self.subscription = event_stream.create_subscription_to_pop(self.on_event)
# --------------------------------------------------------------------------------
def on_event(self, custom_event):
"""The event callback"""
if custom_event is None:
return
self.is_set = True
self.payload = custom_event.payload
# --------------------------------------------------------------------------------
def try_pop_event(self):
"""Pop the payload of the last event received, or None if there is no event to pop"""
if self.is_set:
self.is_set = False
payload = self.payload
self.payload = None
return payload
return None
# ================================================================================
class OgnOnEvent:
"""
This node triggers when the specified message bus event is received
"""
def __init_subclass__(cls, event_name: str, event_stream: Callable, **kwargs):
cls.event_name = event_name
cls.event_stream = event_stream
cls.event_type = kwargs.get("event_type", None)
cls.subscription_type = kwargs.get("subscription_type", EventSubscriptionType.POP)
# --------------------------------------------------------------------------------
@classmethod
def internal_state(*args): # noqa: PLE0211
"""Returns an object that will contain per-node state information"""
cls = args[0]
internal_state = OgnOnEventInternalState(cls.event_stream)
return internal_state
# --------------------------------------------------------------------------------
@classmethod
def initialize(*args): # noqa: PLE0211
# cls = args[0]
# graph_context = args[1]
# node = args[2]
pass
# --------------------------------------------------------------------------------
@classmethod
def release(*args): # noqa: PLE0211
# node = args[1]
pass
# --------------------------------------------------------------------------------
@classmethod
def compute(*args) -> bool: # noqa: PLE0211
"""Compute the outputs from the current input"""
# cls = args[0]
db = args[1]
state = db.internal_state
payload = state.try_pop_event()
if payload is None:
return True
# Copy the event dict contents into the output bundle
db.outputs.bundle.clear()
for name in payload.get_keys():
# Special 'path' entry gets copied to output attrib
if name == payload_path:
db.outputs.path = payload[name]
continue
as_str = payload[name]
arg_obj = pickle.loads(codecs.decode(as_str.encode(), "base64"))
attr_type, attr_value = arg_obj
new_attr = db.outputs.bundle.insert((attr_type, name))
new_attr.value = attr_value
db.outputs.execOut = True
return True
# ================================================================================
class AutoNodeEventStreamWrapper(AutoNodeDefinitionWrapper):
def __init__(self, event_stream: IEventStream, event_name: str, module_name: str, **kwargs):
super().__init__()
self.event_name = event_name
self.event_stream = event_stream
self.event_type = event_stream.get_event_type()
self.module_name = module_name
self.subscription_type = kwargs.get("subscription_type", EventSubscriptionType.POP)
# --------------------------------------------------------------------------------
def get_ogn(self):
event_ogn = {
f"On{self.event_name}": {
"description": [
"Event node which fires when the specified custom event is sent.",
"This node is used in combination with SendCustomEvent",
],
"version": 1,
"uiName": f"On {python_name_to_ui_name(self.event_name)}",
"language": "Python",
"state": {},
"inputs": {},
"outputs": {
"path": {
"type": "token",
"description": "The path associated with the received custom event",
"uiName": "Path",
},
"bundle": {"type": "bundle", "description": "Bundle received with the event", "uiName": "Bundle"},
"execOut": {
"type": "execution",
"description": "Executes when the event is received",
"uiName": "Received",
},
},
}
}
return event_ogn
# --------------------------------------------------------------------------------
def get_node_impl(self):
class OgnOnEventWrapper(
OgnOnEvent, event_name=self.event_name, event_stream=self.event_stream, event_type=self.event_type
):
pass
return OgnOnEventWrapper
# --------------------------------------------------------------------------------
def get_unique_name(self):
return self.event_name
# --------------------------------------------------------------------------------
def get_module_name(self):
return self.module_name
# ================================================================================
class OgnForwardEventInternalState:
"""Convenience class for maintaining per-node state information"""
# --------------------------------------------------------------------------------
def __init__(self, event_stream):
"""Instantiate the per-node state information."""
# This subscription object controls the lifetime of our callback, it will be
# cleaned up automatically when our node is destroyed
self.event_stream: IEventStream = event_stream
self.event_name: str = ""
self.subscription = None
# --------------------------------------------------------------------------------
def start_forwarding(self):
# FIXME (OS): Handle push too
self.subscription = self.event_stream.create_subscription_to_pop(self.on_event)
# --------------------------------------------------------------------------------
def stop_forwarding(self):
self.subscription = None
# --------------------------------------------------------------------------------
def on_event(self, custom_event):
"""The event callback"""
if custom_event is None:
return
# Returns the internal name used for the given custom event name
n = "omni.graph.action." + self.event_name
name = carb.events.type_from_string(n)
message_bus = omni.kit.app.get_app().get_message_bus_event_stream()
message_bus.push(name, custom_event)
# ================================================================================
class OgnForwardEvent:
"""
This node triggers when the specified message bus event is received
"""
# --------------------------------------------------------------------------------
def __init_subclass__(cls, event_name: str, event_stream: Callable, **kwargs):
cls.event_name = event_name
cls.event_stream = event_stream
cls.event_type = kwargs.get("event_type", None)
cls.subscription_type = kwargs.get("subscription_type", EventSubscriptionType.POP)
# --------------------------------------------------------------------------------
@classmethod
def internal_state(*args): # noqa: PLE0211
"""Returns an object that will contain per-node state information"""
cls = args[0]
internal_state = OgnForwardEventInternalState(cls.event_stream)
return internal_state
# --------------------------------------------------------------------------------
@classmethod
def compute(*args) -> bool: # noqa: PLE0211
"""Compute the outputs from the current input"""
# cls = args[0]
db = args[1]
state = db.internal_state
if db.inputs.start_forwarding:
evstream_id = db.inputs.event_stream
state.event_stream = TypeRegistry.remove_from_graph(evstream_id).value
state.event_name = db.inputs.event_name
state.start_forwarding()
if db.inputs.stop_forwarding:
state.stop_forwarding()
db.outputs.execOut = True
return True
# ================================================================================
class AutoNodeEventStreamForwardWrapper(AutoNodeDefinitionWrapper):
def __init__(self, event_stream: IEventStream, event_name: str, module_name: str, **kwargs):
super().__init__()
self.event_name = event_name
self.event_stream = event_stream
self.event_type = event_stream.get_event_type()
self.module_name = module_name
self.subscription_type = kwargs.get("subscription_type", EventSubscriptionType.POP)
# --------------------------------------------------------------------------------
def get_ogn(self):
event_ogn = {
f"Forward{self.event_name}": {
"description": [
"This event forwards the output of this event stream to another named event stream",
"It can be used in combination with OnCustomEvent.",
],
"version": 1,
"uiName": f"Forward {python_name_to_ui_name(self.event_name)}",
"language": "Python",
"state": {},
"inputs": {
"start_forwarding": {
"description": "Trigger this to begin forwarding events from the wrapped event stream"
" to the main event stream",
"type": "execution",
"uiName": "Start forwarding events",
},
"stop_forwarding": {
"description": "Trigger this to stop any event forwarding to the main event stream.",
"type": "execution",
"uiName": "Stop forwarding",
},
"event_stream": {
"description": "Event stream to forward from",
"type": "objectId",
"uiName": "Event stream",
"metadata": {"python_type_desc": "IEventStream"},
},
"event_name": {
"description": "Name for outgoing events, to be used in 'On Custom Event' nodes.",
"type": "string",
"uiName": "Event Name",
},
},
"outputs": {
"execOut": {
"type": "execution",
"description": "Executes when the event is received",
"uiName": "Received",
}
},
}
}
return event_ogn
# --------------------------------------------------------------------------------
def get_node_impl(self):
class OgnForwardEventWrapper(
OgnForwardEvent, event_name=self.event_name, event_stream=self.event_stream, event_type=self.event_type
):
pass
return OgnForwardEventWrapper
# --------------------------------------------------------------------------------
def get_unique_name(self):
return self.event_name
# --------------------------------------------------------------------------------
def get_module_name(self):
return self.module_name
# ================================================================================
class EventAutoNodeDefinitionGenerator(AutoNodeDefinitionGenerator):
_name = "IEventStream"
# --------------------------------------------------------------------------------
@classmethod
def generate_from_definitions( # noqa: PLW0221
cls, target_type: type, type_name_sanitized: str, type_name_short: str, module_name: str
) -> Tuple[Iterable[AutoNodeDefinitionWrapper], Iterable[str]]:
members_covered = set()
generators = set()
if issubclass(target_type, IEventStream):
generators.add(
AutoNodeEventStreamWrapper(
event_stream=target_type, event_name=type_name_short, module_name=module_name
)
)
generators.add(
AutoNodeEventStreamForwardWrapper(
event_stream=target_type, event_name=type_name_short, module_name=module_name
)
)
members_covered.update(key for key in IEventStream.__dict__ if not is_private(key))
return generators, members_covered
| 16,417 | Python | 37.905213 | 118 | 0.460681 |
omniverse-code/kit/exts/omni.graph/omni/graph/core/_impl/autonode/type_definitions.py | import enum
from abc import ABC, abstractmethod
from collections import namedtuple
from typing import Callable, Dict, Iterable, NewType, Optional, Tuple
import numpy as np
Vector3d = NewType("Vector3d", np.ndarray)
Vector3f = NewType("Vector3f", np.ndarray)
Vector3h = NewType("Vector3h", np.ndarray)
Float = NewType("Float", np.float)
Float2 = NewType("Float2", np.ndarray)
Float3 = NewType("Float3", np.ndarray)
Float4 = NewType("Float4", np.ndarray)
Half = NewType("Half", np.half)
Half2 = NewType("Half2", np.ndarray)
Half3 = NewType("Half3", np.ndarray)
Half4 = NewType("Half4", np.ndarray)
Double = NewType("Double", np.double)
Double2 = NewType("Double2", np.ndarray)
Double3 = NewType("Double3", np.ndarray)
Double4 = NewType("Double4", np.ndarray)
Int = NewType("Int", int)
Int2 = NewType("Int2", np.ndarray)
Int3 = NewType("Int3", np.ndarray)
Int4 = NewType("Int4", np.ndarray)
def int_to_int32(input: int) -> Int:
return input & 0xFFFFFFFF
Timecode = NewType("Timecode", float)
Token = NewType("Token", str)
UInt = NewType("UInt", np.uint)
UChar = NewType("UChar", np.ubyte)
def int_to_uchar(input: int) -> UChar:
return input & 0xFF
Matrix2d = NewType("Matrix2d", np.ndarray)
Matrix3d = NewType("Matrix3d", np.ndarray)
Matrix4d = NewType("Matrix4d", np.ndarray)
Normal3f = NewType("Normal3f", np.ndarray)
Normal3d = NewType("Normal3d", np.ndarray)
Normal3h = NewType("Normal3h", np.ndarray)
Point3f = NewType("Point3f", np.ndarray)
Point3d = NewType("Point3d", np.ndarray)
Point3h = NewType("Point3h", np.ndarray)
Quatd = NewType("Quatd", np.ndarray)
Quatf = NewType("Quatf", np.ndarray)
Quath = NewType("Point3h", np.ndarray)
TexCoord2d = NewType("TexCoord2d", np.ndarray)
TexCoord2f = NewType("TexCoord2f", np.ndarray)
TexCoord2h = NewType("TexCoord2h", np.ndarray)
TexCoord3d = NewType("TexCoord3d", np.ndarray)
TexCoord3f = NewType("TexCoord3f", np.ndarray)
TexCoord3h = NewType("TexCoord3h", np.ndarray)
Color3f = NewType("Color3f", np.ndarray)
Color4f = NewType("Color4f", np.ndarray)
Color3d = NewType("Color3d", np.ndarray)
Color4d = NewType("Color4d", np.ndarray)
Color3h = NewType("Color3h", np.ndarray)
Color4h = NewType("Color4h", np.ndarray)
all_types = [
Vector3d,
Vector3f,
Vector3h,
Float,
Float2,
Float3,
Float4,
Half,
Half2,
Half3,
Half4,
Double,
Double2,
Double3,
Double4,
Int,
Int2,
Int3,
Int4,
Timecode,
Token,
UInt,
UChar,
Matrix2d,
Matrix3d,
Matrix4d,
Normal3f,
Normal3d,
Normal3h,
Point3f,
Point3d,
Point3h,
Quatd,
Quatf,
Quath,
TexCoord2d,
TexCoord2f,
TexCoord2h,
TexCoord3d,
TexCoord3f,
TexCoord3h,
Color3f,
Color4f,
Color3d,
Color4d,
Color3h,
Color4h,
]
TypeDesc = namedtuple(
"TypeDesc",
[
"type",
"og_type",
"type_to_og",
"type_to_og_conversion_method",
"og_to_type",
"og_to_type_conversion_method",
"default",
],
)
# ================================================================================
class AutoNodeTypeConversion:
"""Static class for storing conversion methods between python types and Omnigraph types"""
class Method(enum.Enum):
ASSIGN = (0,)
MODIFY = 1
# flake8: noqa: E241
types = [
TypeDesc(bool, "bool", bool, Method.ASSIGN, None, Method.ASSIGN, False),
TypeDesc(Color3d, "colord[3]", None, Method.ASSIGN, None, Method.ASSIGN, (0, 0, 0)),
TypeDesc(Color3f, "colorf[3]", None, Method.ASSIGN, None, Method.ASSIGN, (0, 0, 0)),
TypeDesc(Color3h, "colorh[3]", None, Method.ASSIGN, None, Method.ASSIGN, (0, 0, 0)),
TypeDesc(Color4d, "colord[4]", None, Method.ASSIGN, None, Method.ASSIGN, (0, 0, 0, 0)),
TypeDesc(Color4f, "colorf[4]", None, Method.ASSIGN, None, Method.ASSIGN, (0, 0, 0, 0)),
TypeDesc(Color4h, "colorh[4]", None, Method.ASSIGN, None, Method.ASSIGN, (0, 0, 0, 0)),
TypeDesc(Double, "double", None, Method.ASSIGN, None, Method.ASSIGN, 0),
TypeDesc(Double2, "double[2]", None, Method.ASSIGN, None, Method.ASSIGN, (0, 0)),
TypeDesc(Double3, "double[3]", None, Method.ASSIGN, None, Method.ASSIGN, (0, 0, 0)),
TypeDesc(Double4, "double[4]", None, Method.ASSIGN, None, Method.ASSIGN, (0, 0, 0, 0)),
TypeDesc(float, "double", None, Method.ASSIGN, None, Method.ASSIGN, 0),
TypeDesc(Float, "float", np.float, Method.ASSIGN, None, Method.ASSIGN, 0),
TypeDesc(Float2, "float[2]", None, Method.ASSIGN, None, Method.ASSIGN, (0, 0)),
TypeDesc(Float3, "float[3]", None, Method.ASSIGN, None, Method.ASSIGN, (0, 0, 0)),
TypeDesc(Float4, "float[4]", None, Method.ASSIGN, None, Method.ASSIGN, (0, 0, 0, 0)),
TypeDesc(Half, "half", np.half, Method.ASSIGN, None, Method.ASSIGN, 0),
TypeDesc(Half2, "half[2]", None, Method.ASSIGN, None, Method.ASSIGN, (0, 0)),
TypeDesc(Half3, "half[3]", None, Method.ASSIGN, None, Method.ASSIGN, (0, 0, 0)),
TypeDesc(Half4, "half[4]", None, Method.ASSIGN, None, Method.ASSIGN, (0, 0, 0, 0)),
TypeDesc(int, "int64", None, Method.ASSIGN, None, Method.ASSIGN, 0),
TypeDesc(Int, "int", int_to_int32, Method.ASSIGN, None, Method.ASSIGN, 0),
TypeDesc(Int2, "int[2]", None, Method.ASSIGN, None, Method.ASSIGN, (0, 0)),
TypeDesc(Int3, "int[3]", None, Method.ASSIGN, None, Method.ASSIGN, (0, 0, 0)),
TypeDesc(Int4, "int[4]", None, Method.ASSIGN, None, Method.ASSIGN, (0, 0, 0, 0)),
TypeDesc(Matrix2d, "matrixd[2]", None, Method.ASSIGN, None, Method.ASSIGN, ((1, 0), (0, 1))),
TypeDesc(Matrix3d, "matrixd[3]", None, Method.ASSIGN, None, Method.ASSIGN, ((1, 0, 0), (0, 1, 0), (0, 0, 1))),
TypeDesc(
Matrix4d,
"matrixd[4]",
None,
Method.ASSIGN,
None,
Method.ASSIGN,
((1, 0, 0, 0), (0, 1, 0, 0), (0, 0, 1, 0), (0, 0, 0, 1)),
),
TypeDesc(Normal3d, "normald[3]", None, Method.ASSIGN, None, Method.ASSIGN, (0, 0, 0)),
TypeDesc(Normal3f, "normalf[3]", None, Method.ASSIGN, None, Method.ASSIGN, (0, 0, 0)),
TypeDesc(Normal3h, "normalh[3]", None, Method.ASSIGN, None, Method.ASSIGN, (0, 0, 0)),
TypeDesc(Point3d, "pointd[3]", None, Method.ASSIGN, None, Method.ASSIGN, (0, 0, 0)),
TypeDesc(Point3f, "pointf[3]", None, Method.ASSIGN, None, Method.ASSIGN, (0, 0, 0)),
TypeDesc(Point3h, "pointh[3]", None, Method.ASSIGN, None, Method.ASSIGN, (0, 0, 0)),
TypeDesc(Quatd, "quatd[4]", None, Method.ASSIGN, None, Method.ASSIGN, (0, 0, 0, 0)),
TypeDesc(Quatf, "quatf[4]", None, Method.ASSIGN, None, Method.ASSIGN, (0, 0, 0, 0)),
TypeDesc(Quath, "quath[4]", None, Method.ASSIGN, None, Method.ASSIGN, (0, 0, 0, 0)),
TypeDesc(str, "string", None, Method.ASSIGN, None, Method.ASSIGN, ""),
TypeDesc(TexCoord2d, "texcoordd[2]", None, Method.ASSIGN, None, Method.ASSIGN, (0, 0)),
TypeDesc(TexCoord2f, "texcoordf[2]", None, Method.ASSIGN, None, Method.ASSIGN, (0, 0)),
TypeDesc(TexCoord2h, "texcoordh[2]", None, Method.ASSIGN, None, Method.ASSIGN, (0, 0)),
TypeDesc(TexCoord3d, "texcoordd[3]", None, Method.ASSIGN, None, Method.ASSIGN, (0, 0, 0)),
TypeDesc(TexCoord3f, "texcoordf[3]", None, Method.ASSIGN, None, Method.ASSIGN, (0, 0, 0)),
TypeDesc(TexCoord3h, "texcoordh[3]", None, Method.ASSIGN, None, Method.ASSIGN, (0, 0, 0)),
TypeDesc(Timecode, "timecode", None, Method.ASSIGN, None, Method.ASSIGN, 0),
TypeDesc(Token, "token", None, Method.ASSIGN, None, Method.ASSIGN, 0),
TypeDesc(UInt, "uint", int_to_uchar, Method.ASSIGN, None, Method.ASSIGN, 0),
TypeDesc(UChar, "uchar", int_to_uchar, Method.ASSIGN, None, Method.ASSIGN, 0),
TypeDesc(Vector3d, "vectord[3]", None, Method.ASSIGN, None, Method.ASSIGN, (0, 0, 0)),
TypeDesc(Vector3f, "vectorf[3]", None, Method.ASSIGN, None, Method.ASSIGN, (0, 0, 0)),
TypeDesc(Vector3h, "vectorh[3]", None, Method.ASSIGN, None, Method.ASSIGN, (0, 0, 0)),
]
user_types = []
# --------------------------------------------------------------------------------
def __init__(self):
raise RuntimeError("AutoNodeTypeConversion is a static class, do not instantiate")
# --------------------------------------------------------------------------------
@classmethod
def from_type(cls, type_desc: type) -> Optional[TypeDesc]:
"""Searches the conversion registry using a python type.
Args:
type_desc: python type to convert
Returns:
TypeDesc for the found python type if it's found, None otherwise
"""
for tb in cls.user_types:
if tb.type == type_desc:
return tb
for tb in cls.types:
if tb.type == type_desc:
return tb
return None
# --------------------------------------------------------------------------------
@classmethod
def from_ogn_type(cls, og_type: str) -> Optional[TypeDesc]:
"""Searches the conversion registry using an Omnigraph type.
Searches the user types first, defaults to the system types.
Args:
og_type: string representing the incoming ogn type
Returns:
TypeDesc for the found python type if it's found, None otherwise
"""
# TODO (OS): Solve for arrays
for tb in cls.user_types:
og_coded_type = tb.og_type
if og_coded_type == og_type:
return tb
for tb in cls.types:
og_coded_type = tb.og_type
if og_coded_type == og_type:
return tb
return None
# --------------------------------------------------------------------------------
@classmethod
def register_type_conversion(
cls,
python_type: type,
ogn_typename: str,
python_to_ogn: Optional[Callable] = None,
python_to_ogn_method: Method = Method.ASSIGN,
ogn_to_python: Optional[Callable] = None,
ogn_to_python_method: Method = Method.ASSIGN,
default=None,
):
"""Registers a type conversion between a python type and an ogn type.
Masks any existing system setting. If a previous user-submitted type conversion is registered, it will be overridden.
Args:
python_type: the type representation in python.
ogn_typename: string representation of the ogn type. Node generation will fail if the type isn't recognized by ogn.
python_to_ogn: [optional] function to convert a python return value to an OGN struct. Signature is Callable[[[python_type], object]. Defaults to None
ogn_to_python: [optional] function to convert an OGN struct to a python return value. Signature is Callable[[[object], python_type]. Defaults to None
"""
desc = TypeDesc(
python_type, ogn_typename, python_to_ogn, python_to_ogn_method, ogn_to_python, ogn_to_python_method, default
)
unregistered = cls.unregister_type_conversion(python_type)
if unregistered:
carb.log_warn(
"Registering an autograph type conversion for {type}->{ogn_typename} replaces anohter conversion for: {desc.type}->{og_type}"
)
cls.user_types.append(desc)
# --------------------------------------------------------------------------------
@classmethod
def unregister_type_conversion(cls, python_type: type = None, ogn_type_name: str = None) -> Optional[TypeDesc]:
"""Unregisters a type conversion from python to ogn.
Doesn't unregister system types.
Args:
python_type: the python type to be removed from support
ogn_type_name: the ogn type name type to be removed from support
Returns:
The TypeDesc tuple just unregistered, or none.
"""
if python_type is not None:
for desc in cls.user_types:
if desc.type == python_type:
cls.user_types.remove(desc)
return desc
if ogn_type_name is not None:
for desc in cls.user_types:
if desc.og_type == ogn_type_name:
cls.user_types.remove(desc)
return desc
return None
# ================================================================================
class AutoNodeDefinitionWrapper(ABC):
"""Container for a single node representation consumed by the Ogn code generator.
Class is abstract and meant to be overridden. A sufficient implementation overrides these methods:
* get_ogn(self) -> Dict
* get_node_impl(self)
* get_unique_name(self) -> str
* get_module_name(self) -> str
"""
def __init__(self):
super().__init__()
# --------------------------------------------------------------------------------
@abstractmethod
def get_ogn(self) -> Dict:
"""Get the Ogn dictionary representation of the node interface."""
return {}
# --------------------------------------------------------------------------------
@abstractmethod
def get_node_impl(self):
"""Returns the Ogn class implementing the node behavior. See omnigraph docuemntation on how to implement.
A sufficient implementation contains a staticmethod with the function: compute(db)
"""
return None
# --------------------------------------------------------------------------------
@abstractmethod
def get_unique_name(self) -> str:
"""Get nodes unique name, to be saved as an accessor in the node database.
Returns:
the non-manlged unique name
"""
return ""
# --------------------------------------------------------------------------------
@abstractmethod
def get_module_name(self) -> str:
"""Get the module this autograph method was defined in.
Returns:
the module name
"""
return ""
# ================================================================================
class AutoNodeDefinitionGenerator(ABC):
"""Defines an interface for generating a node definition"""
_name = ""
# --------------------------------------------------------------------------------
@classmethod
def name(cls):
return cls._name
# --------------------------------------------------------------------------------
@classmethod
@abstractmethod
def generate_from_definitions(cls, new_type: type) -> Tuple[Iterable[AutoNodeDefinitionWrapper], Iterable[str]]:
"""This method scans the type new_type and outputs an AutoNodeDefinitionWrapper from it, representing the type,
as well as a list of members it wishes to hide from the rest of the node extraction process.
Args:
new_type: the type to analyze by attribute
Returns: a tuple of:
Iterable[AutoNodeDefinitionWrapper] - an iterable of AutoNodeDefinitionWrapper - every node wrapper that is generated from this type.
Iterable[str] - an iterable of all members covered by this handler that other handlers should ignore.
"""
pass
class AutographDataWrapper:
"""Class to wrap around data being passed in the graph, to ensure a standard interface for passing data in the
graph. Accepts both reference and value types.
"""
# --------------------------------------------------------------------------------
def __init__(self, value) -> None:
self._value = value
self._type = type(value)
if isinstance(self._type, AutographDataWrapper):
raise KeyError("Attempted to wrap a datawrapper")
# --------------------------------------------------------------------------------
@property
def value(self):
"""Returns the stored value without side effects"""
return self._value
# --------------------------------------------------------------------------------
@property
def type(self) -> type:
"""Returns the value type stored at initialization time without side effects"""
return self._type
class AutographObjectStore:
"""Obejct store with simple put-pop interface."""
# --------------------------------------------------------------------------------
def __init__(self):
self._store = {}
# --------------------------------------------------------------------------------
def pop(self, obj_id: int) -> AutographDataWrapper:
"""Attempts to return a value from the object store, and deletes it from the store.
Args:
obj_id: the object ID to be retrieved
Returns:
an AutographDataWrapper if successful
Raises:
KeyError if the object isn't there.
"""
return self._store.pop(obj_id)
# --------------------------------------------------------------------------------
def put(self, obj_id: int, value: AutographDataWrapper) -> Optional[AutographDataWrapper]:
"""Places an object in the object store according to an object ID. If an object already exists in the data store
with the same ID, it is popped.
Args:
obj_id: integer object ID for input object
value: the actual object ID. Does not check for types.
Returns:
The previous object with the same ID stored in the object store, None otherwise.
"""
swapped = self._store.get(obj_id, None)
self._store[obj_id] = value
return swapped
# ================================================================================
class TypeRegistry:
"""Main singleton for storing graph objects and generating and registering functions."""
def __init__(self):
raise RuntimeError("Singleton class, use instance() instead")
# --------------------------------------------------------------------------------
def _initialize(self):
self.class_to_methods: Dict[type, Dict[str, str]] = {}
# Meant to make accessing functions easier
self.func_name_to_func = {}
# Meant to keep a pointer to an object, so it doesn't get garbage collected
self.refs = AutographObjectStore()
# Meant to handle types whene generating nodes
self.type_handlers = set()
# Stores omnigraph implementations
self._impl_modules = {}
# --------------------------------------------------------------------------------
@classmethod
def _reset(cls):
"""Resets all internal data strucutres. Does not unregister nodes."""
cls.instance()._initialize()
# --------------------------------------------------------------------------------
@classmethod
def instance(cls):
"""Retrieves the class instance for this singleton.
Returns:
Class instance
"""
if not hasattr(cls, "_instance"):
cls._instance = cls.__new__(cls)
cls._instance._initialize()
return cls._instance
# --------------------------------------------------------------------------------
@classmethod
def get_func(cls, unique_name: str) -> Optional[AutoNodeDefinitionWrapper]:
"""Retrieves a function from the object store
Attributes
unique_name: function's qualified name. Name mangling is handled by this class
Returns:
Function Wrapper.
"""
return cls.instance().func_name_to_func.get(unique_name, None)
# --------------------------------------------------------------------------------
@classmethod
def add_to_graph(cls, obj) -> int:
"""Adds an object `obj` to the data store without checking for uniqueness of held object.
Does check uniqueness of reference object.
Attributes
obj: Object to add to the data store.
Returns:
the object id.
"""
wrapper = AutographDataWrapper(obj)
obj_id = id(wrapper)
cls.instance().refs.put(obj_id, wrapper)
return obj_id
# --------------------------------------------------------------------------------
@classmethod
def remove_from_graph(cls, obj_id: int) -> AutographDataWrapper:
"""Attempts to remove an object ID from the object store.
Attributes
obj_id: the object ID to be removed from the data store.
Returns:
the object stored if it was found, None otherwise.
"""
return cls.instance().refs.pop(obj_id)
| 20,788 | Python | 36.867031 | 161 | 0.550125 |
omniverse-code/kit/exts/omni.graph/omni/graph/core/_impl/autonode/core.py | import importlib
from typing import Callable
import omni.graph.tools.ogn as ogn
from ..settings import Settings
from .type_definitions import AutoNodeDefinitionWrapper, TypeRegistry
# ==============================================================================================================
class AutoNode:
@staticmethod
def registry():
return TypeRegistry.instance()
# --------------------------------------------------------------------------------
@staticmethod
def generate_code_and_store(
wrapper: AutoNodeDefinitionWrapper, unique_name: str, *, module_name: str = None
) -> None:
"""Generates the implementation for the Ogn class and stores it in the registry.
Attributes
func_wrapper: Positional. The function wrapper object for which code should be generated.
func_name: name of function getting stored. Name is assumed to be sanitized
module_name: [optional] override the name of the module as detected by the reflection system.
"""
if not unique_name.find(".") == -1:
raise NameError(f"{unique_name} is not a valid name for a class, since it contains a '.'")
AutoNode.registry().func_name_to_func[unique_name] = wrapper
name_prefixed = f"Ogn_{unique_name}"
module_name = module_name or wrapper.get_module_name()
code = ogn.code_generation(
wrapper.get_ogn(),
name_prefixed,
module_name,
"omni.graph.tools",
Settings.generator_settings(),
)
##################
# Code Injection #
##################
# create a virtual module
v_module = importlib.util.module_from_spec(globals()["__spec__"])
AutoNode.registry()._impl_modules[name_prefixed] = v_module # noqa: PLW0212
# inject dependencies into the generated module
v_module.__dict__["AutoNode"] = AutoNode
# v_module.__dict__.update([(a.__name__, a) for a in all_types])
# DANGER ZONE: execute the python node database definition in the target node
exec(code["python"], vars(v_module)) # noqa: PLW0122
# inject the generated implementation into the module
setattr(v_module, name_prefixed, wrapper.get_node_impl())
node_class = getattr(v_module, name_prefixed)
# retrieve the registration action from the node db and register the node
db_class = getattr(v_module, name_prefixed + "Database")
do_register = db_class.register
do_register(node_class)
# --------------------------------------------------------------------------------
@staticmethod
def generate_custom_node(wrapper: AutoNodeDefinitionWrapper):
AutoNode.generate_code_and_store(
wrapper, unique_name=wrapper.get_unique_name(), module_name=wrapper.get_module_name()
)
# ==============================================================================================================
class AutoNodeEvaluationDelayedExecutionQueue:
_queue = []
def __init__(self):
raise RuntimeError("AutoNodeEvaluationDelayedExecutionQueue is a singleton")
# --------------------------------------------------------------------------------
@classmethod
def instance(cls):
if not hasattr(cls, "_instance"):
cls._instance = cls.__new__(cls)
# --------------------------------------------------------------------------------
@classmethod
def add_to_queue(cls, callable_fn: Callable):
cls.instance()._queue.append(callable_fn) # noqa: PLW0212
# --------------------------------------------------------------------------------
@classmethod
def execute_queue(cls):
while len(cls.instance()._queue) > 0: # noqa: PLW0212
callable_fn = cls.instance()._queue.pop() # noqa: PLW0212
callable_fn()
| 3,932 | Python | 37.558823 | 112 | 0.524669 |
omniverse-code/kit/exts/omni.graph/omni/graph/core/_impl/autonode/autonode.py | """
AutoNode - module for decorating code to populate it into OmniGraph nodes.
Allows generating nodes by decorating free functions, classes and modules by adding `@AutoFunc()` or `@AutoClass()` to
the declaration of the class.
Generating code relies on function signatures provided by python's type annotations, therefore the module only supports
native python types with `__annotations__`. CPython classes need need to be wrapped for now.
Exports: `AutoClass`, `AutoFunc`
How an AutoNode decorator works: # TODO
How an AutoNode function execution works:
1. Attribute discovery
Attributes are scanned from the db at runtime
2. Attribute type resolution
types.py contains type conversion facilities to decide on the outgoing type of afunction
3. Attribute value resolution
If needed, values are retrieved from the object store
4. Function execution
function is called.
5. Return value resolution
if the return value needs to be stored outside node, it happens now.
6. Dispatch to other nodes
propagation of values and execution statnode"""
# standard lib imports
import inspect
# meta imports
from typing import Callable, Dict, List
# framework imports
import carb
from .core import AutoNode
from .enum_wrappers import EnumAutoNodeDefinitionGenerator
from .event import EventAutoNodeDefinitionGenerator
from .function import AutoFunctionWrapper
from .property import AutoPropertyWrapper
# module imports
from .type_definitions import AutoNodeDefinitionGenerator
from .util import FUNC_INFIX, GET_SUFFIX, PROP_INFIX, SET_SUFFIX, is_private, python_name_to_ui_name, sanitize_qualname
# ================================================================================
def GenerateAutoFunc( # noqa: N802
func: Callable,
*,
qualname: str = None,
ui_name: str = None,
pure: bool = False,
module_name: str = None,
tags: List[str] = None,
annotation: Dict = None,
):
"""Decorator for methods and function objects.
Attributes
func: the function object being wrapped. Should be a pure python function object or any other callable which
has an `__annotations__` property.
qualname: [optional] override the inferred qualified name
ui_name: [optional] name that appears in the funcion's menu and node display.
pure: [optional] override this function to be a pure function - a function independent of object state
and without side effects, which doesn't enforce a specific execution order.
module_name:[optional] override the inferred module name
tags: [optional]
annotation: [optional] override annotations
"""
qualname = qualname or func.__qualname__
unique_name = sanitize_qualname(qualname)
module_name = module_name or func.__module__
ui_name = ui_name or python_name_to_ui_name(qualname)
func_wrapper = AutoFunctionWrapper(
func, unique_name=unique_name, ui_name=ui_name, pure=pure, tags=tags, annotation=annotation
)
AutoNode.generate_code_and_store(func_wrapper, unique_name=unique_name, module_name=module_name)
return func
# ================================================================================
def GenerateAutoClass(target_class, *, module_name: str, annotation: Dict = None): # noqa: N802
"""Decorator for classes.
Registers the class in the type registry, and returns the wrapped class.
Attributes
target_class: class being wrapped.
module_name: [optional] override the inferred module name
annotation: a dict containing annotations for all members
in the class. Used if passed a type with no annotations.
"""
class_directory = {}
module_name = module_name or target_class.__module__
class_shortname = target_class.__name__
class_unique_name = f"{target_class.__qualname__}"
class_sanitized_name = sanitize_qualname(target_class.__qualname__)
# first, extract special type functionality and ignore special type helpers
members_to_ignore = set()
for type_handler in AutoNode.registry().type_handlers:
definitions, members = type_handler.generate_from_definitions(
target_type=target_class,
type_name_sanitized=class_sanitized_name,
type_name_short=class_shortname,
module_name=module_name,
)
for definition in definitions:
AutoNode.generate_custom_node(definition)
members_to_ignore.update(members)
def _member_filter(name):
ret = True
ret &= not is_private(name)
ret &= name not in members_to_ignore
return ret
members_to_scan = [key for key in target_class.__dict__ if _member_filter(key)]
# scan remaining, ordinary members
for key in members_to_scan:
key_unique_name = f"{class_unique_name} : {python_name_to_ui_name(key)}"
value = target_class.__dict__[key]
if inspect.ismethoddescriptor(value):
# this method came from C++, but isn't a function
if annotation is None or key not in annotation:
# can't handle instance methods for now
carb.log_warn(
f"Can't wrap {key_unique_name}: C functions require an annotation shim and none was provided"
)
continue
func_sanitized_name = f"{class_sanitized_name}{FUNC_INFIX}{key}"
func_ui_name = f"{class_unique_name} : {python_name_to_ui_name(key)}"
GenerateAutoFunc(
value,
qualname=func_sanitized_name,
ui_name=func_ui_name,
module_name=module_name,
pure=False,
annotation=annotation[key],
)
class_directory[key] = func_sanitized_name
elif inspect.isfunction(value):
# python function object
func_sanitized_name = f"{class_sanitized_name}{FUNC_INFIX}{key}"
func_ui_name = f"{class_unique_name} : {python_name_to_ui_name(key)}"
shim = annotation.get(key, None) if annotation else None
GenerateAutoFunc(
value,
qualname=func_sanitized_name,
ui_name=func_ui_name,
module_name=module_name,
pure=False,
annotation=shim,
)
class_directory[key] = func_sanitized_name
elif inspect.isdatadescriptor(value):
# has a getter, a setter and a deleter
prop_sanitized_name = f"{class_sanitized_name}{PROP_INFIX}{key}"
getter_sanitized_name = f"{prop_sanitized_name}{GET_SUFFIX}"
getter_ui_name = f"{class_unique_name} : Get {key}"
setter_sanitized_name = f"{prop_sanitized_name}{SET_SUFFIX}"
setter_ui_name = f"{class_unique_name} : Set {key}"
type_override = annotation.get(key, None) if annotation else None
if not type_override:
carb.log_warn(f"{class_unique_name}.{key} has no annotation, and will be skipped")
continue
getter_shim = {"return": type_override}
setter_shim = {"value": type_override, "return": None}
GenerateAutoFunc(
value.getter,
qualname=getter_sanitized_name,
ui_name=getter_ui_name,
module_name=module_name,
annotation=getter_shim,
)
GenerateAutoFunc(
value.setter,
qualname=setter_sanitized_name,
ui_name=setter_ui_name,
module_name=module_name,
annotation=setter_shim,
)
class_directory[key] = {"get": getter_sanitized_name, "set": setter_sanitized_name}
else:
# it's a value and should be wrapped in a property
prop_sanitized_name = f"{class_sanitized_name}{PROP_INFIX}{key}"
getter_sanitized_name = f"{prop_sanitized_name}{GET_SUFFIX}"
getter_ui_name = f"{class_unique_name} : Get {key}"
setter_sanitized_name = f"{prop_sanitized_name}{SET_SUFFIX}"
setter_ui_name = f"{class_unique_name} : Set {key}"
shim = annotation.get(key, None) if annotation else None
wrapper = AutoPropertyWrapper(target_class, name=key, type_override=shim)
GenerateAutoFunc(
wrapper.get, qualname=getter_sanitized_name, ui_name=getter_ui_name, module_name=module_name, pure=False
)
GenerateAutoFunc(
wrapper.set, qualname=setter_sanitized_name, ui_name=setter_ui_name, module_name=module_name, pure=False
)
class_directory[key] = {"get": getter_sanitized_name, "set": setter_sanitized_name}
AutoNode.registry().func_name_to_func[prop_sanitized_name] = wrapper
AutoNode.registry().class_to_methods[target_class] = class_directory
return target_class
##################################################################################
# #
# public interface #
# #
##################################################################################
# ================================================================================
def AutoClass(**kwargs): # noqa: N802
# inject locals for linking
if "module_name" not in kwargs:
try:
kwargs["module_name"] = inspect.currentframe().f_back.f_locals["__package__"]
except (AttributeError, KeyError):
kwargs["module_name"] = "default_module"
carb.log_warn("No module name found in package. Assigning default name 'default_module'")
def ret(cls):
return GenerateAutoClass(cls, **kwargs) # noqa: PLE1125
ret.__doc__ = GenerateAutoClass.__doc__
return ret
# ================================================================================
def AutoFunc(**kwargs): # noqa: N802
# inject locals for linking
if "module_name" not in kwargs:
try:
kwargs["module_name"] = inspect.currentframe().f_back.f_locals["__package__"]
except (AttributeError, KeyError):
kwargs["module_name"] = "default_module"
carb.log_warn("No module name found in package. Assigning default name 'default_module'")
def ret(func):
return GenerateAutoFunc(func, **kwargs)
ret.__doc__ = GenerateAutoFunc.__doc__
return ret
# ================================================================================
def register_autonode_type_extension(handler: AutoNodeDefinitionGenerator, **kwargs):
# if "module_name" not in kwargs:
# kwargs['module_name'] = inspect.currentframe().f_back.f_locals["__package__"]
AutoNode.registry().type_handlers.add(handler)
# ================================================================================
def unregister_autonode_type_extension(handler: AutoNodeDefinitionGenerator, **kwargs):
# if "module_name" not in kwargs:
# kwargs['module_name'] = inspect.currentframe().f_back.f_locals["__package__"]
AutoNode.registry().type_handlers.remove(handler)
# should help clean in hot reloads
AutoNode.registry()._reset() # noqa: PLW0212
# Add Enums
register_autonode_type_extension(EnumAutoNodeDefinitionGenerator)
# Add Events
register_autonode_type_extension(EventAutoNodeDefinitionGenerator)
| 11,670 | Python | 38.296296 | 120 | 0.594173 |
omniverse-code/kit/exts/omni.graph/omni/graph/core/_impl/autonode/property.py | # ================================================================================
class AutoPropertyWrapper:
"""Wrapper to generate a getter and setter from a property in a class"""
def __init__(self, target_class, name: str, *, type_override: type = None) -> None:
try:
self._type = type_override or target_class.__annotations__[name]
except KeyError:
self._type = type(target_class.__dict__[name])
self._name = name
self.get.__annotations__["target"] = type(target_class)
self.get.__annotations__["return"] = self._type
self.set.__annotations__["target"] = type(target_class)
self.set.__annotations__["value"] = self._type
def get(self, target):
return getattr(target, self._name)
def set(self, target, value): # noqa: A003
setattr(target, self._name, value)
return target
| 903 | Python | 35.159999 | 87 | 0.542636 |
omniverse-code/kit/exts/omni.graph/omni/graph/core/_impl/autonode/enum_wrappers.py | from typing import Dict, Iterable, OrderedDict, Tuple
import carb
from .type_definitions import AutoNodeDefinitionGenerator, AutoNodeDefinitionWrapper
from .util import GeneratedCode
# ================================================================================
class OgnEnumExecutionWrapper:
def __init_subclass__(cls, target_class: type) -> None:
cls.target_class = target_class
cls.member_names = list(target_class.__members__)
cls.generate_compute()
@classmethod
def generate_compute(cls):
code = GeneratedCode()
code.line("from .type_definitions import TypeRegistry")
code.line("@classmethod")
with code.indent("def compute(*args):"):
code.line("cls = args[0]")
code.line("db = args[1]")
with code.indent("if not db.inputs.exec:"):
code.line("return True")
code.line("input = db.inputs.enum")
code.line("value = TypeRegistry.remove_from_graph(input).value")
for name in cls.member_names:
code.line(f"db.outputs.{name} = bool(value == cls.target_class.{name})")
code.line("return True")
carb.log_verbose(f"Generated code for {cls.target_class}:\n{str(code)}")
exec(str(code), globals()) # noqa: PLW0122
cls.compute = compute # noqa: Defined in exec() code
# ================================================================================
class OgnEnumWrapper(AutoNodeDefinitionWrapper):
"""Wrapper around Enums"""
def __init__(self, target_class, unique_name: str, module_name: str, *, ui_name: str = None):
super().__init__()
self.target_class = target_class
self.unique_name = unique_name
self.ui_name = ui_name or target_class.__name__
self.module_name = module_name
self.descriptor: Dict = {}
self.descriptor["uiName"] = ui_name
self.descriptor["version"] = 1
self.descriptor["language"] = "Python"
self.descriptor["description"] = f"Enum Wrapper for {self.ui_name}"
self.descriptor["inputs"] = OrderedDict(
{
"enum": {
"uiName": "Input",
"description": "Enum input",
"type": "objectId",
"default": 0,
"metadata": {"python_type_desc": self.unique_name},
},
"exec": {"uiName": "Exec", "description": "Execution input", "type": "execution", "default": 0},
}
)
def signature(name):
return {"uiName": name, "description": f"Execute on {name}", "type": "execution", "default": 0}
self.descriptor["outputs"] = OrderedDict({name: signature(name) for name in self.target_class.__members__})
# --------------------------------------------------------------------------------
def get_unique_name(self) -> str:
return self.unique_name
# --------------------------------------------------------------------------------
def get_module_name(self) -> str:
return self.module_name
# --------------------------------------------------------------------------------
def get_node_impl(self):
class OgnEnumReturnType(OgnEnumExecutionWrapper, target_class=self.target_class):
pass
return OgnEnumReturnType
# --------------------------------------------------------------------------------
def get_ogn(self) -> Dict:
d = {self.unique_name: self.descriptor}
return d
# ================================================================================
class EnumAutoNodeDefinitionGenerator(AutoNodeDefinitionGenerator):
_name = "Enum"
# --------------------------------------------------------------------------------
@classmethod
def generate_from_definitions( # noqa: PLW0221
cls, target_type: type, type_name_sanitized: str, type_name_short: str, module_name: str
) -> Tuple[Iterable[AutoNodeDefinitionWrapper], Iterable[str]]:
members_covered = set()
returned_generators = set()
if hasattr(target_type, "__members__"):
ret = OgnEnumWrapper(
target_type,
unique_name=type_name_sanitized,
module_name=module_name,
ui_name=f"Switch on {type_name_short}",
)
members_covered.update(target_type.__members__)
returned_generators.add(ret)
return returned_generators, members_covered
| 4,582 | Python | 38.17094 | 115 | 0.498691 |
omniverse-code/kit/exts/omni.graph/omni/graph/core/_impl/v1_5_0/update_file_format.py | """File format upgrade utilities"""
from typing import Any, Dict, List, Optional, Tuple
import carb
import omni.graph.core as og
import omni.usd
from omni.kit.commands import execute
from pxr import Gf, OmniGraphSchema, Usd
from .utils import ALLOW_IMPLICIT_GRAPH_SETTING, USE_SCHEMA_PRIMS_SETTING
EXTENDED_ATTRIBUTE_SCOPED_CUSTOM_DATA_VERSION = og.FileFormatVersion(1, 5)
LAST_FILE_FORMAT_VERSION_WITHOUT_SCHEMA = og.FileFormatVersion(1, 10)
"""TODO: This is the last file format version where it is possible to have OmniGraph prims that do not use the schema
It should be updated when the final deprecation is made.
"""
# ==============================================================================================================
def remove_global_compute_graph(old_format_version, new_format_version, graph):
"""If the setting to allow a global implicit graph is not on then remove it if found
and replace it with a regular graph"""
settings = carb.settings.get_settings()
allow_implicit_graph = settings.get(ALLOW_IMPLICIT_GRAPH_SETTING)
# If the schema is enabled it will fix the global compute graphs too
use_schema_prims = settings.get(og.USE_SCHEMA_PRIMS_SETTING)
if not allow_implicit_graph and not use_schema_prims:
stage = omni.usd.get_context().get_stage()
if stage is not None:
iterator = iter(stage.TraverseAll())
for prim in iterator:
if prim.GetTypeName() == "GlobalComputeGraph":
carb.log_info(
"Converting " + prim.GetPrimPath().pathString + "from GlobalComputeGraph to ComputeGraph"
)
prim.SetTypeName("ComputeGraph")
iterator.PruneChildren()
# ==============================================================================================================
def check_for_bare_connections(stage: Usd.Stage) -> List[str]:
"""Check for any of the old unsupported connections from nodes to prims that cannot exist in schema-based world
Return:
List of strings describing the forbidden connections found
"""
iterator = iter(stage.TraverseAll())
bad_connections = []
for prim in iterator:
if prim.GetTypeName() in ["ComputeNode", "OmniGraphNode"]:
for attribute in prim.GetAttributes():
for connected_path in attribute.GetConnections():
connected_prim = stage.GetPrimAtPath(connected_path.GetPrimPath())
if not connected_prim.IsValid():
carb.log_warn(
f"Invalid connection found at {attribute.GetPath()}:"
f" {connected_path.GetPrimPath()} while migrating to new schema"
)
elif connected_prim.GetTypeName() not in ["ComputeNode", "OmniGraphNode"]:
bad_connections.append(f"{prim.GetPrimPath()} - {connected_path}")
return bad_connections
# ==============================================================================================================
def migrate_attribute_custom_data(
old_format_version: og.FileFormatVersion, new_format_version: og.FileFormatVersion, _
):
"""Add scoped customData to attributes which have the old format"""
if old_format_version < EXTENDED_ATTRIBUTE_SCOPED_CUSTOM_DATA_VERSION:
stage = omni.usd.get_context().get_stage()
if stage is None:
return
iterator = iter(stage.TraverseAll())
for prim in iterator:
if prim.GetTypeName() in ["OmniGraphNode", "ComputeNode"]:
for attribute in prim.GetAttributes():
custom_data = attribute.GetCustomData()
extended_type = custom_data.get("ExtendedAttributeType", None)
if extended_type:
attribute.SetCustomDataByKey("omni:graph:attrType", extended_type)
iterator.PruneChildren()
# ==============================================================================================================
class OmniGraphSchemaMigrator:
"""Collection of methods to manage all of the steps involved in migrating an arbitrary graph to use schema prims"""
def __init__(self):
"""Set up initial values"""
self.__command_count = 0
# --------------------------------------------------------------------------------------------------------------
@property
def stage(self) -> Usd.Stage:
"""Returns the stage in use - set as a property so that the latest version is always used as it changes"""
return omni.usd.get_context().get_stage()
# --------------------------------------------------------------------------------------------------------------
def __check_for_old_prim_nodes(self) -> List[str]:
"""Check for any of the old unsupported prim nodes that cannot exist in schema-based world
Return:
List of prim paths for any unsupported prim node types
"""
iterator = iter(self.stage.TraverseAll())
prim_nodes = []
for prim in iterator:
if prim.GetTypeName() == "ComputeNode":
node_type_attr = prim.GetAttribute("node:type")
if node_type_attr.IsValid() and node_type_attr.Get() == "omni.graph.core.Prim":
prim_nodes.append(prim.GetPrimPath())
return prim_nodes
# --------------------------------------------------------------------------------------------------------------
def __change_prim_types_to_match_schema(self) -> List[Tuple[str, str, str]]:
"""Modify any old prim names to match the ones used by the schema
Return:
List of (path, old_type, new_type) for prims whose type was changed
"""
iterator = iter(self.stage.TraverseAll())
retyped = []
for prim in iterator:
if prim.GetTypeName() in ["GlobalComputeGraph", "ComputeGraph"]:
carb.log_info(f"Converting graph {prim.GetPrimPath()} from {prim.GetTypeName()} to OmniGraph")
retyped.append((str(prim.GetPrimPath()), prim.GetTypeName(), "OmniGraph"))
prim.SetTypeName("OmniGraph")
elif prim.GetTypeName() == "ComputeNode":
carb.log_info(f"Converting node {prim.GetPrimPath()} from ComputeNode to OmniGraphNode")
retyped.append((str(prim.GetPrimPath()), prim.GetTypeName(), "OmniGraphNode"))
prim.SetTypeName("OmniGraphNode")
# Ensure that the schema-defined attributes on the node are no longer custom
node_prim = OmniGraphSchema.OmniGraphNode(prim)
if node_prim:
node_type_attr = node_prim.GetNodeTypeAttr()
if node_type_attr.IsValid():
if not node_type_attr.SetCustom(False):
carb.log_warn(f"Failed to set node:type attribute to non-custom on {prim.GetPrimPath()}")
else:
carb.log_warn(f"OmniGraph prim node {prim.GetPrimPath()} has no node:type attribute")
node_type_version_attr = node_prim.GetNodeTypeVersionAttr()
if node_type_version_attr.IsValid():
if not node_type_version_attr.SetCustom(False):
carb.log_warn(
f"Failed to set node:typeVersion attribute to non-custom on {prim.GetPrimPath()}"
)
else:
carb.log_warn(f"OmniGraph prim node {prim.GetPrimPath()} has no node:type attribute")
else:
# This might be an error or it might just be the fact that the USD notification to change the type
# hasn't been processed yet. As this is only temporary compatibility code and we know that when
# reading a file the prims are immediately valid there is no need to add the complexity here to
# tie into an event loop and await the USD notification propagation.
pass
return retyped
# --------------------------------------------------------------------------------------------------------------
def __create_top_level_graph(self) -> List[Tuple[str, str]]:
"""If there are any nodes or settings not in a graph then create a graph for them and move them into it.
Assumes that before calling this all of the old prim type names have been replaced with the schema prim
type names.
Args:
stage: USD stage on which to replace settings
Return:
List of (old_path, new_path) for prims that were moved from the root level to a new graph
Raises:
og.OmniGraphError if the required prim changes failed
"""
iterator = iter(self.stage.TraverseAll())
# Collect this map of settings prim path onto the path at which the parent graph must be created
prims_to_move = []
for prim in iterator:
if prim.GetTypeName() in ["ComputeGraphSettings", "OmniGraphNode"]:
parent = prim.GetParent()
if not parent.IsValid() or parent.GetTypeName() != "OmniGraph":
prims_to_move.append(prim)
elif prim.GetTypeName() in ["ComputeGraph", "OmniGraph"]:
iterator.PruneChildren()
prim_paths_moved = []
if prims_to_move:
carb.log_info(f"Creating top level graph for global nodes {[prim.GetPrimPath() for prim in prims_to_move]}")
for prim in prims_to_move:
parent_path = str(prim.GetParent().GetPrimPath())
if parent_path[-1] != "/":
parent_path += "/"
default_global_graph_path = f"{parent_path}__graphUsingSchemas"
global_graph_prim = self.stage.GetPrimAtPath(default_global_graph_path)
if not global_graph_prim:
(status, result) = execute("CreatePrim", prim_path=default_global_graph_path, prim_type="OmniGraph")
if not status:
raise og.OmniGraphError(
f"Error creating OmniGraph prim at {default_global_graph_path} - {result}"
)
new_prim_path = f"{default_global_graph_path}/{prim.GetName()}"
prim_paths_moved.append((str(prim.GetPrimPath()), new_prim_path))
carb.log_info(f"Move {prim.GetPrimPath()} -> {new_prim_path}")
(status, result) = execute("MovePrim", path_from=prim.GetPrimPath(), path_to=new_prim_path)
if not status:
raise og.OmniGraphError(
f"Error moving OmniGraph prim from {prim.GetPrimPath()} to {new_prim_path} - {result}"
)
return prim_paths_moved
# --------------------------------------------------------------------------------------------------------------
def __replace_settings_with_properties(self, new_file_format_version: Tuple[int, int]) -> List[str]:
"""If there are any of the old settings prims move their property values into their containing graph.
Args:
new_file_format_version: The file format version that should be used for the graph setting
Return:
List of prim paths with settings that were transferred to the containing graph and then deleted
"""
iterator = iter(self.stage.TraverseAll())
prims_to_remove = []
for prim in iterator: # noqa: PLR1702
if prim.GetTypeName() == "ComputeGraphSettings":
carb.log_info(f"Moving settings from {prim.GetPrimPath()} into the parent graph")
graph_prim = prim.GetParent()
# Need to check against the old types as well as the USD change notices may not have percolated
if graph_prim.IsValid() and graph_prim.GetTypeName() in [
"GlobalComputeGraph",
"ComputeGraph",
"OmniGraph",
]:
for attr in prim.GetAttributes():
setting_name = attr.GetName()
setting_value = attr.Get()
if setting_name == "flatCacheBacking":
setting_name = "fabricCacheBacking"
if setting_value == "StagedWithHistory":
setting_value = "StageWithHistory"
graph_attr = graph_prim.GetAttribute(setting_name)
if not graph_attr.IsValid():
graph_attr = graph_prim.CreateAttribute(
setting_name, attr.GetTypeName(), custom=False, variability=attr.GetVariability()
)
if graph_attr.IsValid():
graph_attr.Set(setting_value)
else:
carb.log_warn(
f"Could not create settings attribute {attr.GetName()}"
f" on graph {graph_prim.GetPrimPath()}"
)
prims_to_remove.append(str(prim.GetPrimPath()))
schema_prim = OmniGraphSchema.OmniGraph(graph_prim)
if bool(schema_prim):
file_format_version_attr = schema_prim.GetFileFormatVersionAttr()
file_format_version_attr.Set(Gf.Vec2i(new_file_format_version))
else:
carb.log_warn(f"Could not cast graph prim {graph_prim.GetPrimPath()} to OmniGraph schema")
else:
carb.log_warn(f"Could not find graph above {prim.GetPrimPath()} to receive settings")
elif prim.GetTypeName() == "ComputeNodeMetadata":
# Take advantage of the loop to also get rid of the obsolete metadata children
prims_to_remove.append(str(prim.GetPrimPath()))
if prims_to_remove:
(status, result) = execute("DeletePrims", paths=prims_to_remove)
if not status:
raise og.OmniGraphError(f"Error deleting prims {prims_to_remove} - {result}")
return prims_to_remove
# --------------------------------------------------------------------------------------------------------------
# Handling for old files that did not use the OmniGraph schema (earlier than 1.3)
def update(self, new_file_format_version: Optional[Tuple[int, int]] = None) -> Dict[str, Any]:
"""Update the current file to use the new schema.
This can run either before OmniGraph has attached to the stage (e.g. when reading in an old file) or when an
explicit migration has been requested (e.g. when an old file exists and the user wants to migrate it). In both
cases if any prim types have been migrated the useSchemaPrims setting will be forced to True so that subsequent
OmniGraph additions use the schema types. (Mostly because this is easier than trying to track the state of
whether a graph contains such prims already.)
Conversion of old scenes entails:
- Changing any ComputeGraph or GlobalComputeGraph prims to be OmniGraph types
- If a ComputeGraphSettings prim exists, migrating its attribute values to the OmniGraph prim
- Changing any ComputeNode prims to be OmniGraphNode types
- If any ComputeNode prims appear without a parent ComputeGraph then create a default graph
and move them into it
Args:
new_file_format_version: The file format version that should be used for the graph setting. If None then
it will force the version immediately following the schema conversion (1, 4)
Return:
A dictionary of operations that were performed as part of the migration (key describes the operation, value
is the objects to which it was applied)
"""
stage = omni.usd.get_context().get_stage()
if stage is None:
return {"message": "No stage to convert"}
try:
self.__command_count = 0
return_values = {}
# Verify that the old prim nodes don't exist
old_prim_nodes = self.__check_for_old_prim_nodes()
if old_prim_nodes:
raise og.OmniGraphError(
f"Deprecated omni.graph.core.Prim nodes not allowed with schema - {old_prim_nodes}"
)
# Verify that bare connections from OmniGraph nodes to non-OmniGraph prims do not exist
bare_connections = check_for_bare_connections(self.stage)
if bare_connections:
raise og.OmniGraphError(
"Deprecated connections from an OmniGraph node to a USD Prim not allowed with schema"
f" - {bare_connections}"
)
# First pass - change ComputeGraph/GlobalComputeGraph -> OmniGraph and ComputeNode -> OmniGraphNode
return_values["Prim Types Changed"] = self.__change_prim_types_to_match_schema()
# Second pass - if there are any OmniGraphNode or ComputeGraphSettings prims not in a graph,
# create one and move them into it
return_values["Root Prims Moved To Graph"] = self.__create_top_level_graph()
# Third pass - move settings from their own prim to the parent graph prim
if new_file_format_version is None:
new_file_format_version = (1, 4)
return_values["Settings Removed"] = self.__replace_settings_with_properties(new_file_format_version)
# Now that the scene has been migrated the schema setting has to be enabled or bad things will happen.
# Don't bother doing it if nothing changed though.
if any(return_values.values()):
carb.settings.get_settings().set(USE_SCHEMA_PRIMS_SETTING, True)
return return_values
except og.OmniGraphError as error:
# If anything failed it would leave the graph in a hybrid state so try to restore it back to its original
# state so that it remains stable.
carb.log_error(str(error))
for _i in range(self.__command_count):
omni.kit.undo()
return_values = {}
return return_values
# ==============================================================================================================
# Handling for old files that did not use the OmniGraph schema (earlier than 1.3)
def update_to_include_schema(new_file_format_version: Optional[Tuple[int, int]] = None) -> Dict[str, Any]:
"""Update the current file to use the new schema. See OmniGraphSchemaMigrator.update() for details
This can run either before OmniGraph has attached to the stage (e.g. when reading in an old file) or when an
explicit migration has been requested (e.g. when an old file exists and the user wants to migrate it). In both
cases if any prim types have been migrated the useSchemaPrims setting will be forced to True so that subsequent
OmniGraph additions use the schema types. (Mostly because this is easier than trying to track the state of whether
a graph contains such prims already.)
Conversion of old scenes entails:
- Changing any ComputeGraph or GlobalComputeGraph prims to be OmniGraph types
- If a ComputeGraphSettings prim exists, migrating its attribute values to the OmniGraph prim
- Changing any ComputeNode prims to be OmniGraphNode types
- If any ComputeNode prims appear without a parent ComputeGraph create a default graph and move them into it
Args:
new_file_format_version: The file format version that should be used for the graph setting. If None then it will
force the version immediately following the schema conversion (1, 4)
Return:
A dictionary of operations that were performed as part of the migration (key describes the operation, value
is the objects to which it was applied)
Raises:
og.OmniGraphError if any of the attempted changes failed - will attempt to restore graph to original state
"""
return OmniGraphSchemaMigrator().update()
# ==============================================================================================================
# Handling for old files that did not use the OmniGraph schema (earlier than 1.3)
def cb_update_to_include_schema(
old_version: Optional[og.FileFormatVersion], new_version: Optional[og.FileFormatVersion], graph: Optional[og.Graph]
) -> Dict[str, Any]:
"""Callback invoked when a file is loaded to update old files to use the new schema.
This will be called anytime a file is loaded with a non-current version. The old version and new version are
checked to confirm that the values cross over the boundary when schemas were created, and if so then the schema
information is applied to the file.
Args:
old_version: Version the file to upgrade uses
new_version: Current file version expected
graph: Graph to convert (only present for historical reasons - the entire stage is updated)
Return:
A dictionary of operations that were performed as part of the migration (key describes the operation, value
is the objects to which it was applied)
"""
# If the setting to automatically migrate is not on then there is nothing to do here
if not carb.settings.get_settings().get(USE_SCHEMA_PRIMS_SETTING):
return {}
# If the file format version is one of the ones that must contain schema prims no migration is needed
if old_version is not None and (
old_version.majorVersion > LAST_FILE_FORMAT_VERSION_WITHOUT_SCHEMA.majorVersion
or (
old_version.majorVersion == LAST_FILE_FORMAT_VERSION_WITHOUT_SCHEMA.majorVersion
and old_version.minorVersion > LAST_FILE_FORMAT_VERSION_WITHOUT_SCHEMA.minorVersion
)
):
return {"message": f"File format version {old_version} already uses the schema"}
return update_to_include_schema((new_version.majorVersion, new_version.minorVersion))
# --------------------------------------------------------------------------------------------------------------
RESETTING_USE_SCHEMA_PRIMS = False
"""Global variable to avoid potential infinite recursion when restoring the useSchemaPrims setting"""
RESETTING_IMPLICIT_GRAPH = False
"""Global variable to avoid potential infinite recursion when restoring the allowGlobalImplicitGraph setting"""
# --------------------------------------------------------------------------------------------------------------
def can_set_use_schema_prims_setting(new_value: bool) -> str:
"""Check to see if a new value for the schema prims setting is valid - returns warning text, empty if okay"""
def __prim_types_in_scene(prim_types: List[str]) -> bool:
"""Returns true if the scene contains prims whose types are any in the list"""
found_prims = []
stage = omni.usd.get_context().get_stage()
if stage is not None:
iterator = iter(stage.TraverseAll())
for prim in iterator:
if prim.GetTypeName() in prim_types:
found_prims.append(f"{prim.GetPrimPath()} : {prim.GetTypeName()}")
return found_prims
if new_value:
forbidden_prims = __prim_types_in_scene(
["ComputeGraphSettings", "ComputeNode", "ComputeGraph", "GlobalComputeGraph"]
)
if forbidden_prims:
return f"Cannot enable {USE_SCHEMA_PRIMS_SETTING} when the scene contains old style prims {forbidden_prims}"
bare_connections = check_for_bare_connections(check_for_bare_connections(omni.usd.get_context().get_stage()))
if bare_connections:
return (
f"Cannot enable {USE_SCHEMA_PRIMS_SETTING} when the scene contains"
f" direct prim connections {bare_connections}"
)
else:
forbidden_prims = __prim_types_in_scene(["OmniGraph", "OmniGraphNode"])
if forbidden_prims:
return f"Cannot disable {USE_SCHEMA_PRIMS_SETTING} when the scene contains schema prims {forbidden_prims}"
return ""
| 24,664 | Python | 53.089912 | 120 | 0.579144 |
omniverse-code/kit/exts/omni.graph/omni/graph/core/_impl/v1_5_0/omnigraph_helper.py | # noqa: PLC0302
r"""Deprecated class that handles interactions with the OmniGraphs - use og.Controller instead
_____ ______ _____ _____ ______ _____ _______ ______ _____
| __ \ | ____|| __ \ | __ \ | ____|/ ____| /\ |__ __|| ____|| __ \
| | | || |__ | |__) || |__) || |__ | | / \ | | | |__ | | | |
| | | || __| | ___/ | _ / | __| | | / /\ \ | | | __| | | | |
| |__| || |____ | | | | \ \ | |____| |____ / ____ \ | | | |____ | |__| |
|_____/ |______||_| |_| \_\|______|\_____|/_/ \_\|_| |______||_____/
"""
import os
from contextlib import suppress
from typing import Any, Dict, List, Optional, Tuple, Union
import omni.graph.core as og
import omni.graph.tools as ogt
import omni.kit.commands
from carb import log_info, log_warn
from pxr import Sdf, Tf, Usd
from ..errors import OmniGraphError
from ..object_lookup import ObjectLookup
from ..typing import Attribute_t, Node_t
from ..utils import DBG_EVAL, dbg_eval
from .context_helper import ContextHelper
from .utils import (
ATTRIBUTE_TYPE_HINTS,
ATTRIBUTE_TYPE_OR_LIST,
ATTRIBUTE_TYPE_TYPE_HINTS,
ATTRIBUTE_VALUE_PAIR,
ATTRIBUTE_VALUE_PAIRS,
EXTENDED_ATTRIBUTE_TYPE_HINTS,
NODE_TYPE_HINTS,
NODE_TYPE_OR_LIST,
)
# Function argument types passed to the various graph interface operations
ConnectData_t = Tuple[Node_t, Attribute_t, Node_t, Attribute_t]
ConnectDatas_t = Union[ConnectData_t, List[ConnectData_t]]
CreateNodeData_t = Tuple[str, Node_t]
CreateNodeDatas_t = Union[CreateNodeData_t, List[CreateNodeData_t]]
CreatePrimData_t = Tuple[str, Dict[str, Tuple[str, Any]]]
CreatePrimDatas_t = Union[CreatePrimData_t, List[CreatePrimData_t]]
DeleteNodeData_t = str
DeleteNodeDatas_t = Union[DeleteNodeData_t, List[DeleteNodeData_t]]
DisconnectData_t = Tuple[Node_t, Attribute_t, Node_t, Attribute_t]
DisconnectDatas_t = Union[DisconnectData_t, List[DisconnectData_t]]
SetValueData_t = Tuple[Attribute_t, Any]
SetValueDatas_t = Union[SetValueData_t, List[SetValueData_t]]
# Decoded attribute bundle possibilities
BundledAttribute_t = Optional[Union[Usd.Prim, Usd.Property]]
# =====================================================================
@ogt.DeprecatedClass("og.OmniGraphHelper is deprecated after version 1.5.0. Use og.Controller instead.")
class OmniGraphHelper:
"""Class to provide a simple interface to OmniGraph manipulation functions
Provides functions for creating nodes, making and breaking connections, and setting values.
Graph manipulation functions are undoable, value changes are not.
The main benefit this class provides over direct manipulation of the graph is that it accepts
a variety of types for its operations. e.g. a connection could take an OmniGraph Node, a USD Prim,
or a string indicating the path to the node.
Attributes:
graph: The OmniGraph on which operations will be performed.
Raises:
OmniGraphError: If there is not enough information to perform the requested operation
"""
# Type of connection point
PRIM_TYPE = 0
BUNDLE_TYPE = 1
REGULAR_TYPE = 2
UNKNOWN = -1
# ----------------------------------------------------------------------
def __init__(self, omnigraph: Optional[og.Graph] = None):
"""Initialize the graph"""
if omnigraph is None:
self.graph = og.get_current_graph()
else:
self.graph = omnigraph
# ----------------------------------------------------------------------
def context(self):
"""Returns the evaluation context for the graph to which this helper is attached"""
return self.graph.get_default_graph_context()
# ----------------------------------------------------------------------
async def evaluate(self):
"""Wait for the next Graph evaluation cycle - await this function to ensure it is finished before returning.
If the graph evaluation time is not incremented after 10 application updates, RuntimeError is raised.
"""
start_t = self.context().get_time_since_start()
# Ensure that a graph evaluation has happened before returning
for _ in range(10):
await omni.kit.app.get_app().next_update_async()
now_t = self.context().get_time_since_start()
if now_t > start_t:
return
raise RuntimeError(f"Graph evaluation time {now_t} was not incremented from start time {start_t}")
# ----------------------------------------------------------------------
@staticmethod
def safe_node_name(node_type_name: str, abbreviated: bool = False) -> str:
"""Returns a USD-safe node name derived from the node_type_name (stripping namespace)
Args:
node_type_name: Fully namespaced name of the node type
abbreviated: If True then remove the namespace, else just make the separators into underscores
Returns:
A safe node name that roughly corresponds to the given node type name
"""
if abbreviated:
last_namespace = node_type_name.rfind(".")
if last_namespace < 0:
return node_type_name
return node_type_name[last_namespace + 1 :]
return node_type_name.replace(".", "_")
# ----------------------------------------------------------------------
def omnigraph_node(self, node_info: NODE_TYPE_OR_LIST) -> Union[og.Node, List[og.Node]]:
"""Returns the OmniGraph node(s) corresponding to the variable type parameter
Args:
node_info: Information for the node to find. If a list then iterate over the list
Returns:
Node(s) corresponding to the description(s) in the current graph, None where there is no match
Raises:
OmniGraphError if the node description wasn't one of the recognized types
"""
return ObjectLookup.node(node_info)
# ----------------------------------------------------------------------
def omnigraph_attribute(
self, node: NODE_TYPE_HINTS, attribute_info: ATTRIBUTE_TYPE_OR_LIST
) -> Union[og.Attribute, List[og.Attribute]]:
"""Returns the OmniGraph attribute(s) corresponding to the variable type parameter
Args:
node: Node to which the attribute belongs. Ignored if attribute_info is an og.Attribute
attribute_info: Information on which attribute to look for. If a list then get all of them
Returns:
Attribute(s) matching the description(s) - None where there is no match
Raises:
OmniGraphError if the attribute description wasn't one of the recognized types, or if
any of the attributes could not be found
"""
return ObjectLookup.attribute(attribute_info, node)
# ----------------------------------------------------------------------
def node_as_prim(self, node: NODE_TYPE_HINTS) -> Usd.Prim:
"""Returns the prim corresponding to the variable type parameter"""
if isinstance(node, Sdf.Path):
return omni.usd.get_context().get_stage().GetPrimAtPath(node.GetPrimPath())
if isinstance(node, og.Node):
return omni.usd.get_context().get_stage().GetPrimAtPath(node.get_prim_path())
if isinstance(node, Usd.Prim):
return node
with suppress(Exception):
if isinstance(node, str):
return omni.usd.get_context().get_stage().GetPrimAtPath(self.graph.get_node(node).get_prim_path())
raise OmniGraphError(f"Failed to get prim on {node}")
# ----------------------------------------------------------------------
def get_prim_path(self, node: NODE_TYPE_HINTS):
"""Returns the prim path corresponding to the variable type parameter"""
if isinstance(node, Sdf.Path):
return node.GetPrimPath()
if isinstance(node, og.Node):
return node.get_prim_path()
if isinstance(node, Usd.Prim):
return node.GetPath()
with suppress(Exception):
if isinstance(node, str):
return self.graph.get_node(node).get_prim_path()
raise OmniGraphError(f"Failed to get prim path on {node}")
# ----------------------------------------------------------------------
# begin-create-attribute-function
def create_attribute(
self,
node: NODE_TYPE_HINTS,
attr_name: str,
attr_type: ATTRIBUTE_TYPE_TYPE_HINTS,
attr_port: Optional[og.AttributePortType] = og.AttributePortType.ATTRIBUTE_PORT_TYPE_INPUT,
attr_default: Optional[Any] = None,
attr_extended_type: Optional[
EXTENDED_ATTRIBUTE_TYPE_HINTS
] = og.ExtendedAttributeType.EXTENDED_ATTR_TYPE_REGULAR,
) -> Optional[og.Attribute]:
"""Create a new dynamic attribute on the node
Args:
node: Node on which to create the attribute (path or og.Node)
attr_name: Name of the new attribute, either with or without the port namespace
attr_type: Type of the new attribute, as an OGN type string or og.Type
attr_port: Port type of the new attribute, default is og.AttributePortType.ATTRIBUTE_PORT_TYPE_INPUT
attr_default: The initial value to set on the attribute, default is None
attr_extended_type: The extended type of the attribute, default is
og.ExtendedAttributeType.EXTENDED_ATTR_TYPE_REGULAR. If the extended type is
og.ExtendedAttributeType.EXTENDED_ATTR_TYPE_UNION then this parameter will be a
2-tuple with the second element being a list or comma-separated string of union types
Returns:
The newly created attribute, None if there was a problem creating it
"""
# end-create-attribute-function
ogt.dbg(f"Create attribute '{attr_name}' on node {node} of type {attr_type}")
omg_node = self.omnigraph_node(node)
omg_attr_type = ObjectLookup.attribute_type(attr_type)
(success, result) = og.cmds.CreateAttr(
node=omg_node,
attr_name=attr_name,
attr_type=omg_attr_type,
attr_port=attr_port,
attr_default=attr_default,
attr_extended_type=attr_extended_type,
)
if not result or not success:
return None
namespace = og.get_port_type_namespace(attr_port)
if not attr_name.startswith(namespace):
if (
omg_attr_type.get_type_name() == "bundle"
and attr_port != og.AttributePortType.ATTRIBUTE_PORT_TYPE_INPUT
):
separator = "_"
else:
separator = ":"
attr_name = f"{namespace}{separator}{attr_name}"
return omg_node.get_attribute(attr_name)
# ----------------------------------------------------------------------
# begin-remove-attribute-function
def remove_attribute(self, attribute: ATTRIBUTE_TYPE_HINTS, node: Optional[NODE_TYPE_HINTS] = None) -> bool:
"""Removes an existing dynamic attribute from a node.
Args:
attribute: Name of the attribute to be removed
node: If not None and the attribute is specified as a string then this is the node on which it lives
Returns:
True if the attribute was successfully removed, else False
"""
# end-remove-attribute-function
ogt.dbg(f"Remove attribute {attribute} using node {node}")
omg_attribute = self.omnigraph_attribute(node, attribute)
(success, result) = og.cmds.RemoveAttr(attribute=omg_attribute)
return success and result
# ----------------------------------------------------------------------
def create_node(
self, node_path: str, node_type: str, allow_exists: bool = False, version: Optional[int] = None
) -> og.Node:
"""Create an OmniGraph node of the given type and version at the given path.
Args:
node_path: SdfPath to the node in the stage
node_type: Type of node to create
check_exists: If true then succeed if a node with matching path, type, and version already exists
version: Version of the node type to create. By default it creates the most recent.
Raises:
OmniGraphError: If the node already existed
Returns:
OmniGraph node added to the scene, or None if it could not be created
"""
ogt.dbg(f"Create '{node_path}' of type '{node_type}', allow={allow_exists}, version={version}")
if version is not None:
raise OmniGraphError("Creating nodes with specific versions not supported")
node = self.graph.get_node(node_path)
if node is not None and node.is_valid():
if allow_exists:
current_node_type = node.get_type_name()
if node_type == current_node_type:
return node
error = f"already exists as type {current_node_type}"
else:
error = "already exists"
raise OmniGraphError(f"Creation of {node_path} as type {node_type} failed - {error}")
og.cmds.CreateNode(graph=self.graph, node_path=node_path, node_type=node_type, create_usd=True)
return self.graph.get_node(node_path)
# ----------------------------------------------------------------------
def create_prim(self, prim_path: str, attribute_info: Dict[str, Tuple[Union[str, og.Type], Any]]):
"""Create a prim node containing a predefined set of attribute values and a ReadPrim OmniGraph node for it
Args:
prim_path: Location of the prim
attribute_info: Dictionary of {NAME: (TYPE, VALUE)} for all prim attributes
The TYPE is in OGN format, so "float[3][]", "bundle", etc.
The VALUE should be in a format suitable for passing to pxr::UsdAttribute.Set()
Returns:
og.Node of the created node
"""
stage = omni.usd.get_context().get_stage()
omni.kit.commands.execute("CreatePrim", prim_path=prim_path, prim_type="BundleSource")
prim = stage.GetPrimAtPath(prim_path)
# Walk the list of attribute descriptions, creating them on the prim as they go
for attribute_name, (attribute_type_name, attribute_value) in attribute_info.items():
if isinstance(attribute_type_name, og.Type):
attribute_type = attribute_type_name
attribute_type_name = attribute_type.get_ogn_type_name()
else:
attribute_type = og.AttributeType.type_from_ogn_type_name(attribute_type_name)
manager = ogt.get_attribute_manager_type(attribute_type_name)
sdf_type_name = manager.sdf_type_name()
if sdf_type_name is not None:
sdf_type = getattr(Sdf.ValueTypeNames, sdf_type_name)
usd_value = og.attribute_value_as_usd(attribute_type, attribute_value)
prim.CreateAttribute(attribute_name, sdf_type).Set(usd_value)
# Add the new Prim to OmniGraph
return og.cmds.CreateNode(
graph=self.graph, node_path=prim_path, node_type="omni.graph.core.Prim", create_usd=False
)[1]
# ----------------------------------------------------------------------
def delete_node(self, node: NODE_TYPE_HINTS, allow_noexists: bool = False) -> bool:
"""Deletes an OmniGraph node at the given path.
Args:
node: node to be deleted
allow_noexists: If true then succeed if no node with matching path exists
Raises:
OmniGraphError: If the node does not exist
Returns:
True if the node is gone
"""
ogt.dbg(f"Delete '{node}', allow_noexists={allow_noexists}")
try:
omnigraph_node = self.omnigraph_node(node)
except Exception:
if allow_noexists:
return True
raise
return og.cmds.DeleteNode(graph=self.graph, node_path=omnigraph_node.get_prim_path(), modify_usd=True)[0]
# ----------------------------------------------------------------------
def attach_to_prim(self, prim: Union[Usd.Prim, str]) -> og.Node:
"""Create a new compute node attached to an ordinary USD prim.
Args:
prim: Prim node or name of prim node to which the OmniGraph node should attach
Returns:
OmniGraph Prim type node associated with the passed in Prim
"""
ogt.dbg(f"Attach to prim {prim}")
if isinstance(prim, str):
prim_path = prim
else:
prim_path = str(prim.GetPath())
return self.create_node(prim_path, "omni.graph.core.Prim", allow_exists=True)
# ----------------------------------------------------------------------
@staticmethod
def get_attr_type_name(attr):
"""
Get the type name for the given attribute, taking in to account extended type
Args:
attr: Attribute whose type is to be determined
Returns:
The type name of the attribute
"""
type_name = None
with suppress(AttributeError):
if attr.get_extended_type() in [
og.ExtendedAttributeType.EXTENDED_ATTR_TYPE_ANY,
og.ExtendedAttributeType.EXTENDED_ATTR_TYPE_UNION,
]:
type_name = attr.get_resolved_type().get_type_name()
if type_name is None:
try:
type_name = attr.get_type_name()
except AttributeError:
type_name = attr.get_type().get_type_name()
return type_name
# ----------------------------------------------------------------------
@staticmethod
def get_attr_type(attr: Union[og.Attribute, og.AttributeData]):
"""
Get the type for the given attribute, taking in to account extended type
Args:
attr: Attribute whose type is to be determined
Returns:
The type of the attribute
"""
return attr.get_resolved_type() if isinstance(attr, og.Attribute) else attr.get_type()
# ----------------------------------------------------------------------
def _decode_connection_point(
self, node_info: NODE_TYPE_HINTS, attr_info: ATTRIBUTE_TYPE_HINTS
) -> Tuple[int, Optional[Usd.Prim], og.Node, Optional[og.Attribute]]:
"""Decode a connection point into identifying pieces
Args:
node_info: Identifying information for an OmniGraph node
attr_info: Identifying information for an OmniGraph node's attribute
Returns:
(location_type, prim, node, attribute)
location_type: what type of connection point this is - bundle, regular, or prim
prim: Prim of the connection point, or None if it is not a prim type
node: og.Node of the connection point, or None if it is a prim
attribute: og.Attribute of the connection point, or None if it is a prim
Raises:
OmniGraphError if the configuration of the connection point is not consistent
"""
attr_type = self.UNKNOWN
prim = None
node = node_info
attr = None
if attr_info is None:
prim = self.node_as_prim(node_info)
if not prim.IsValid():
raise OmniGraphError("When attribute is None, node must be a valid Prim")
attr_type = self.PRIM_TYPE
else:
node = self.omnigraph_node(node_info)
if not node.is_valid():
raise OmniGraphError("When attribute is specified, node must be a valid OmniGraph node")
attr = self.omnigraph_attribute(node, attr_info)
if not attr.is_valid():
raise OmniGraphError("Attribute is not valid")
if attr.get_type_name() == "bundle":
attr_type = self.BUNDLE_TYPE
else:
attr_type = self.REGULAR_TYPE
assert attr_type != self.UNKNOWN
return (attr_type, prim, node, attr)
# ----------------------------------------------------------------------
def _decode_connection_type(
self,
src_node_info: NODE_TYPE_HINTS,
src_attr_info: ATTRIBUTE_TYPE_HINTS,
dst_node_info: NODE_TYPE_HINTS,
dst_attr_info: ATTRIBUTE_TYPE_HINTS,
) -> Tuple[Union[Usd.Prim, og.Attribute], og.Attribute]:
"""
Decode the node and source information into an Attribute->Attribute connection or a Prim->Bundle connection.
Everything is set up to be fairly generic so that if we have more general connections in the future it can
still be handled using the same framework.
The source and destination comes from _decode_connection_point() with these legal cases:
Prim -> bundleAttribute
src_attr_info is None, src_node_info is Prim, dst_attr_info.type == bundle
bundleAttribute -> bundleAttribute
src_attr_info.type == dst_attr_info.type == bundle
attribute -> attribute
src_attr_info.type != bundle, dst_attr_info.type != bundle
Args:
src_node_info: Node on the source (input) end of the connection.
src_attr_info: Attribute on the source (input) end of the connection - None means connect from a Prim.
dst_node_info: Node on the destination (output) end of the connection.
dst_attr_info: Attribute on the destination (output) end of the connection.
Returns:
(src_location, dst_location):
If a Prim->Bundle connection:
src_location: Usd.Prim where the connection originates
dst_location: og.Attribute where the connection terminates
If an Attribute->Attribute connection
src_location: og.Attribute where the connection originates
dst_location: og.Attribute where the connection terminates
Raises:
OmniGraphError: If the connection request doesn't fall into one of the allowed cases
"""
src_location = None
dst_location = None
src_path = f"{self.get_prim_path(src_node_info)}.{src_attr_info}"
dst_path = f"{self.get_prim_path(dst_node_info)}.{dst_attr_info}"
try:
(src_type, src_prim, src_node, src_attr) = self._decode_connection_point(src_node_info, src_attr_info)
(dst_type, _, dst_node, dst_attr) = self._decode_connection_point(dst_node_info, dst_attr_info)
if src_type == self.PRIM_TYPE:
if dst_type == self.PRIM_TYPE:
raise OmniGraphError("Prim -> Prim connection not valid, use AddRelationship/RemoveRelationship")
if dst_type == self.REGULAR_TYPE:
raise OmniGraphError("Prim -> Attribute connection not allowed")
if not dst_node or not dst_node.is_valid() or not dst_attr:
raise OmniGraphError("Destination is invalid")
# Prim -> Bundle connection
if dst_type == self.BUNDLE_TYPE:
src_location = src_prim
dst_location = dst_attr
ogt.dbg(f"Prim -> Bundle {src_path} -> {dst_path}")
elif src_type == self.BUNDLE_TYPE:
if dst_type == self.REGULAR_TYPE:
raise OmniGraphError("Bundle -> Attribute connection not allowed")
if not src_node or not src_node.is_valid() or not src_attr:
raise OmniGraphError("Source is invalid")
if not dst_node or not dst_node.is_valid() or not dst_attr:
raise OmniGraphError("Destination is invalid")
# Bundle -> Bundle connection
if dst_type == self.BUNDLE_TYPE:
src_location = src_attr
dst_location = dst_attr
ogt.dbg(f"Bundle -> Bundle {src_path} -> {dst_path}")
# Bundle -> Prim connection
if dst_type == self.PRIM_TYPE:
raise OmniGraphError("Bundle -> Prim connection not allowed")
else:
if dst_type == self.PRIM_TYPE:
raise OmniGraphError("Attribute -> Prim connection not allowed")
if dst_type == self.BUNDLE_TYPE:
raise OmniGraphError("Attribute -> Bundle connection not allowed")
if not src_node or not src_node.is_valid() or not src_attr:
raise OmniGraphError("Source is invalid")
if not dst_node or not dst_node.is_valid() or not dst_attr:
raise OmniGraphError("Destination is invalid")
# Attribute -> Attribute connection
src_location = src_attr
dst_location = dst_attr
ogt.dbg(f"Attribute -> Attribute {src_path} -> {dst_path}")
except OmniGraphError as error:
raise OmniGraphError(f"{src_path} -> {dst_path}") from error
return (src_location, dst_location)
# ----------------------------------------------------------------------
def connect(
self,
src_node: NODE_TYPE_HINTS,
src_attr: ATTRIBUTE_TYPE_HINTS,
dst_node: NODE_TYPE_HINTS,
dst_attr: ATTRIBUTE_TYPE_HINTS,
):
"""Create a connection between two attributes
Args:
src_node: Node on the source (input) end of the connection. Ignored if src_attr is an og.Attribute
src_attr: Attribute on the source (input) end of the connection. (If None then it's a prim connection)
dst_node: Node on the destination (output) end of the connection. Ignored if dst_attr is an og.Attribute
dst_attr: Attribute on the destination (output) end of the connection.
Raises:
OmniGraphError: If nodes or attributes could not be found, or connection fails
"""
ogt.dbg(f"Connect {src_node},{src_attr} -> {dst_node},{dst_attr}")
(src_location, dst_location) = self._decode_connection_type(src_node, src_attr, dst_node, dst_attr)
if src_location is None or dst_location is None:
success = False
error = "Connection locations not recognized"
elif isinstance(src_location, Usd.Prim):
ogt.dbg(" Connect Prim -> Bundle")
(success, error) = og.cmds.ConnectPrim(
attr=dst_location,
prim_path=src_location.GetPath().pathString,
is_bundle_connection=src_attr is not None,
)
else:
ogt.dbg(f" Connect Attr {src_location.get_name()} to {dst_location.get_name()}")
(success, error) = og.cmds.ConnectAttrs(src_attr=src_location, dest_attr=dst_location, modify_usd=True)
if not success:
raise OmniGraphError(
f"Failed to connect {self.get_prim_path(src_node)}.{src_attr}"
f" -> {self.get_prim_path(dst_node)}.{dst_attr} ({error})"
)
# ----------------------------------------------------------------------
def disconnect(
self,
src_node: NODE_TYPE_HINTS,
src_attr: ATTRIBUTE_TYPE_HINTS,
dst_node: NODE_TYPE_HINTS,
dst_attr: ATTRIBUTE_TYPE_HINTS,
):
"""Break a connection between two attributes
Args:
src_node: Node on the source (input) end of the connection. Ignored if src_attr is an og.Attribute
src_attr: Attribute on the source (input) end of the connection. If None then it is a prim connection.
dst_node: Node on the destination (output) end of the connection. Ignored if dst_attr is an og.Attribute
dst_attr: Attribute on the destination (output) end of the connection.
Raises:
OmniGraphError: If nodes or attributes could not be found, connection didn't exist, or disconnection fails
"""
ogt.dbg(f"Disconnect {src_node},{src_attr} -> {dst_node},{dst_attr}")
(src_location, dst_location) = self._decode_connection_type(src_node, src_attr, dst_node, dst_attr)
if src_location is None or dst_location is None:
success = False
error = "Connection locations not recognized"
elif isinstance(src_location, Usd.Prim):
(success, error) = og.cmds.DisconnectPrim(
attr=dst_location,
prim_path=src_location.GetPath().pathString,
is_bundle_connection=src_attr is not None,
)
else:
ogt.dbg(f" Disconnect Attr {src_location.get_name()} from {dst_location.get_name()}")
(success, error) = og.cmds.DisconnectAttrs(src_attr=src_location, dest_attr=dst_location, modify_usd=True)
if not success:
raise OmniGraphError(
f"Failed to disconnect {self.get_prim_path(src_node)}.{src_attr}"
f" -> {self.get_prim_path(dst_node)}.{dst_attr} ({error})"
)
# ----------------------------------------------------------------------
def disconnect_all(
self,
attr: ATTRIBUTE_TYPE_HINTS,
node: Optional[NODE_TYPE_HINTS] = None,
):
"""Break all connections to and from an attribute
Args:
attr: Attribute on the source (input) end of the connection. If None then it is a prim connection.
node: Node on the source (input) end of the connection. Ignored if attr is an og.Attribute
Raises:
OmniGraphError: If nodes or attributes could not be found, connection didn't exist, or disconnection fails
"""
ogt.dbg(f"Disconnect all on {node},{attr}")
attribute = self.omnigraph_attribute(node, attr)
if attribute is None:
success = False
error = "Disconnection attribute not recognized"
else:
ogt.dbg(f" Disconnect All from {attribute.get_name()}")
(success, error) = og.cmds.DisconnectAllAttrs(attr=attribute, modify_usd=True)
if not success:
raise OmniGraphError(f"Failed to break connections on {self.get_prim_path(node)}.{attr} ({error})")
# ----------------------------------------------------------------------
def set_attribute_data_values(
self, values_to_set: List[Tuple[og.AttributeData, Any]], graph: Optional[og.Graph] = None
):
"""Set a bunch of attribute data values
Args:
values_to_set: List of (AttributeData, Value) pairs which are the values to be set
Raises:
OmniGraphError: If values could not be set
"""
if not values_to_set:
return
for (attribute_data, value) in values_to_set:
try:
(success, error) = og.cmds.SetAttrData(attribute_data=attribute_data, value=value, graph=graph)
if not success:
raise TypeError(error)
except TypeError as error:
raise OmniGraphError(f"Could not set value on attribute data '{attribute_data.get_name()}'") from error
# ----------------------------------------------------------------------
def set_attribute_values(self, values_to_set: List[Tuple[og.Attribute, Any]], ignore_usd: bool = False):
"""Set a bunch of attribute values
Dict values can be used to specify a type in additional to a value. If the attribute is unresolved, it will be
resolved to that type before setting the value. For example:
set_attribute_values([(attrib, {"type": "float2", "value": (1.0, 2.0)})])
Args:
values_to_set: List of (Attribute, Value) pairs which are the values to be set.
ignore_usd: If False then report any problems updating the USD attributes
Raises:
OmniGraphError: If values could not be set
"""
if not values_to_set:
return
for (attribute, value) in values_to_set:
set_type = None
if isinstance(value, dict):
# special case - we may need to resolve the attribute to this particular type before setting
set_type = value["type"]
value = value["value"]
try:
(success, error) = og.cmds.SetAttr(attr=attribute, value=value, set_type=set_type)
if not success:
raise TypeError(error)
except TypeError as error:
raise OmniGraphError(f"Could not set value on attribute '{attribute.get_name()}'") from error
# ----------------------------------------------------------------------------------------------------
# TODO: This is necessary to update USD at the moment. Updating flatcache and USD should be handled
# directly in SetAttrCommand. Once that has been done this can be deleted.
# {
stage = omni.usd.get_context().get_stage()
prim = stage.GetPrimAtPath(attribute.get_node().get_prim_path())
if prim.IsValid() and attribute.get_extended_type() == og.ExtendedAttributeType.EXTENDED_ATTR_TYPE_REGULAR:
try:
# The Set method wants USD types for some attribute types so do the translation first
value = og.attribute_value_as_usd(OmniGraphHelper.get_attr_type(attribute), value)
prim.GetAttribute(attribute.get_name()).Set(value)
except Tf.ErrorException as error:
if not ignore_usd:
log_warn(f"Could not sync USD on attribute {attribute.get_name()} - {error}")
except TypeError as error:
# TODO: This occurs when the parameters to Set() don't match what USD expects. It could be fixed
# by special-casing every known mismatch but this section should be going away so it won't
# be done at this time. The current known failures are the quaternion types and arrays of the
# tuple-arrays (e.g. "quatd[4]", "double[3][]", "float[2][]", ...)
if not ignore_usd:
log_info(f"Could not set value on attribute {attribute.get_name()} - {error}")
except Exception as error: # noqa: PLW0703
log_warn(f"Unknown problem setting values - {error}")
# }
# ----------------------------------------------------------------------------------------------------
# ----------------------------------------------------------------------
def set_values(self, node: NODE_TYPE_HINTS, values_to_set: ATTRIBUTE_VALUE_PAIRS, ignore_usd: bool = False):
"""Set a bunch of attribute values on a single node
This is general purpose for handling all types of node and attribute descriptions. If you already have
the og.Attributes whose values you wish to set then call set_attribute_values() instead.
Args:
node: Node on which the values are to be set
values_to_set: List or single element of (Attribute, Value) pairs which are the values to be set
ignore_usd: If False then report any problems updating the USD attributes
Raises:
OmniGraphError: If nodes or attributes could not be found, or values could not be set
"""
if not values_to_set:
log_warn("Tried to set values from an empty list")
return
omnigraph_node = self.omnigraph_node(node)
def set_a_value(attribute_and_value: ATTRIBUTE_VALUE_PAIR):
"""Try to set a single value, raising an OmniGraphError exception if anything went wrong"""
if len(attribute_and_value) != 2:
raise OmniGraphError(f"Values to set should be (attribute, value) pairs, not '{attribute_and_value}'")
attribute = self.omnigraph_attribute(omnigraph_node, attribute_and_value[0])
self.set_attribute_values([(attribute, attribute_and_value[1])], ignore_usd=ignore_usd)
if isinstance(values_to_set, list):
if values_to_set and not isinstance(values_to_set[0], tuple) and not isinstance(values_to_set[0], list):
log_warn(f"Call set_values() with a tuple or array of tuples as attribute values, not {values_to_set}")
set_a_value(values_to_set)
else:
for attribute_and_value in values_to_set:
set_a_value(attribute_and_value)
else:
set_a_value(values_to_set)
# ----------------------------------------------------------------------
def get_attribute_values(self, attributes_to_get: List[og.Attribute]) -> List[Any]:
"""Get the values from a list of defined attributes
Args:
attributes_to_get: List of attributes whose values are to be retrieved
Returns:
List of values corresponding to the list of attributes passed in
"""
results = []
context_helper = ContextHelper()
for attribute in attributes_to_get:
try:
results.append(context_helper.get_attr_value(attribute))
except TypeError as error:
raise OmniGraphError(f"Could not get value on attribute '{attribute.get_name()}'") from error
return results
# ----------------------------------------------------------------------
def get_values(self, node: NODE_TYPE_HINTS, attributes_to_get: ATTRIBUTE_TYPE_OR_LIST) -> List[Any]:
"""Get the values from attributes on a node
This is general purpose for handling all types of node and attribute descriptions. If you already have
the og.Attributes whose values you wish to retrieve then call get_attribute_values() instead.
Args:
node: Description of node whose values are to be read
attributes_to_get: One or a list of descriptions of attributes whose values are to be retrieved
Raises:
OmniGraphError: If nodes or attributes could not be found, or values could not be read
Returns:
One or a list of values corresponding to the attributes passed in
"""
omnigraph_node = self.omnigraph_node(node)
if not isinstance(attributes_to_get, List):
return self.get_attribute_values([self.omnigraph_attribute(omnigraph_node, attributes_to_get)])[0]
return self.get_attribute_values(
[self.omnigraph_attribute(omnigraph_node, attribute) for attribute in attributes_to_get]
)
# ----------------------------------------------------------------------
def _edit_delete_nodes(self, root_prim: str, nodes_to_delete: DeleteNodeData_t):
"""Delete the set of nodes passed, using the format required by edit_graph"""
delete_list = nodes_to_delete if isinstance(nodes_to_delete, list) else [nodes_to_delete]
for node_name in delete_list:
dbg_eval(f"Deleting node {node_name}")
node_path = os.path.join(root_prim, node_name).replace("\\", "/")
self.delete_node(node_path, False)
dbg_eval(f"... deleted {node_path}")
# ----------------------------------------------------------------------
def _edit_create_nodes(self, root_prim: str, nodes_to_create: CreateNodeData_t):
"""Create the set of nodes passed, using the format required by edit_graph
Returns a tuple of the map from node path to the created node, and the list of constructed nodes"""
node_path_map = {}
nodes_constructed = []
create_list = nodes_to_create if isinstance(nodes_to_create, list) else [nodes_to_create]
for node_type, node_name in create_list:
dbg_eval(f"Creating node {node_name} of type {node_type}")
node_path = os.path.join(root_prim, node_name).replace("\\", "/")
node_path_map[node_name] = self.create_node(node_path, node_type, False)
nodes_constructed.append(node_path_map[node_name])
dbg_eval(f"... created {node_path_map[node_name]}")
return (node_path_map, nodes_constructed)
# ----------------------------------------------------------------------
def _edit_create_prims(
self,
root_prim: str,
node_path_map: Dict[str, og.Node],
nodes_constructed: List[og.Node],
prims_to_create: CreatePrimData_t,
):
"""Create the set of prims passed, using the format required by edit_graph"""
create_list = prims_to_create if isinstance(prims_to_create, list) else [prims_to_create]
for prim_path, attribute_info in create_list:
dbg_eval(f"Creating prim at {prim_path}")
node_path = os.path.join(root_prim, prim_path).replace("\\", "/")
node_path_map[prim_path] = self.create_prim(node_path, attribute_info)
nodes_constructed.append(node_path_map[prim_path])
dbg_eval(f"... created {node_path_map[prim_path]}")
return (node_path_map, nodes_constructed)
# ----------------------------------------------------------------------
def _edit_connect(self, node_path_map: Dict[str, og.Node], connections_to_make: ConnectData_t):
"""Make a set of attribute connections, using the format required by edit_graph"""
connection_list = connections_to_make if isinstance(connections_to_make, list) else [connections_to_make]
try:
for (src_node_name, src_attr_name, dst_node_name, dst_attr_name) in connection_list:
dbg_eval(f"Connecting {src_node_name}.{src_attr_name} -> {dst_node_name}.{dst_attr_name}")
try:
src_node = node_path_map[src_node_name]
except KeyError:
src_node = src_node_name
try:
dst_node = node_path_map[dst_node_name]
except KeyError:
dst_node = dst_node_name
dbg_eval(f"...nodes resolved to {src_node} and {dst_node}")
self.connect(src_node, src_attr_name, dst_node, dst_attr_name)
dbg_eval("...connection succeeded")
except ValueError as error:
raise OmniGraphError(
f"Connect requires src_node, src_attr, dst_node, dst_attr - got {connection_list}"
) from error
# ----------------------------------------------------------------------
def _edit_disconnect(self, node_path_map: Dict[str, og.Node], connections_to_break: DisconnectData_t):
"""Make a set of attribute disconnections, using the format required by edit_graph"""
connection_list = connections_to_break if isinstance(connections_to_break, list) else [connections_to_break]
try:
for (src_node_name, src_attr_name, dst_node_name, dst_attr_name) in connection_list:
dbg_eval(f"Disconnecting {src_node_name}.{src_attr_name} -> {dst_node_name}.{dst_attr_name}")
try:
src_node = node_path_map[src_node_name]
except KeyError:
src_node = src_node_name
try:
dst_node = node_path_map[dst_node_name]
except KeyError:
dst_node = dst_node_name
dbg_eval(f"...nodes resolved to {src_node} and {dst_node}")
self.disconnect(src_node, src_attr_name, dst_node, dst_attr_name)
dbg_eval("...disconnection succeeded")
except ValueError as error:
raise OmniGraphError(
f"Connect requires src_node, src_attr, dst_node, dst_attr - got {connection_list}"
) from error
# ----------------------------------------------------------------------
def _edit_set_values(self, node_path_map: Dict[str, og.Node], values_to_set: SetValueData_t):
"""Set a bunch of attribute values, using the format required by edit_graph"""
value_descriptions = values_to_set if isinstance(values_to_set, list) else [values_to_set]
# value_list data can either include a node or not. If the node is not included then
# the list members must be og.Attributes, not just names.
try:
for value_list in value_descriptions:
if not isinstance(value_list, tuple) and not isinstance(value_list, list):
raise ValueError
if len(value_list) == 3:
node_name, attr_name, value = value_list
_ = DBG_EVAL and dbg_eval(f"Setting value '{value} on {node_name}.{attr_name}")
try:
node = node_path_map[node_name]
except KeyError:
node = node_name
self.set_values(node, [(attr_name, value)])
else:
attr_name, value = value_list
if not isinstance(attr_name, og.Attribute):
raise OmniGraphError(f"Must set values with og.Attribute, got '{attr_name}'")
_ = DBG_EVAL and dbg_eval(f"Setting value '{value} on {attr_name}")
self.set_attribute_values([(attr_name, value)])
_ = DBG_EVAL and dbg_eval("...setting value succeeded")
except ValueError as ex:
raise OmniGraphError(f"Setting value requires ({{node_name, }}attr_name, value) - got {value_list}") from ex
# ----------------------------------------------------------------------
def edit(self, graph_description: Dict[str, Any]) -> List[og.Node]:
"""Modify an OmniGraph relative to the top level of the scene ("/")
Convenience function for accessing edit_graph without a root prim when it's not relevant
"""
return self.edit_graph("/", graph_description)
# ----------------------------------------------------------------------
def edit_graph(self, root_prim: str, graph_description: Dict[str, Any]) -> List[og.Node]:
"""Create an OmniGraph node graph from a dictionary description of the contents.
Here's a simple call that first deletes an existing node "oldnode", then creates two nodes of type
"omni.graph.tutorials.SimpleData", connects their "a_int" attributes, disconnects their "a_float" attributes
and sets the input "a_int" of the source node to the value 5. It also creates two unused USD Prim nodes, one
with a float attribute named "attrFloat" with value 2.0, and the other with a boolean attribute named "attrBool"
with the value true.
.. code-block:: python
helper = OmniGraphHelper()
(src_node, dst_node) = helper.edit_graph("/", {
"deletions" [
"oldnode"
],
"nodes": [
("omni.graph.tutorials.SimpleData", "src"),
("omni.graph.tutorials.SimpleData", "dst")
],
"prims": [
("Prim1", {"attrFloat": ("float", 2.0)),
("Prim2", {"attrBool": ("bool", true)),
],
"connections": [
("src", "outputs:a_int", "dst", "inputs:a_int")
],
"disconnections": [
("src", "outputs:a_float", "dst", "inputs:a_float")
],
"values": [
("src", "inputs:a_int", 5)
]
}
)
Args:
root_prim: Top level prim for the graph nodes (e.g. "/")
graph_description: Dictionary of graph construction definitions. A strict set of keys is accepted. Each
of the values in the dictionary can be either a single value or a list of values of the proscribed type.
- "deletions": [NODE_NAME]
Deletes a node at the given path
- "nodes": [(NODE_TYPE, NODE_NAME)]
Constructs a node of type "NODE_TYPE" and name "NODE_NAME".
- "prims": [(PRIM_PATH, {ATTR_NAME: (ATTR_TYPE, ATTR_VALUE)})]
Constructs a prim with path "PRIM_PATH containing a set of attributes with specified types and values.
- "connections": [(SRC_NODE_NAME, SRC_ATTR_NAME, DST_NODE_NAME, DST_ATTR_NAME)]
Makes a connection between the given source and destination attributes
- "disconnections": [(SRC_NODE_NAME, SRC_ATTR_NAME, DST_NODE_NAME, DST_ATTR_NAME)]
Breaks a connection between the given source and destination attributes
- "values": [(NODE_NAME, ATTR_NAME, VALUE)]
Sets the value of the given list of attributes.
Note that when constructing nodes the "NODE_NAME" may be in use, so a map is constructed when
the nodes are created between the requested node name and the actual node created, which will
contain the prim path reference.
Operations happen in that order (all deletions, all nodes, all connections, all values) to minimize
the possibility of errors. As a shortform any of the keys can accept a single tuple as well as a
list of tuples.
Returns:
The list of og.Nodes created for all constructed nodes
Raises:
OmniGraphError if any of the graph creation instructions could not be fulfilled
The graph will be left in the partially constructed state it reached at the time of the error
"""
# The graph could be in an illegal state when halfway through editing operations. This will disable it
# until all operations are completed. It's up to the caller to ensure that the state is legal after all
# operations are completed.
graph_was_disabled = self.graph.is_disabled()
self.graph.set_disabled(True)
try:
# Syntax check first
for instruction, data in graph_description.items():
if instruction not in ["nodes", "connections", "disconnections", "values", "deletions", "prims"]:
raise OmniGraphError(f"Unknown graph construction operation - {instruction}: {data}")
# Delete first because we may be creating nodes with the same names
with suppress(KeyError):
self._edit_delete_nodes(root_prim, graph_description["deletions"])
# Create nodes next since connect and set may need them
node_path_map = {}
nodes_constructed = []
with suppress(KeyError):
(node_path_map, nodes_constructed) = self._edit_create_nodes(root_prim, graph_description["nodes"])
# Prims next as they may be used in connections
with suppress(KeyError):
self._edit_create_prims(root_prim, node_path_map, nodes_constructed, graph_description["prims"])
# Connections next as setting values may override their data
with suppress(KeyError):
self._edit_connect(node_path_map, graph_description["connections"])
# Disconnections may have been created by the connections list so they're next, though that's unlikely
with suppress(KeyError):
self._edit_disconnect(node_path_map, graph_description["disconnections"])
# Now set the values
with suppress(KeyError):
self._edit_set_values(node_path_map, graph_description["values"])
finally:
# Really important that this always gets reset
self.graph.set_disabled(graph_was_disabled)
return nodes_constructed
| 52,187 | Python | 47.956848 | 120 | 0.569414 |
omniverse-code/kit/exts/omni.graph/omni/graph/core/_impl/v1_5_0/context_helper.py | r"""Deprecated accessor of attribute values within a graph context. Use og.DataView or og.Controller instead.
_____ ______ _____ _____ ______ _____ _______ ______ _____
| __ \ | ____|| __ \ | __ \ | ____|/ ____| /\ |__ __|| ____|| __ \
| | | || |__ | |__) || |__) || |__ | | / \ | | | |__ | | | |
| | | || __| | ___/ | _ / | __| | | / /\ \ | | | __| | | | |
| |__| || |____ | | | | \ \ | |____| |____ / ____ \ | | | |____ | |__| |
|_____/ |______||_| |_| \_\|______|\_____|/_/ \_\|_| |______||_____/
"""
from contextlib import suppress
from typing import Any, Optional, Union
import omni.graph.core as og
import omni.graph.tools as ogt
from ..attribute_values import AttributeDataValueHelper, AttributeValueHelper, WrappedArrayType
from ..lookup_tables import (
IDX_ARRAY_GET,
IDX_ARRAY_GET_TENSOR,
IDX_ARRAY_SET,
IDX_GET,
IDX_GET_TENSOR,
IDX_SET,
UNSUPPORTED_METHODS,
type_access_methods,
)
from ..utils import DBG_EVAL, dbg_eval, list_dimensions
# ==============================================================================================================
# Try to import torch for tensor APIs. If not available the non-tensor APIs will still work.
try:
import torch_wrap
except ImportError:
torch_wrap = None
# ================================================================================
@ogt.DeprecatedClass("og.ContextHelper is deprecated after version 1.5.0. Use og.Controller instead.")
class ContextHelper:
"""Helper class for managing compute graph contexts
Attributes:
_py_context: Context on which to apply the operations
"""
def __init__(self, py_context=None):
"""Remember the context for future operations.
Args:
py_context: Context for the operations - if None then get the current one
"""
if py_context is None:
for context in og.get_compute_graph_contexts():
self._py_context = context
else:
self._py_context = py_context
# ----------------------------------------------------------------------
@property
def context(self):
"""Returns the context being used for evaluation"""
return self._py_context
# ----------------------------------------------------------------------
def get_attribute_configuration(self, attr: Union[og.Attribute, og.AttributeData]):
"""Get the array configuration information from the attribute.
Attributes can be simple, tuples, or arrays of either. The information on what this is will be
encoded in the attribute type name. This method decodes that type name to find out what type of
attribute data the attribute will use.
The method also gives the right answers for both Attribute and AttributeData with some suitable AttributeError
catches to special case on unimplemented methods.
Args:
attr: Attribute whose configuration is being determined
Returns:
Tuple of:
str: Name of the full/resolved data type used by the attribute (e.g. "float[3][]")
str: Name of the simple data type used by the attribute (e.g. "float")
bool: True if the data type is a tuple or array (e.g. "float3" or "float[]")
bool: True if the data type is a matrix and should be flattened (e.g. "matrixd[3]" or "framed[4][]")
List: List of lookup methods for this type
Raises:
TypeError: If the attribute type is not yet supported
"""
# The actual data in extended types is the resolved type name; the attribute type is always token
ogn_type = attr.get_resolved_type() if isinstance(attr, og.Attribute) else attr.get_type()
type_name = ogn_type.get_ogn_type_name()
# The root name is important for lookup
root_type_name = ogn_type.get_base_type_name()
if ogn_type.base_type == og.BaseDataType.UNKNOWN and (
attr.get_extended_type()
in (og.ExtendedAttributeType.EXTENDED_ATTR_TYPE_ANY, og.ExtendedAttributeType.EXTENDED_ATTR_TYPE_UNION)
):
raise TypeError(f"Attribute '{attr.get_name()}' is not resolved, and so has no concrete type")
is_array_type = ogn_type.array_depth > 0 and ogn_type.role not in [og.AttributeRole.TEXT, og.AttributeRole.PATH]
is_matrix_type = (
type_name.startswith("matrix") or type_name.startswith("frame") or type_name.startswith("transform")
)
lookup_methods = UNSUPPORTED_METHODS
# Gather nodes automatically add one level of array to their attributes
is_gather_node = False
with suppress(AttributeError):
is_gather_node = attr.get_node().get_type_name() == "Gather"
if is_gather_node:
if is_array_type:
raise TypeError("Array types on Gather nodes are not yet supported in Python")
is_array_type = True
# Arrays of arrays are not yet supported in flatcache so they cannot be supported in Python
if ogn_type.array_depth > 1:
raise TypeError("Nested array types are not yet supported in Python")
try:
lookup_methods = type_access_methods(ogn_type)[0]
except (KeyError, TypeError) as error:
raise TypeError(f"Root type {ogn_type.get_ogn_type_name()} is not yet supported in Python") from error
return (type_name, root_type_name, is_array_type, is_matrix_type, lookup_methods)
# ----------------------------------------------------------------------
def get(
self, attr_object: Union[og.Attribute, og.AttributeData], on_gpu: bool = False, update_immediately: bool = False
):
"""
Get the value of an attribute or attribute data. Can be used for either type.
This method is intended for simple value retrievals. For array values use get_array().
Args:
attr_object: attribute data whose value is to be retrieved
on_gpu: Is the value stored on the GPU?
update_immediately: Should the stage update before getting the value or wait for the next regular update?
Returns:
Value of the attribute or attribute data
Raises:
TypeError: If an unsupported object type was passed in
"""
if isinstance(attr_object, og.AttributeData):
helper = AttributeDataValueHelper(attr_object)
return helper.get(on_gpu)
if isinstance(attr_object, og.Attribute):
helper = AttributeValueHelper(attr_object)
return helper.get(on_gpu)
raise TypeError(f"Object type {type(attr_object)} cannot be set with this method")
# ----------------------------------------------------------------------
def get_array(
self,
attr_object: Union[og.Attribute, og.AttributeData],
on_gpu: bool = False,
update_immediately: bool = False,
get_for_write: bool = False,
reserved_element_count: int = 0,
return_type: Optional[WrappedArrayType] = None,
) -> Any:
"""
Get the value of an attribute or attribute data. Can be used for either type.
Args:
attr_object: attribute whose value is to be retrieved
on_gpu: Is the value stored on the GPU?
update_immediately: Should the stage update before getting the value or wait for the next regular update?
get_for_write: If True then get the data in writable form (which may do other things under the covers)
reserved_element_count: For writable array types set the element count to this before retrieving the data.
This guarantees a buffer of this many elements is available in the returned data.
Returns:
Array value of the attribute or attribute data
Raises:
TypeError: If an unsupported object type was passed in
"""
# Ask the attribute update its value. If we are using a push graph, this
# won't do anything, but in a dirty and pull graph, this generates the "pull" that causes the graph
# to evaluate the dirtied attribute.
with suppress(AttributeError):
attr_object.update_object_value(update_immediately)
helper = AttributeValueHelper(attr_object)
if get_for_write is not None:
if reserved_element_count is None:
raise ValueError("Tried to get an array for write without setting the element count")
return helper.get_array(get_for_write, reserved_element_count, on_gpu, return_type)
return helper.get(on_gpu)
# ----------------------------------------------------------------------
def get_attr_value(
self,
attr: og.Attribute,
isGPU: bool = False, # noqa: N803
isTensor: bool = False, # noqa: N803
getDefault: bool = False, # noqa: N803
updateImmediately=False, # noqa: N803
getForWrite=False, # noqa: N803
writeElemCount=0, # noqa: N803
):
"""
Get the value of a node attribute in the context managed by this class.
Args:
attr: attribute whose value is to be retrieved
isGPU: Is the attribute stored on the GPU?
isTensor: Is the attribute value a tensor type? For some types of data this doesn't mean anything
but is silently accepted anyway.
isDefault: Whether or not we want to retrieve the default value
updateImmediately: Should the stage update immediately or wait for the next regular update?
getForWrite: Is the value going to be written to after calling?
writeElemCount: If the value to get is a writable array then set it at this size
Returns:
Value of the attribute
Raises:
AttributeError: If you try to access array data with "isTensor=True" and torch was not imported
TypeError: Raised if the data type of the attribute is not yet supported
"""
(type_name, root_type_name, is_array_type, _, lookup_methods) = self.get_attribute_configuration(attr)
# Verify that getting arrays for write has a valid element count. 0 is okay, None indicates uninitialized
if is_array_type and getForWrite and (writeElemCount is None):
raise ValueError(f"Attribute {attr.get_name()} requires a size to be set before getting values")
# Ask the attribute update its value. If we are using a push graph, this
# won't do anything, but in a dirty and pull graph, this generates the "pull" that causes the graph
# to evaluate the dirtied attribute.
with suppress(AttributeError):
attr.update_attribute_value(updateImmediately)
can_be_tensor = (isTensor or isGPU) and is_array_type and torch_wrap is not None
_ = DBG_EVAL and dbg_eval(
f"Getting value of type {type_name} on {attr.get_name()}. GPU = {isGPU}, Tensor = {isTensor}"
)
try:
_ = DBG_EVAL and dbg_eval(" --> Has Get/Set methods")
if is_array_type:
if lookup_methods[IDX_ARRAY_GET] is not None:
if can_be_tensor and (lookup_methods[IDX_ARRAY_GET_TENSOR] is not None):
_ = DBG_EVAL and dbg_eval(
f" --> Returning array tensor data with {lookup_methods[IDX_ARRAY_GET_TENSOR]}"
)
tensor = lookup_methods[IDX_ARRAY_GET_TENSOR](
self._py_context, attr, isGPU, getForWrite, writeElemCount
)
return torch_wrap.wrap_tensor(tensor) if tensor is not None else None
_ = DBG_EVAL and dbg_eval(f" --> Returning array data with {lookup_methods[IDX_ARRAY_GET]}")
return lookup_methods[IDX_ARRAY_GET](
self._py_context, attr, getDefault, getForWrite, writeElemCount
)
raise TypeError(f"Getting array data of type {root_type_name} is not yet supported")
if can_be_tensor and lookup_methods[IDX_GET_TENSOR] is not None:
_ = DBG_EVAL and dbg_eval(f" --> Returning tensor data with {lookup_methods[IDX_GET_TENSOR]}")
tensor = lookup_methods[IDX_GET_TENSOR](self._py_context, attr, isGPU, getForWrite, writeElemCount)
return torch_wrap.wrap_tensor(tensor) if tensor is not None else None
_ = DBG_EVAL and dbg_eval(f" --> Returning normal data with {lookup_methods[IDX_GET]}")
return lookup_methods[IDX_GET](self._py_context, attr, getDefault, getForWrite, writeElemCount)
except TypeError as error:
raise TypeError(f"Trying to get unsupported attribute type {type_name}") from error
except KeyError as error:
raise TypeError(f"Trying to get unknown attribute type {type_name}") from error
# ----------------------------------------------------------------------
def set_attr_value(self, new_value, attr: og.Attribute):
"""
Set the value of a attribute in the context managed by this class
new_value: New value to be set on the attribute
attr: Attribute whose value is to be set
Raises:
TypeError: Raised if the data type of the attribute is not yet supported
or if the parameters were passed in the wrong order.
"""
if isinstance(new_value, og.Attribute):
raise TypeError("set_attr_value is called with value first, attribute second")
(type_name, root_type_name, is_array_type, is_matrix_type, lookup_methods) = self.get_attribute_configuration(
attr
)
# Flatten the matrix data out, if it wasn't already flattened
# 2x2 matrix can come in as [[a, b], [c, d]] or [a, b, c, d] but will always go to the ABI as the latter
if is_matrix_type:
value_dimensions = list_dimensions(new_value)
if is_array_type:
if value_dimensions == 3:
value_to_set = [[item for sublist in matrix for item in sublist] for matrix in new_value]
else:
value_to_set = new_value
else:
if value_dimensions == 2:
value_to_set = [item for sublist in new_value for item in sublist]
else:
value_to_set = new_value
else:
value_to_set = new_value
try:
_ = DBG_EVAL and dbg_eval(f"Set attribute {attr.get_name()} of type {type_name} to {new_value}")
_ = DBG_EVAL and dbg_eval(f" as {root_type_name}, array={is_array_type}, matrix={is_matrix_type}")
if is_array_type:
if lookup_methods[IDX_ARRAY_GET] and lookup_methods[IDX_ARRAY_SET]:
_ = DBG_EVAL and dbg_eval(f" --> Setting array node data using {lookup_methods[IDX_ARRAY_SET]}")
# When setting an entire array all at once you need to first ensure the memory is allocated
# by calling the get method.
lookup_methods[IDX_ARRAY_GET](self._py_context, attr, False, True, len(value_to_set))
lookup_methods[IDX_ARRAY_SET](self._py_context, value_to_set, attr)
else:
raise TypeError(f"Setting array data of type {type_name} is not yet supported")
else:
_ = DBG_EVAL and dbg_eval(f" --> Setting simple data with {lookup_methods[IDX_SET]}")
lookup_methods[IDX_SET](self._py_context, value_to_set, attr)
except KeyError as error:
raise TypeError(f"Trying to set unsupported attribute type {type_name}") from error
# ----------------------------------------------------------------------
def get_elem_count(self, attr):
"""
Get the number of elements on the attribute in the context managed by this class
attr: Attribute whose element values are to be counted
Returns:
Number of elements currently on the attribute
"""
return self._py_context.get_elem_count(attr)
| 16,501 | Python | 47.678466 | 120 | 0.576389 |
omniverse-code/kit/exts/omni.graph/omni/graph/core/_impl/v1_5_0/utils.py | r"""Deprecated utilities
_____ ______ _____ _____ ______ _____ _______ ______ _____
| __ \ | ____|| __ \ | __ \ | ____|/ ____| /\ |__ __|| ____|| __ \
| | | || |__ | |__) || |__) || |__ | | / \ | | | |__ | | | |
| | | || __| | ___/ | _ / | __| | | / /\ \ | | | __| | | | |
| |__| || |____ | | | | \ \ | |____| |____ / ____ \ | | | |____ | |__| |
|_____/ |______||_| |_| \_\|______|\_____|/_/ \_\|_| |______||_____/
"""
from typing import Any, List, Tuple, Union
import carb
import omni.graph.core as og
from pxr import Sdf, Usd
ALLOW_IMPLICIT_GRAPH_SETTING = "/persistent/omnigraph/allowGlobalImplicitGraph"
"""Constant for the setting to selectively disable the global implicit graph"""
USE_SCHEMA_PRIMS_SETTING = "/persistent/omnigraph/useSchemaPrims"
"""Constant for the setting to force OmniGraph prims to follow the schema"""
ENABLE_LEGACY_PRIM_CONNECTIONS = "/persistent/omnigraph/enableLegacyPrimConnections"
"""Constant for the setting to enable connections between legacy Prims and OG Nodes"""
DISABLE_PRIM_NODES_SETTING = "/persistent/omnigraph/disablePrimNodes"
"""Constant for the setting to enable legacy Prim nodes to exist in the scene"""
# Object type hints are now available in typing.py
NODE_TYPE_HINTS = Union[str, og.Node, Usd.Prim, None] # type: ignore
NODE_TYPE_OR_LIST = Union[NODE_TYPE_HINTS, List[NODE_TYPE_HINTS]]
ATTRIBUTE_TYPE_HINTS = Union[str, og.Attribute, Usd.Attribute] # type: ignore
ATTRIBUTE_TYPE_OR_LIST = Union[ATTRIBUTE_TYPE_HINTS, List[ATTRIBUTE_TYPE_HINTS]]
ATTRIBUTE_TYPE_TYPE_HINTS = Union[str, og.Type]
ATTRIBUTE_VALUE_PAIR = Tuple[ATTRIBUTE_TYPE_HINTS, Any]
ATTRIBUTE_VALUE_PAIRS = Union[ATTRIBUTE_VALUE_PAIR, List[ATTRIBUTE_VALUE_PAIR]]
EXTENDED_ATTRIBUTE_TYPE_HINTS = Union[og.AttributePortType, Tuple[og.AttributePortType, Union[str, List[str]]]]
GRAPH_TYPE_HINTS = Union[str, Sdf.Path, og.Graph, None] # type: ignore
GRAPH_TYPE_OR_LIST = Union[GRAPH_TYPE_HINTS, List[GRAPH_TYPE_HINTS]]
# ================================================================================
def get_omnigraph():
"""Returns the current OmniGraph.
Deprecated as there is no longer the notion of a 'current' graph
"""
carb.log_warn("get_omnigraph() is deprecated and will be removed - use og.ObjectLookup.graph() instead")
for context in og.get_compute_graph_contexts():
return context.get_graph()
raise ValueError("OmniGraph is not currently available")
# ====================================================================================================
def l10n(msg):
"""Wrapper for l10n for when it gets implemented.
Deprecated - implementation is not on the plan and usage is spotty.
"""
return msg
| 2,789 | Python | 43.285714 | 111 | 0.570814 |
omniverse-code/kit/exts/omni.graph/omni/graph/core/_impl/v1_5_0/replaced_functions.py | r"""Deprecation support for functions that have been replaced by equivalents
_____ ______ _____ _____ ______ _____ _______ ______ _____
| __ \ | ____|| __ \ | __ \ | ____|/ ____| /\ |__ __|| ____|| __ \
| | | || |__ | |__) || |__) || |__ | | / \ | | | |__ | | | |
| | | || __| | ___/ | _ / | __| | | / /\ \ | | | __| | | | |
| |__| || |____ | | | | \ \ | |____| |____ / ____ \ | | | |____ | |__| |
|_____/ |______||_| |_| \_\|______|\_____|/_/ \_\|_| |______||_____/
"""
import re
import omni.graph.core as og
import omni.graph.tools as ogt
from ..lookup_tables import OGN_NAMES_TO_TYPES, USD_NAMES_TO_TYPES
# Pattern match for OGN style type names
# MATCH: BaseType, [TupleCount]|None, []|None - e.g. int[3][] = "int",[3],[]
RE_OGN_ATTRIBUTE_TYPE_PATTERN = re.compile(r"(^[^\[]+)(\[[0-9]+\]){0,1}(\[\]){0,1}")
# Pattern matches for USD style type names. The rules for USD names are a little more complex so they require
# multiple patterns to fully grok. (e.g. an int[4] is "int4" but a colord[4] is "color4d")
# MATCH: BaseType64, TupleCount|None, []|None - e.g. int64 = "int64",None,None
RE_USD_ATTRIBUTE_64_TYPE_PATTERN = re.compile(r"^([a-zA-Z]+64)([0-9]+){0,1}(\[\]){0,1}")
# MATCH: BaseType, TupleCount|None, h|d|f|None, []|None - e.g. quat3d[] = "quat",3,d,[]
RE_USD_ATTRIBUTE_TYPE_PATTERN = re.compile(r"^([a-zA-Z]+)([0-9]+){0,1}([hdf]){0,1}(\[\]){0,1}")
# Mapping of the .ogn base data types to the corresponding og.BaseDataType values
BASE_DATA_TYPE_MAP = {
"bool": og.BaseDataType.BOOL,
"bundle": og.BaseDataType.RELATIONSHIP,
"double": og.BaseDataType.DOUBLE,
"execution": og.BaseDataType.UINT,
"float": og.BaseDataType.FLOAT,
"half": og.BaseDataType.HALF,
"int": og.BaseDataType.INT,
"int64": og.BaseDataType.INT64,
"objectId": og.BaseDataType.UINT64,
"path": og.BaseDataType.UCHAR,
"string": og.BaseDataType.UCHAR,
"token": og.BaseDataType.TOKEN,
"uchar": og.BaseDataType.UCHAR,
"uint": og.BaseDataType.UINT,
"uint64": og.BaseDataType.UINT64,
}
# Mapping of the .ogn role names to the corresponding og.AttributeRole values
ROLE_MAP = {
"color": og.AttributeRole.COLOR,
"execution": og.AttributeRole.EXECUTION,
"frame": og.AttributeRole.FRAME,
"matrix": og.AttributeRole.MATRIX,
"none": og.AttributeRole.NONE,
"normal": og.AttributeRole.NORMAL,
"objectId": og.AttributeRole.OBJECT_ID,
"path": og.AttributeRole.PATH,
"point": og.AttributeRole.POSITION,
"quat": og.AttributeRole.QUATERNION,
"string": og.AttributeRole.TEXT,
"texcoord": og.AttributeRole.TEXCOORD,
"timecode": og.AttributeRole.TIMECODE,
"transform": og.AttributeRole.TRANSFORM,
"vector": og.AttributeRole.VECTOR,
}
# ==============================================================================================================
@ogt.deprecated_function("Use og.AttributeType.type_from_ogn_type_name instead")
def attribute_type_from_ogn_type_name(ogn_type_name: str) -> og.Type:
"""Construct an attribute type object from an OGN style type name"""
type_match = RE_OGN_ATTRIBUTE_TYPE_PATTERN.match(ogn_type_name)
if not type_match:
raise AttributeError(f"Attribute type '{ogn_type_name}' does not match known OGN type names")
try:
(base_type, role) = OGN_NAMES_TO_TYPES[type_match.group(1)]
except KeyError as error:
raise AttributeError(f"Base type '{type_match.group(1)}' is not a supported OGN type") from error
tuple_count = 1 if type_match.group(2) is None else int(type_match.group(2)[1])
array_depth = 0 if type_match.group(3) is None and role in [og.AttributeRole.TEXT, og.AttributeRole.PATH] else 1
is_matrix_type = role in [og.AttributeRole.MATRIX, og.AttributeRole.TRANSFORM, og.AttributeRole.FRAME]
if is_matrix_type:
tuple_count *= tuple_count
return og.Type(base_type, tuple_count, array_depth, role)
# ==============================================================================================================
@ogt.deprecated_function("Use og.AttributeType.type_from_sdf_type_name instead")
def attribute_type_from_usd_type_name(usd_type_name: str) -> og.Type:
"""Construct an attribute type object from a USD style type name"""
# The 64 type pattern (int64, uint64) has to be applied first so that the base type includes it
type_match = RE_USD_ATTRIBUTE_64_TYPE_PATTERN.match(usd_type_name)
if type_match:
(full_type, tuple_count, array_pattern) = type_match.groups()
flavour = None
else:
type_match = RE_USD_ATTRIBUTE_TYPE_PATTERN.match(usd_type_name)
if not type_match:
raise AttributeError(f"Attribute type '{usd_type_name}' does not match known USD type names")
(full_type, tuple_count, flavour, array_pattern) = type_match.groups()
# Reassemble the role names (quat3d extracts as "quat",3,"d",None - need "quatd" to grok the types)
full_type = f"{full_type}{flavour}" if flavour is not None else full_type
tuple_count = 1 if tuple_count is None else int(tuple_count)
array_depth = 0 if array_pattern is None else 1
try:
(base_type, role, override_tuple_count) = USD_NAMES_TO_TYPES[full_type]
if override_tuple_count is not None:
tuple_count = override_tuple_count
except KeyError as error:
raise AttributeError(f"Base type '{full_type}' is not a supported USD type") from error
is_matrix_type = usd_type_name.startswith("matrix")
if is_matrix_type:
tuple_count *= tuple_count
return og.Type(base_type, tuple_count, array_depth, role)
| 5,695 | Python | 46.865546 | 116 | 0.597366 |
omniverse-code/kit/exts/omni.graph/omni/graph/core/tests/test_bundle_changes.py | import omni.graph.core as og
import omni.graph.core.tests as ogt
class BundleTestSetup(ogt.OmniGraphTestCase):
async def setUp(self):
"""Set up test environment, to be torn down when done"""
await super().setUp()
self.graph = og.Controller.create_graph("/graph")
self.context = self.graph.get_default_graph_context()
self.factory = og.IBundleFactory.create()
self.assertTrue(self.factory is not None)
self.bundle_changes = og.IBundleChanges.create(self.context)
self.assertTrue(self.bundle_changes is not None)
class TestBundleTopologyChanges(BundleTestSetup):
async def setUp(self):
"""Set up test environment, to be torn down when done"""
await super().setUp()
async def test_bundle_changes_interface(self):
bundle_changes = og.IBundleChanges.create(self.context)
self.assertTrue(bundle_changes is not None)
async def test_create_bundle(self):
bundle = self.factory.create_bundle(self.context, "bundle")
self.bundle_changes.activate_change_tracking(bundle)
with og.BundleChanges(self.bundle_changes, bundle) as changes:
self.assertEqual(changes.get_change(bundle), og.BundleChangeType.MODIFIED)
# cleaned after leaving the scope
self.assertEqual(self.bundle_changes.get_change(bundle), og.BundleChangeType.NONE)
async def test_create_attribute(self):
bundle = self.factory.create_bundle(self.context, "bundle")
self.bundle_changes.activate_change_tracking(bundle)
# setup tracking
self.bundle_changes.get_change(bundle)
self.bundle_changes.clear_changes()
# check if everything is clean
self.assertEqual(self.bundle_changes.get_change(bundle), og.BundleChangeType.NONE)
# modify
attrib = bundle.create_attribute("attrib", og.Type(og.BaseDataType.INT))
# check for changes
with og.BundleChanges(self.bundle_changes, bundle) as changes:
self.assertTrue(changes.has_changed())
self.assertEqual(changes.get_change(bundle), og.BundleChangeType.MODIFIED)
self.assertEqual(changes.get_change(attrib), og.BundleChangeType.MODIFIED)
# cleaned after leaving the scope
self.assertEqual(self.bundle_changes.get_change(bundle), og.BundleChangeType.NONE)
self.assertEqual(self.bundle_changes.get_change(attrib), og.BundleChangeType.NONE)
async def test_create_attribute_like(self):
bundle1 = self.factory.create_bundle(self.context, "bundle1")
bundle2 = self.factory.create_bundle(self.context, "bundle2")
self.bundle_changes.activate_change_tracking(bundle1)
self.bundle_changes.activate_change_tracking(bundle2)
attrib1 = bundle1.create_attribute("attrib", og.Type(og.BaseDataType.INT))
# setup tracking
self.bundle_changes.get_change(bundle1)
self.bundle_changes.get_change(bundle2)
self.bundle_changes.get_change(attrib1)
self.bundle_changes.clear_changes()
# check if everything is clean
self.assertEqual(self.bundle_changes.get_change(bundle1), og.BundleChangeType.NONE)
self.assertEqual(self.bundle_changes.get_change(bundle2), og.BundleChangeType.NONE)
self.assertEqual(self.bundle_changes.get_change(attrib1), og.BundleChangeType.NONE)
# command: create attrib based on attrib1
attrib2 = bundle2.create_attribute_like(attrib1)
# check for changes
with og.BundleChanges(self.bundle_changes, bundle2) as changes:
self.assertTrue(changes.has_changed())
self.assertEqual(changes.get_change(bundle1), og.BundleChangeType.NONE)
self.assertEqual(changes.get_change(attrib1), og.BundleChangeType.NONE)
self.assertEqual(changes.get_change(bundle2), og.BundleChangeType.MODIFIED)
self.assertEqual(changes.get_change(attrib2), og.BundleChangeType.MODIFIED)
# cleaned after leaving the scope
self.assertEqual(self.bundle_changes.get_change(bundle1), og.BundleChangeType.NONE)
self.assertEqual(self.bundle_changes.get_change(bundle2), og.BundleChangeType.NONE)
self.assertEqual(self.bundle_changes.get_change(attrib1), og.BundleChangeType.NONE)
self.assertEqual(self.bundle_changes.get_change(attrib2), og.BundleChangeType.NONE)
async def test_create_child_bundle(self):
bundle = self.factory.create_bundle(self.context, "bundle")
self.bundle_changes.activate_change_tracking(bundle)
# setup tracking
self.bundle_changes.get_change(bundle)
self.bundle_changes.clear_changes()
# check if everything is clean
self.assertEqual(self.bundle_changes.get_change(bundle), og.BundleChangeType.NONE)
# modify
bundle.create_child_bundle("child")
# check for changes and clear them
with og.BundleChanges(self.bundle_changes, bundle) as changes:
self.assertTrue(changes.has_changed())
self.assertEqual(changes.get_change(bundle), og.BundleChangeType.MODIFIED)
# cleaned after leaving the scope
self.assertEqual(self.bundle_changes.get_change(bundle), og.BundleChangeType.NONE)
async def test_remove_attribute(self):
bundle = self.factory.create_bundle(self.context, "bundle")
self.bundle_changes.activate_change_tracking(bundle)
bundle.create_attribute("attrib", og.Type(og.BaseDataType.INT))
# setup tracking
self.bundle_changes.get_change(bundle)
self.bundle_changes.clear_changes()
# check if everything is clean
self.assertEqual(self.bundle_changes.get_change(bundle), og.BundleChangeType.NONE)
# modify
bundle.remove_attribute("attrib")
# check for changes and clear them
with og.BundleChanges(self.bundle_changes, bundle) as changes:
self.assertTrue(changes.has_changed())
self.assertEqual(changes.get_change(bundle), og.BundleChangeType.MODIFIED)
# cleaned after leaving the scope
self.assertEqual(self.bundle_changes.get_change(bundle), og.BundleChangeType.NONE)
async def test_remove_child_bundles(self):
bundle = self.factory.create_bundle(self.context, "bundle")
self.bundle_changes.activate_change_tracking(bundle)
child = bundle.create_child_bundle("child")
# setup tracking
self.bundle_changes.get_change(bundle)
self.bundle_changes.clear_changes()
# check if everything is clean
self.assertEqual(self.bundle_changes.get_change(bundle), og.BundleChangeType.NONE)
# modify
bundle.remove_child_bundle(child)
# check for changes and clear them
with og.BundleChanges(self.bundle_changes, bundle) as changes:
self.assertTrue(changes.has_changed())
self.assertEqual(changes.get_change(bundle), og.BundleChangeType.MODIFIED)
# cleaned after leaving the scope
self.assertEqual(self.bundle_changes.get_change(bundle), og.BundleChangeType.NONE)
async def test_clear_contents(self):
bundle = self.factory.create_bundle(self.context, "bundle")
self.bundle_changes.activate_change_tracking(bundle)
# setup tracking
self.bundle_changes.get_change(bundle)
self.bundle_changes.clear_changes()
# check if everything is clean
self.assertEqual(self.bundle_changes.get_change(bundle), og.BundleChangeType.NONE)
# modify
bundle.clear_contents()
# check for changes and clear them
with og.BundleChanges(self.bundle_changes, bundle) as changes:
self.assertTrue(changes.has_changed())
self.assertEqual(changes.get_change(bundle), og.BundleChangeType.MODIFIED)
# cleaned after leaving the scope
self.assertEqual(self.bundle_changes.get_change(bundle), og.BundleChangeType.NONE)
async def test_copy_attribute(self):
bundle1 = self.factory.create_bundle(self.context, "bundle1")
bundle2 = self.factory.create_bundle(self.context, "bundle2")
self.bundle_changes.activate_change_tracking(bundle1)
self.bundle_changes.activate_change_tracking(bundle2)
attrib1 = bundle1.create_attribute("attrib1", og.Type(og.BaseDataType.INT))
# setup tracking
self.bundle_changes.get_change(bundle1)
self.bundle_changes.get_change(bundle2)
self.bundle_changes.get_change(attrib1)
self.bundle_changes.clear_changes()
# check if everything is clean
self.assertEqual(self.bundle_changes.get_change(bundle1), og.BundleChangeType.NONE)
self.assertEqual(self.bundle_changes.get_change(bundle2), og.BundleChangeType.NONE)
self.assertEqual(self.bundle_changes.get_change(attrib1), og.BundleChangeType.NONE)
# modify
# only bundle2 is affected, but source bundle1 and attrib1 not
bundle2.copy_attribute(attrib1)
# check for changes and clear them
with og.BundleChanges(self.bundle_changes, bundle2) as changes:
self.assertTrue(changes.has_changed())
self.assertEqual(changes.get_change(bundle1), og.BundleChangeType.NONE)
self.assertEqual(changes.get_change(bundle2), og.BundleChangeType.MODIFIED)
self.assertEqual(changes.get_change(attrib1), og.BundleChangeType.NONE)
# cleaned after leaving the scope
self.assertEqual(self.bundle_changes.get_change(bundle1), og.BundleChangeType.NONE)
self.assertEqual(self.bundle_changes.get_change(bundle2), og.BundleChangeType.NONE)
self.assertEqual(self.bundle_changes.get_change(attrib1), og.BundleChangeType.NONE)
async def test_copy_child_bundle(self):
"""Test if CoW reference is resolved."""
bundle1 = self.factory.create_bundle(self.context, "bundle1")
bundle2 = self.factory.create_bundle(self.context, "bundle2")
self.bundle_changes.activate_change_tracking(bundle1)
self.bundle_changes.activate_change_tracking(bundle2)
# setup tracking
self.bundle_changes.get_change(bundle1)
self.bundle_changes.get_change(bundle2)
self.bundle_changes.clear_changes()
# check if everything is clean
self.assertEqual(self.bundle_changes.get_change(bundle1), og.BundleChangeType.NONE)
self.assertEqual(self.bundle_changes.get_change(bundle2), og.BundleChangeType.NONE)
# modify
# only bundle1 is dirty, but bundle2 stays intact
bundle1.copy_child_bundle(bundle2)
self.assertEqual(self.bundle_changes.get_change(bundle2), og.BundleChangeType.NONE)
# check for changes and clear them
with og.BundleChanges(self.bundle_changes, bundle1) as changes:
self.assertTrue(changes.has_changed())
self.assertEqual(changes.get_change(bundle1), og.BundleChangeType.MODIFIED)
# cleaned after leaving the scope
self.assertEqual(self.bundle_changes.get_change(bundle1), og.BundleChangeType.NONE)
self.assertEqual(self.bundle_changes.get_change(bundle2), og.BundleChangeType.NONE)
async def test_copy_bundle(self):
"""Copying bundle creates a shallow copy - a reference.
To obtain the dirty id the reference needs to be resolved"""
bundle1 = self.factory.create_bundle(self.context, "bundle1")
bundle2 = self.factory.create_bundle(self.context, "bundle2")
self.bundle_changes.activate_change_tracking(bundle1)
self.bundle_changes.activate_change_tracking(bundle2)
# setup tracking
self.bundle_changes.get_change(bundle1)
self.bundle_changes.get_change(bundle2)
self.bundle_changes.clear_changes()
# check if everything is clean
self.assertEqual(self.bundle_changes.get_change(bundle1), og.BundleChangeType.NONE)
self.assertEqual(self.bundle_changes.get_change(bundle2), og.BundleChangeType.NONE)
# modify
# bundle2 is modified, but bundle1 stays intact
bundle2.copy_bundle(bundle1)
self.assertEqual(self.bundle_changes.get_change(bundle1), og.BundleChangeType.NONE)
# check for changes and clear them
with og.BundleChanges(self.bundle_changes, bundle2) as changes:
self.assertTrue(changes.has_changed())
self.assertEqual(changes.get_change(bundle2), og.BundleChangeType.MODIFIED)
# cleaned after leaving the scope
self.assertEqual(self.bundle_changes.get_change(bundle1), og.BundleChangeType.NONE)
self.assertEqual(self.bundle_changes.get_change(bundle2), og.BundleChangeType.NONE)
async def test_get_attribute_by_name(self):
"""Getting writable attribute data handle does not change dirty id.
Only writing to an attribute triggers id to be changed."""
bundle = self.factory.create_bundle(self.context, "bundle")
self.bundle_changes.activate_change_tracking(bundle)
attrib = bundle.create_attribute("attrib", og.Type(og.BaseDataType.INT))
# setup tracking
self.bundle_changes.get_change(bundle)
self.bundle_changes.get_change(attrib)
self.bundle_changes.clear_changes()
# check if everything is clean
self.assertEqual(self.bundle_changes.get_change(bundle), og.BundleChangeType.NONE)
self.assertEqual(self.bundle_changes.get_change(attrib), og.BundleChangeType.NONE)
# getting attribute doesn't mark any changes
attrib = bundle.get_attribute_by_name("attrib")
# check for changes and clear them
with og.BundleChanges(self.bundle_changes, bundle) as changes:
self.assertFalse(changes.has_changed())
self.assertEqual(changes.get_change(bundle), og.BundleChangeType.NONE)
self.assertEqual(changes.get_change(attrib), og.BundleChangeType.NONE)
# cleaned after leaving the scope
self.assertEqual(self.bundle_changes.get_change(bundle), og.BundleChangeType.NONE)
self.assertEqual(self.bundle_changes.get_change(attrib), og.BundleChangeType.NONE)
async def test_get_child_bundle_by_name(self):
"""Getting writable bundle handle does not change dirty id.
Only creating/removing attributes and children triggers id to be
changed."""
bundle = self.factory.create_bundle(self.context, "bundle")
self.bundle_changes.activate_change_tracking(bundle)
child = bundle.create_child_bundle("child")
# setup tracking
self.bundle_changes.get_change(bundle)
self.bundle_changes.get_change(child)
self.bundle_changes.clear_changes()
# check if everything is clean
self.assertEqual(self.bundle_changes.get_change(bundle), og.BundleChangeType.NONE)
self.assertEqual(self.bundle_changes.get_change(child), og.BundleChangeType.NONE)
# bundle and child must be clean
child = bundle.get_child_bundle_by_name("child")
# check for changes and clear them
with og.BundleChanges(self.bundle_changes, bundle) as changes:
self.assertFalse(changes.has_changed())
self.assertEqual(changes.get_change(bundle), og.BundleChangeType.NONE)
self.assertEqual(changes.get_change(child), og.BundleChangeType.NONE)
# cleaned after leaving the scope
self.assertEqual(self.bundle_changes.get_change(bundle), og.BundleChangeType.NONE)
self.assertEqual(self.bundle_changes.get_change(child), og.BundleChangeType.NONE)
async def test_change_child_and_propagate_changes_to_parent(self):
r"""
bundle1
\_ child0
\_ child1
\_ child2 <-- create attribute
Will propagate dirty id changes up to `bundle1`
(child2 -> child1 -> child0 -> bundle1)
"""
bundle = self.factory.create_bundle(self.context, "bundle")
self.bundle_changes.activate_change_tracking(bundle)
child0 = bundle.create_child_bundle("child0")
child1 = child0.create_child_bundle("child1")
child2 = child1.create_child_bundle("child2")
# setup tracking
self.bundle_changes.get_change(bundle)
self.bundle_changes.get_change(child0)
self.bundle_changes.get_change(child1)
self.bundle_changes.get_change(child2)
self.bundle_changes.clear_changes()
# check if everything is clean
self.assertEqual(self.bundle_changes.get_change(child2), og.BundleChangeType.NONE)
self.assertEqual(self.bundle_changes.get_change(child1), og.BundleChangeType.NONE)
self.assertEqual(self.bundle_changes.get_change(child0), og.BundleChangeType.NONE)
self.assertEqual(self.bundle_changes.get_change(bundle), og.BundleChangeType.NONE)
# creating attribute automatically make all hierarchy dirty
child2.create_attribute("attrib", og.Type(og.BaseDataType.INT))
# check for changes and clear them
with og.BundleChanges(self.bundle_changes, bundle) as changes:
self.assertTrue(changes.has_changed())
self.assertEqual(changes.get_change(child2), og.BundleChangeType.MODIFIED)
self.assertEqual(changes.get_change(child1), og.BundleChangeType.MODIFIED)
self.assertEqual(changes.get_change(child0), og.BundleChangeType.MODIFIED)
self.assertEqual(changes.get_change(bundle), og.BundleChangeType.MODIFIED)
# cleaned after leaving the scope
self.assertEqual(self.bundle_changes.get_change(child2), og.BundleChangeType.NONE)
self.assertEqual(self.bundle_changes.get_change(child1), og.BundleChangeType.NONE)
self.assertEqual(self.bundle_changes.get_change(child0), og.BundleChangeType.NONE)
self.assertEqual(self.bundle_changes.get_change(bundle), og.BundleChangeType.NONE)
class TestBundleAttributeDataChanges(BundleTestSetup):
async def setUp(self):
"""Set up test environment, to be torn down when done"""
await super().setUp()
async def test_set_get_simple_attribute_data(self):
"""Getting simple attribute data should not change dirty id"""
bundle = self.factory.create_bundle(self.context, "bundle")
self.bundle_changes.activate_change_tracking(bundle)
attrib = bundle.create_attribute("attrib", og.Type(og.BaseDataType.INT))
# setup tracking
self.bundle_changes.get_change(bundle)
self.bundle_changes.get_change(attrib)
self.bundle_changes.clear_changes()
self.assertEqual(self.bundle_changes.get_change(bundle), og.BundleChangeType.NONE)
self.assertEqual(self.bundle_changes.get_change(attrib), og.BundleChangeType.NONE)
# command: set modifies attribute and bundle
attrib.set(42)
# check for changes and clear them
with og.BundleChanges(self.bundle_changes, bundle) as changes:
self.assertTrue(changes.has_changed())
self.assertEqual(changes.get_change(bundle), og.BundleChangeType.MODIFIED)
self.assertEqual(changes.get_change(attrib), og.BundleChangeType.MODIFIED)
# cleaned after leaving the scope
self.assertEqual(self.bundle_changes.get_change(bundle), og.BundleChangeType.NONE)
self.assertEqual(self.bundle_changes.get_change(attrib), og.BundleChangeType.NONE)
# query: get does not modify attribute and bundle
self.assertEqual(attrib.as_read_only().get(), 42)
# check for changes and clear them
with og.BundleChanges(self.bundle_changes, bundle) as changes:
self.assertFalse(changes.has_changed())
self.assertEqual(changes.get_change(bundle), og.BundleChangeType.NONE)
self.assertEqual(changes.get_change(attrib), og.BundleChangeType.NONE)
# cleaned after leaving the scope
self.assertEqual(self.bundle_changes.get_change(bundle), og.BundleChangeType.NONE)
self.assertEqual(self.bundle_changes.get_change(attrib), og.BundleChangeType.NONE)
async def test_set_get_array_attribute_data(self):
"""Getting simple attribute data should not change dirty id"""
bundle = self.factory.create_bundle(self.context, "bundle")
self.bundle_changes.activate_change_tracking(bundle)
attrib = bundle.create_attribute("attrib", og.Type(og.BaseDataType.INT, 1, 1))
# setup tracking
self.bundle_changes.get_change(bundle)
self.bundle_changes.get_change(attrib)
self.bundle_changes.clear_changes()
self.assertEqual(self.bundle_changes.get_change(bundle), og.BundleChangeType.NONE)
self.assertEqual(self.bundle_changes.get_change(attrib), og.BundleChangeType.NONE)
# command: set modifies attribute and bundle
attrib.set([42])
# check for changes and clear them
with og.BundleChanges(self.bundle_changes, bundle) as changes:
self.assertTrue(changes.has_changed())
self.assertEqual(changes.get_change(bundle), og.BundleChangeType.MODIFIED)
self.assertEqual(changes.get_change(attrib), og.BundleChangeType.MODIFIED)
# cleaned after leaving the scope
self.assertEqual(self.bundle_changes.get_change(bundle), og.BundleChangeType.NONE)
self.assertEqual(self.bundle_changes.get_change(attrib), og.BundleChangeType.NONE)
# query: get does not modify attribute and bundle
self.assertEqual(attrib.as_read_only().get()[0], 42)
# check for changes and clear them
with og.BundleChanges(self.bundle_changes, bundle) as changes:
self.assertFalse(changes.has_changed())
self.assertEqual(changes.get_change(bundle), og.BundleChangeType.NONE)
self.assertEqual(changes.get_change(attrib), og.BundleChangeType.NONE)
# cleaned after leaving the scope
self.assertEqual(self.bundle_changes.get_change(bundle), og.BundleChangeType.NONE)
self.assertEqual(self.bundle_changes.get_change(attrib), og.BundleChangeType.NONE)
async def test_set_get_tuple_attribute_data(self):
"""Getting simple attribute data should not change dirty id"""
bundle = self.factory.create_bundle(self.context, "bundle")
self.bundle_changes.activate_change_tracking(bundle)
attrib = bundle.create_attribute("attrib", og.Type(og.BaseDataType.INT, 2, 0))
# setup tracking
self.bundle_changes.get_change(bundle)
self.bundle_changes.get_change(attrib)
self.bundle_changes.clear_changes()
self.assertEqual(self.bundle_changes.get_change(bundle), og.BundleChangeType.NONE)
self.assertEqual(self.bundle_changes.get_change(attrib), og.BundleChangeType.NONE)
# command: set modifies attribute and bundle
attrib.set([42, 24])
# check for changes and clear them
with og.BundleChanges(self.bundle_changes, bundle) as changes:
self.assertTrue(changes.has_changed())
self.assertEqual(changes.get_change(bundle), og.BundleChangeType.MODIFIED)
self.assertEqual(changes.get_change(attrib), og.BundleChangeType.MODIFIED)
# cleaned after leaving the scope
self.assertEqual(self.bundle_changes.get_change(bundle), og.BundleChangeType.NONE)
self.assertEqual(self.bundle_changes.get_change(attrib), og.BundleChangeType.NONE)
# query: get does not modify attribute and bundle
self.assertEqual(attrib.as_read_only().get()[0], 42)
self.assertEqual(attrib.as_read_only().get()[1], 24)
# check for changes and clear them
with og.BundleChanges(self.bundle_changes, bundle) as changes:
self.assertFalse(changes.has_changed())
self.assertEqual(changes.get_change(bundle), og.BundleChangeType.NONE)
self.assertEqual(changes.get_change(attrib), og.BundleChangeType.NONE)
# cleaned after leaving the scope
self.assertEqual(self.bundle_changes.get_change(bundle), og.BundleChangeType.NONE)
self.assertEqual(self.bundle_changes.get_change(attrib), og.BundleChangeType.NONE)
| 24,227 | Python | 45.325048 | 91 | 0.692987 |
omniverse-code/kit/exts/omni.graph/omni/graph/core/tests/test_bundle_cow.py | import omni.graph.core as og
import omni.graph.core.tests as ogt
class TestBundleCow(ogt.OmniGraphTestCase):
async def setUp(self):
await super().setUp()
self.graph = og.Controller.create_graph("/graph")
self.context = self.graph.get_default_graph_context()
self.factory = og.IBundleFactory.create()
self.assertTrue(self.factory is not None)
self.bundle1Name = "bundle1"
self.bundle2Name = "bundle2"
self.attr1Name = "attr1"
self.attr1Type = og.Type(og.BaseDataType.BOOL, 1, 1)
self.bundle1 = self.factory.create_bundle(self.context, self.bundle1Name)
self.assertTrue(self.bundle1.valid)
self.bundle2 = self.factory.create_bundle(self.context, self.bundle2Name)
self.assertTrue(self.bundle2.valid)
async def test_copy_and_remove_attribute_with_metadata(self):
meta_name = "meta1"
meta_type = og.Type(og.BaseDataType.INT, 1, 1)
attr1 = self.bundle1.create_attribute(self.attr1Name, self.attr1Type)
attr1.set([False, True])
meta1 = self.bundle1.create_attribute_metadata(self.attr1Name, meta_name, meta_type)
meta1.set([1, 2, 3, 4])
# copy attribute with metadata
self.bundle2.copy_attribute(attr1)
# confirm data is accurate after setting it
cpy_meta1 = self.bundle2.get_attribute_metadata_by_name(self.attr1Name, meta_name)
cpy_meta1.set([4, 3, 2, 1])
self.assertTrue((meta1.get() == [1, 2, 3, 4]).all())
self.assertTrue((cpy_meta1.get() == [4, 3, 2, 1]).all())
# remove copied attribute should leave original attribute intact
self.bundle2.remove_attributes_by_name([self.attr1Name])
# confirm source data is intact
attr1 = self.bundle1.get_attribute_by_name(self.attr1Name)
self.assertTrue(attr1.is_valid())
self.assertTrue((attr1.get() == [False, True]).all())
self.assertEqual(self.bundle1.get_attribute_metadata_count(self.attr1Name), 1)
meta1 = self.bundle1.get_attribute_metadata_by_name(self.attr1Name, meta_name)
self.assertTrue(meta1.is_valid())
self.assertTrue((meta1.get() == [1, 2, 3, 4]).all())
# confirm removed metadata is gone
self.assertEqual(self.bundle2.get_attribute_metadata_count(self.attr1Name), 0)
attr1 = self.bundle2.get_attribute_metadata_by_name(self.attr1Name, meta_name)
self.assertFalse(attr1.is_valid())
async def test_copy_bundle_and_remove_attribute_with_metadata(self):
meta_name = "meta1"
meta_type = og.Type(og.BaseDataType.INT, 1, 1)
attr1 = self.bundle1.create_attribute(self.attr1Name, self.attr1Type)
attr1.set([False, True])
meta1 = self.bundle1.create_attribute_metadata(self.attr1Name, meta_name, meta_type)
meta1.set([1, 2, 3, 4])
# copy attribute with metadata
self.bundle2.copy_bundle(self.bundle1)
#
# Do NOT materialize attribute - keep shallow copy of entire bundle
#
# remove copied attribute should leave original attribute intact
self.bundle2.remove_attributes_by_name([self.attr1Name])
# confirm source data is intact
attr1 = self.bundle1.get_attribute_by_name(self.attr1Name)
self.assertTrue(attr1.is_valid())
self.assertTrue((attr1.get() == [False, True]).all())
self.assertEqual(self.bundle1.get_attribute_metadata_count(self.attr1Name), 1)
meta1 = self.bundle1.get_attribute_metadata_by_name(self.attr1Name, meta_name)
self.assertTrue(meta1.is_valid())
self.assertTrue((meta1.get() == [1, 2, 3, 4]).all())
# confirm copied metadata is gone
self.assertEqual(self.bundle2.get_attribute_metadata_count(self.attr1Name), 0)
attr1 = self.bundle2.get_attribute_metadata_by_name(self.attr1Name, meta_name)
self.assertFalse(attr1.is_valid())
async def test_remove_attribute_metadata(self):
attr1 = self.bundle1.create_attribute(self.attr1Name, self.attr1Type)
attr1.set([False, True])
meta_name1 = "meta1"
meta_type1 = og.Type(og.BaseDataType.INT, 1, 1)
meta1 = self.bundle1.create_attribute_metadata(self.attr1Name, meta_name1, meta_type1)
meta1.set([1, 2, 3, 4])
meta_name2 = "meta2"
meta_type2 = og.Type(og.BaseDataType.BOOL, 1, 1)
meta1 = self.bundle1.create_attribute_metadata(self.attr1Name, meta_name2, meta_type2)
meta1.set([False, True])
# copy attribute with metadata
self.bundle2.copy_bundle(self.bundle1)
#
# Materialize metadata for bundle2!
#
self.bundle2.remove_attribute_metadata(self.attr1Name, (meta_name1))
# check if source is intact
self.assertEqual(self.bundle1.get_attribute_metadata_count(self.attr1Name), 2)
names = self.bundle1.get_attribute_metadata_names(self.attr1Name)
self.assertEqual(len(names), 2)
self.assertTrue(meta_name1 in names)
self.assertTrue(meta_name2 in names)
# check if shallow copied metadata bundle has been materialized
self.assertEqual(self.bundle2.get_attribute_metadata_count(self.attr1Name), 1)
names = self.bundle2.get_attribute_metadata_names(self.attr1Name)
self.assertEqual(len(names), 1)
self.assertFalse(meta_name1 in names)
self.assertTrue(meta_name2 in names)
async def test_copy_child_bundle(self):
org_child = self.bundle1.create_child_bundle("org_child")
# create bundle for modifications
mod_bundle = self.factory.create_bundle(self.context, "mod_bundle")
mod_child = mod_bundle.copy_child_bundle(org_child)
mod_child.create_attribute("attr", og.Type(og.BaseDataType.BOOL, 1, 1))
# original child can not change, but modified change must
self.assertEqual(org_child.get_attribute_count(), 0)
self.assertEqual(mod_child.get_attribute_count(), 1)
async def test_attribute_resize(self):
src_bundle = self.factory.create_bundle(self.context, "src_bundle")
src_attrib = src_bundle.create_attribute(
"attrib",
og.Type(
og.BaseDataType.FLOAT,
tuple_count=1,
array_depth=1,
),
element_count=100,
)
dst_bundle = self.factory.create_bundle(self.context, "dst_bundle")
dst_bundle.copy_bundle(src_bundle)
self.assertEqual(dst_bundle.get_attribute_count(), 1)
dst_attrib = dst_bundle.create_attribute(
"attrib",
og.Type(
og.BaseDataType.FLOAT,
tuple_count=1,
array_depth=1,
),
element_count=200,
)
self.assertEqual(src_attrib.size(), 100)
self.assertEqual(dst_attrib.size(), 200)
| 6,926 | Python | 38.135593 | 94 | 0.641207 |
omniverse-code/kit/exts/omni.graph/omni/graph/core/tests/test_omnigraph_utils.py | """
Suite of tests to exercise small pieces of the OmniGraph utility scripts. These tests are like
unit tests in that they all only focus on one piece of functionality, not the integration of
many pieces, as these tests usually do.
"""
import json
from contextlib import suppress
from pathlib import Path
import carb
import carb.settings
import omni.graph.core as og
import omni.graph.core.tests as ogt
import omni.kit.app
import omni.kit.commands
import omni.kit.test
import omni.usd
class TestOmniGraphUtilities(ogt.OmniGraphTestCase):
"""Wrapper for unit tests on basic OmniGraph support script functionality"""
# ----------------------------------------------------------------------
async def test_ogn_type_conversion(self):
"""Test operation of the AttributeType.type_from_ogn_type_name() function"""
# Test data is tuples of string input and expected Type output
simple_data_no_tuples = [
("any", og.Type(og.BaseDataType.TOKEN)),
("bool", og.Type(og.BaseDataType.BOOL)),
("int64", og.Type(og.BaseDataType.INT64)),
("token", og.Type(og.BaseDataType.TOKEN)),
("uchar", og.Type(og.BaseDataType.UCHAR)),
("uint", og.Type(og.BaseDataType.UINT)),
("uint64", og.Type(og.BaseDataType.UINT64)),
]
simple_data = [
("double", og.Type(og.BaseDataType.DOUBLE)),
("float", og.Type(og.BaseDataType.FLOAT)),
("half", og.Type(og.BaseDataType.HALF)),
("int", og.Type(og.BaseDataType.INT)),
]
tuple_data = [(f"{type_name}[2]", og.Type(og_type.base_type, 2, 0)) for (type_name, og_type) in simple_data]
array_data = [
(f"{type_name}[]", og.Type(og_type.base_type, 1, 1))
for (type_name, og_type) in simple_data + simple_data_no_tuples
]
array_tuple_data = [
(f"{type_name}[3][]", og.Type(og_type.base_type, 3, 1)) for (type_name, og_type) in simple_data
]
role_data = [
("bundle", og.Type(og.BaseDataType.RELATIONSHIP, 1, 0, og.AttributeRole.BUNDLE)),
("colord[3]", og.Type(og.BaseDataType.DOUBLE, 3, 0, og.AttributeRole.COLOR)),
("colorf[3]", og.Type(og.BaseDataType.FLOAT, 3, 0, og.AttributeRole.COLOR)),
("colorh[3]", og.Type(og.BaseDataType.HALF, 3, 0, og.AttributeRole.COLOR)),
("frame[4]", og.Type(og.BaseDataType.DOUBLE, 16, 0, og.AttributeRole.FRAME)),
("matrixd[2]", og.Type(og.BaseDataType.DOUBLE, 4, 0, og.AttributeRole.MATRIX)),
("matrixd[3]", og.Type(og.BaseDataType.DOUBLE, 9, 0, og.AttributeRole.MATRIX)),
("matrixd[4]", og.Type(og.BaseDataType.DOUBLE, 16, 0, og.AttributeRole.MATRIX)),
("normald[3]", og.Type(og.BaseDataType.DOUBLE, 3, 0, og.AttributeRole.NORMAL)),
("normalf[3]", og.Type(og.BaseDataType.FLOAT, 3, 0, og.AttributeRole.NORMAL)),
("normalh[3]", og.Type(og.BaseDataType.HALF, 3, 0, og.AttributeRole.NORMAL)),
("path", og.Type(og.BaseDataType.UCHAR, 1, 1, og.AttributeRole.PATH)),
("pointd[3]", og.Type(og.BaseDataType.DOUBLE, 3, 0, og.AttributeRole.POSITION)),
("pointf[3]", og.Type(og.BaseDataType.FLOAT, 3, 0, og.AttributeRole.POSITION)),
("pointh[3]", og.Type(og.BaseDataType.HALF, 3, 0, og.AttributeRole.POSITION)),
("quatd[3]", og.Type(og.BaseDataType.DOUBLE, 3, 0, og.AttributeRole.QUATERNION)),
("quatf[3]", og.Type(og.BaseDataType.FLOAT, 3, 0, og.AttributeRole.QUATERNION)),
("quath[3]", og.Type(og.BaseDataType.HALF, 3, 0, og.AttributeRole.QUATERNION)),
("target", og.Type(og.BaseDataType.RELATIONSHIP, 1, 0, og.AttributeRole.TARGET)),
("texcoordd[3]", og.Type(og.BaseDataType.DOUBLE, 3, 0, og.AttributeRole.TEXCOORD)),
("texcoordf[3]", og.Type(og.BaseDataType.FLOAT, 3, 0, og.AttributeRole.TEXCOORD)),
("texcoordh[3]", og.Type(og.BaseDataType.HALF, 3, 0, og.AttributeRole.TEXCOORD)),
("timecode[3]", og.Type(og.BaseDataType.DOUBLE, 3, 0, og.AttributeRole.TIMECODE)),
("transform[3]", og.Type(og.BaseDataType.DOUBLE, 9, 0, og.AttributeRole.TRANSFORM)),
("vectord[3]", og.Type(og.BaseDataType.DOUBLE, 3, 0, og.AttributeRole.VECTOR)),
("vectorf[3]", og.Type(og.BaseDataType.FLOAT, 3, 0, og.AttributeRole.VECTOR)),
("vectorh[3]", og.Type(og.BaseDataType.HALF, 3, 0, og.AttributeRole.VECTOR)),
]
test_data = simple_data + simple_data_no_tuples + tuple_data + array_data + array_tuple_data + role_data
for (attribute_type_spec, attribute_type_expected) in test_data:
actual = og.AttributeType.type_from_ogn_type_name(attribute_type_spec)
self.assertEqual(attribute_type_expected, actual, f"Failed to convert {attribute_type_spec}")
# ----------------------------------------------------------------------
async def test_sdf_type_conversion(self):
"""Test operation of the AttributeType.type_from_sdf_type_name() function"""
# Test data is tuples of string input and expected Type output
simple_data_no_tuples = [
("bool", og.Type(og.BaseDataType.BOOL)),
("int64", og.Type(og.BaseDataType.INT64)),
("token", og.Type(og.BaseDataType.TOKEN)),
("uchar", og.Type(og.BaseDataType.UCHAR)),
("uint", og.Type(og.BaseDataType.UINT)),
("uint64", og.Type(og.BaseDataType.UINT64)),
]
simple_data = [
("double", og.Type(og.BaseDataType.DOUBLE)),
("float", og.Type(og.BaseDataType.FLOAT)),
("half", og.Type(og.BaseDataType.HALF)),
("int", og.Type(og.BaseDataType.INT)),
]
tuple_data = [(f"{type_name}2", og.Type(og_type.base_type, 2, 0)) for (type_name, og_type) in simple_data]
array_data = [
(f"{type_name}[]", og.Type(og_type.base_type, 1, 1))
for (type_name, og_type) in simple_data + simple_data_no_tuples
]
array_tuple_data = [
(f"{type_name}3[]", og.Type(og_type.base_type, 3, 1)) for (type_name, og_type) in simple_data
]
role_data = [
("color3d", og.Type(og.BaseDataType.DOUBLE, 3, 0, og.AttributeRole.COLOR)),
("color3f", og.Type(og.BaseDataType.FLOAT, 3, 0, og.AttributeRole.COLOR)),
("color3h", og.Type(og.BaseDataType.HALF, 3, 0, og.AttributeRole.COLOR)),
("frame4d", og.Type(og.BaseDataType.DOUBLE, 16, 0, og.AttributeRole.FRAME)),
("matrix2d", og.Type(og.BaseDataType.DOUBLE, 4, 0, og.AttributeRole.MATRIX)),
("matrix3d", og.Type(og.BaseDataType.DOUBLE, 9, 0, og.AttributeRole.MATRIX)),
("matrix4d", og.Type(og.BaseDataType.DOUBLE, 16, 0, og.AttributeRole.MATRIX)),
("normal3d", og.Type(og.BaseDataType.DOUBLE, 3, 0, og.AttributeRole.NORMAL)),
("normal3f", og.Type(og.BaseDataType.FLOAT, 3, 0, og.AttributeRole.NORMAL)),
("normal3h", og.Type(og.BaseDataType.HALF, 3, 0, og.AttributeRole.NORMAL)),
("point3d", og.Type(og.BaseDataType.DOUBLE, 3, 0, og.AttributeRole.POSITION)),
("point3f", og.Type(og.BaseDataType.FLOAT, 3, 0, og.AttributeRole.POSITION)),
("point3h", og.Type(og.BaseDataType.HALF, 3, 0, og.AttributeRole.POSITION)),
("quatd", og.Type(og.BaseDataType.DOUBLE, 4, 0, og.AttributeRole.QUATERNION)),
("quatf", og.Type(og.BaseDataType.FLOAT, 4, 0, og.AttributeRole.QUATERNION)),
("quath", og.Type(og.BaseDataType.HALF, 4, 0, og.AttributeRole.QUATERNION)),
("texCoord3d", og.Type(og.BaseDataType.DOUBLE, 3, 0, og.AttributeRole.TEXCOORD)),
("texCoord3f", og.Type(og.BaseDataType.FLOAT, 3, 0, og.AttributeRole.TEXCOORD)),
("texCoord3h", og.Type(og.BaseDataType.HALF, 3, 0, og.AttributeRole.TEXCOORD)),
("timecode", og.Type(og.BaseDataType.DOUBLE, 1, 0, og.AttributeRole.TIMECODE)),
("vector3d", og.Type(og.BaseDataType.DOUBLE, 3, 0, og.AttributeRole.VECTOR)),
("vector3f", og.Type(og.BaseDataType.FLOAT, 3, 0, og.AttributeRole.VECTOR)),
("vector3h", og.Type(og.BaseDataType.HALF, 3, 0, og.AttributeRole.VECTOR)),
]
test_data = simple_data + simple_data_no_tuples + tuple_data + array_data + array_tuple_data + role_data
for (attribute_type_spec, attribute_type_expected) in test_data:
actual = og.AttributeType.type_from_sdf_type_name(attribute_type_spec)
self.assertEqual(
attribute_type_expected,
actual,
f"Failed to convert '{attribute_type_spec}' - '{attribute_type_expected.get_type_name()}'"
f" != '{actual.get_type_name()}'",
)
# ----------------------------------------------------------------------
async def test_extension_information(self):
"""Test operation of the utilities to examine extension and OmniGraph node type information"""
extension_information = og.ExtensionInformation()
manager = omni.kit.app.get_app_interface().get_extension_manager()
examples_cpp_extension = "omni.graph.examples.cpp"
nodes_extension = "omni.graph.nodes"
# If the two known extensions are somehow not found then the test cannot run
examples_cpp_extension_id = None
nodes_extension_id = None
with suppress(Exception):
examples_cpp_extension_id = manager.get_extension_id_by_module(examples_cpp_extension)
nodes_extension_id = manager.get_extension_id_by_module(nodes_extension)
if not examples_cpp_extension_id:
carb.log_warn("test_extension_information cannot run since omni.graph.examples.cpp was not found")
return
if not nodes_extension_id:
carb.log_warn("test_extension_information cannot run since omni.graph.nodes was not found")
return
# Remember the enabled state so that we can gracefully recover after the test run
examples_cpp_enabled = manager.is_extension_enabled(examples_cpp_extension)
nodes_enabled = manager.is_extension_enabled(nodes_extension)
try:
# The test proceeds by creating five nodes, two OmniGraph nodes from each of the known extensions
# and one Prim that is given attribute information to make it look like an OmniGraph node. Then the
# extension mapping information is read in with all of the extension enabled/disabled combinations to
# ensure the correct information is retrieved.
# Set up the scene with both extensions enabled to begin with
manager.set_extension_enabled_immediate(examples_cpp_extension_id, True)
manager.set_extension_enabled_immediate(nodes_extension_id, True)
examples_cpp_node_types = ["omni.graph.examples.cpp.Smooth", "omni.graph.examples.cpp.VersionedDeformer"]
examples_cpp_nodes = ["/TestGraph/Smooth", "/TestGraph/VersionedDeformer"]
nodes_node_types = ["omni.graph.nodes.ArrayLength", "omni.graph.nodes.Noop"]
nodes_nodes = ["/TestGraph/ArrayLength", "/TestGraph/Noop"]
og.Controller.edit(
"/TestGraph",
{
og.Controller.Keys.CREATE_NODES: [
(examples_cpp_nodes[0][11:], examples_cpp_node_types[0]),
(examples_cpp_nodes[1][11:], examples_cpp_node_types[1]),
(nodes_nodes[0][11:], nodes_node_types[0]),
(nodes_nodes[1][11:], nodes_node_types[1]),
]
},
)
# test_data is a list of test configurations where the contents are:
# Enable omni.graph.examples.cpp?
# Enable omni.graph.nodes?
test_data = [
[True, True],
[True, False],
[False, False],
[False, True],
]
for enable_examples_cpp, enable_nodes in test_data:
manager.set_extension_enabled_immediate(examples_cpp_extension_id, enable_examples_cpp)
manager.set_extension_enabled_immediate(nodes_extension_id, enable_nodes)
# The first test reads the entire set of extension node types. As this is always in flux only a few
# that are unlikely to move are checked.
(enabled_extensions, disabled_extensions) = extension_information.get_node_types_by_extension()
# Make sure the extensions are partitioned correctly by enabled state
if enable_examples_cpp:
self.assertTrue(examples_cpp_extension in enabled_extensions)
self.assertTrue(examples_cpp_extension not in disabled_extensions)
for node_type in examples_cpp_node_types:
self.assertIn(node_type, enabled_extensions[examples_cpp_extension])
else:
self.assertTrue(examples_cpp_extension not in enabled_extensions)
self.assertTrue(examples_cpp_extension in disabled_extensions)
for node_type in examples_cpp_node_types:
self.assertIn(node_type, disabled_extensions[examples_cpp_extension])
if enable_nodes:
self.assertTrue(nodes_extension in enabled_extensions)
self.assertTrue(nodes_extension not in disabled_extensions)
for node_type in nodes_node_types:
self.assertIn(node_type, enabled_extensions[nodes_extension])
else:
self.assertTrue(nodes_extension not in enabled_extensions)
self.assertTrue(nodes_extension in disabled_extensions)
for node_type in nodes_node_types:
self.assertIn(node_type, disabled_extensions[nodes_extension])
# Check that the node configuration is also returning the correct data
(enabled_nodes, disabled_nodes) = extension_information.get_nodes_by_extension()
if enable_examples_cpp:
self.assertTrue(examples_cpp_extension in enabled_nodes)
self.assertTrue(examples_cpp_extension not in disabled_nodes)
for node_path in examples_cpp_nodes:
self.assertIn(node_path, enabled_nodes[examples_cpp_extension])
else:
self.assertTrue(examples_cpp_extension not in enabled_nodes)
self.assertTrue(examples_cpp_extension in disabled_nodes)
for node_path in examples_cpp_nodes:
self.assertIn(node_path, disabled_nodes[examples_cpp_extension])
if enable_nodes:
self.assertTrue(nodes_extension in enabled_nodes)
self.assertTrue(nodes_extension not in disabled_nodes)
for node_path in nodes_nodes:
self.assertIn(node_path, enabled_nodes[nodes_extension])
else:
self.assertTrue(nodes_extension not in enabled_nodes)
self.assertTrue(nodes_extension in disabled_nodes)
for node_path in nodes_nodes:
self.assertIn(node_path, disabled_nodes[nodes_extension])
finally:
manager.set_extension_enabled_immediate(examples_cpp_extension, examples_cpp_enabled)
manager.set_extension_enabled_immediate(nodes_extension, nodes_enabled)
# ----------------------------------------------------------------------
async def test_graphregistry_event_stream(self):
"""
Tests the graph registry event stream notifies when extensions
with node types are loaded and unloaded
"""
examples_python_extension = "omni.graph.examples.python"
manager = omni.kit.app.get_app_interface().get_extension_manager()
examples_python_extension_id = None
with suppress(Exception):
examples_python_extension_id = manager.get_extension_id_by_module(examples_python_extension)
if not examples_python_extension_id:
carb.log_warn(f"test_graphregistry_event_stream cannot run since {examples_python_extension} was not found")
return
examples_enabled = manager.is_extension_enabled(examples_python_extension)
# tests the registration
count = 0
event_type = None
def on_changed(event):
nonlocal count
nonlocal event_type
if event.type in (int(og.GraphRegistryEvent.NODE_TYPE_ADDED), int(og.GraphRegistryEvent.NODE_TYPE_REMOVED)):
event_type = event.type
count = count + 1
sub = og.GraphRegistry().get_event_stream().create_subscription_to_pop(on_changed)
self.assertIsNotNone(sub)
try:
enabled = examples_enabled
# each load/unload should trigger the callback for each node loaded/unloaded
last_count = count
for i in range(1, 4):
enabled = not enabled
manager.set_extension_enabled_immediate(examples_python_extension, enabled)
await omni.kit.app.get_app().next_update_async()
self.assertGreater(count, last_count)
if enabled:
self.assertEqual(event_type, int(og.GraphRegistryEvent.NODE_TYPE_ADDED))
else:
self.assertEquals(event_type, int(og.GraphRegistryEvent.NODE_TYPE_REMOVED))
last_count = count
# wait more frames to validate the callback didn't get called without an extension change
for _j in range(1, i):
await omni.kit.app.get_app().next_update_async()
self.assertEqual(count, last_count)
finally:
manager.set_extension_enabled_immediate(examples_python_extension, examples_enabled)
# ----------------------------------------------------------------------
async def test_typed_value(self):
"""Test operation of the TypedValue class"""
# Test data consists of args + kwargs values to pass to the set() method, a boolean indicating whether setting
# should succeed or not, and the expected value and type after setting. When there are two args or two kwargs
# the __init__ method is used as well as those are the cases in which it is valid.
unknown_t = og.Type(og.BaseDataType.UNKNOWN)
float_t = og.Type(og.BaseDataType.FLOAT)
test_data = [
# Legal args configurations
[[], {}, True, None, unknown_t],
[[1.0], {}, True, 1.0, unknown_t],
[[1.0, "float"], {}, True, 1.0, float_t],
[[1.0, float_t], {}, True, 1.0, float_t],
# Legal kwargs configurations
[[], {"value": 1.0}, True, 1.0, unknown_t],
[[], {"value": 1.0, "type": "float"}, True, 1.0, float_t],
[[], {"value": 1.0, "type": float_t}, True, 1.0, float_t],
[[], {"type": float_t, "value": 1.0}, True, 1.0, float_t],
# Illegal args combinations
[[1.0, "float", 2], {}, False, None, None],
[[1.0, "sink"], {}, False, None, None],
[["float", 1.0], {}, False, None, None],
# Illegal kwargs combinations
[[], {"valley": 1.0}, False, None, None],
[[], {"type": "float"}, False, None, None],
[[], {"value": 1.0, "type": "flat"}, False, None, None],
[[], {"value": 1.0, "type": "float", "scissors": "run_with"}, False, None, None],
# Illegal args+kwargs combinations
[[1.0], {"type": "float"}, False, None, None],
[[1.0, "float"], {"value": 1.0}, False, None, None],
]
for args, kwargs, should_succeed, expected_value, expected_type in test_data:
test_info = (
f"args={args}, kwargs={kwargs}, success={should_succeed}, value={expected_value}, type={expected_type}"
)
if should_succeed:
if len(args) == 2:
init_test = og.TypedValue(*args)
self.assertEqual(init_test.value, expected_value, test_info)
self.assertEqual(init_test.type, expected_type, test_info)
elif len(kwargs) == 2:
init_test = og.TypedValue(**kwargs)
self.assertEqual(init_test.value, expected_value, test_info)
self.assertEqual(init_test.type, expected_type, test_info)
set_test = og.TypedValue()
set_test.set(*args, **kwargs)
self.assertEqual(set_test.value, expected_value, test_info)
self.assertEqual(set_test.type, expected_type, test_info)
else:
with self.assertRaises(og.OmniGraphError):
set_test = og.TypedValue()
set_test.set(*args, **kwargs)
if len(args) == 2 and not kwargs:
with self.assertRaises(og.OmniGraphError):
init_test = og.TypedValue(*args)
elif len(kwargs) == 2 and not args:
with self.assertRaises(og.OmniGraphError):
init_test = og.TypedValue(**kwargs)
# ----------------------------------------------------------------------
async def test_category_setup(self):
"""Test that the default category list is something sensible"""
# Read the exact set of default categories, which should be the minimum available category list
category_path = Path(carb.tokens.get_tokens_interface().resolve("${kit}")) / "dev" / "ogn" / "config"
with open(category_path / "CategoryConfiguration.json", "r", encoding="utf-8") as cat_fd:
default_categories = dict(json.load(cat_fd)["categoryDefinitions"].items())
actual_categories = og.get_node_categories_interface().get_all_categories()
# compounds is a special case that gets added at runtime, not in ogn, and is not intended
# for use by .ogn compiled nodes.
self.assertTrue("Compounds" in actual_categories)
for category_name, category_description in actual_categories.items():
if category_name == "Compounds":
continue
self.assertTrue(category_name in default_categories)
self.assertEqual(category_description, default_categories[category_name])
# ----------------------------------------------------------------------
async def test_app_information(self):
"""Test the functions which return information about the running application."""
# Make sure that we get back a tuple containing two non-negative ints.
kit_version = og.get_kit_version()
self.assertTrue(
isinstance(kit_version, tuple), f"get_kit_version() returned type {type(kit_version)}, not tuple"
)
self.assertEqual(
len(kit_version), 2, f"get_kit_version() returned tuple with {len(kit_version)} elements, expected 2"
)
self.assertTrue(
isinstance(kit_version[0], int) and isinstance(kit_version[1], int),
f"get_kit_version() returned types ({type(kit_version[0])}, {type(kit_version[1])}, expected (int, int)",
)
self.assertTrue(
kit_version[0] >= 0 and kit_version[1] >= 0, f"get_kit_version() returned invalid value '{kit_version}'"
)
# ----------------------------------------------------------------------
async def test_temp_settings(self):
"""Test the Settings.temporary context manager."""
setting_names = ("/omnigraph/test/boolval", "/omnigraph/test/intval", "/omnigraph/test/sub/strval")
# Initialize the settings.
settings = carb.settings.get_settings()
initial_values = (True, None, "first")
initial_settings = list(zip(setting_names, initial_values))
for name, value in initial_settings:
settings.destroy_item(name)
if value is not None:
settings.set(name, value)
# Test the single setting version of the context.
with og.Settings.temporary(setting_names[2], "second"):
self.assertEqual(settings.get(setting_names[2]), "second", "Single setting, in context.")
self.assertEqual(settings.get(setting_names[2]), initial_values[2], "Single setting, after context.")
# Test the list version.
temp_settings = list(zip(setting_names, (False, 6, "third")))
with og.Settings.temporary(temp_settings):
for name, value in temp_settings:
self.assertEqual(settings.get(name), value, f"Multiple settings, in context: '{name}'")
for name, value in initial_settings:
self.assertEqual(settings.get(name), value, f"Multiple settings, after context: '{name}'")
# Clean up.
for name in setting_names:
settings.destroy_item(name)
| 25,391 | Python | 54.806593 | 120 | 0.586074 |
omniverse-code/kit/exts/omni.graph/omni/graph/core/tests/test_register_ogn_nodes.py | """
Contains support for testing methods in ../scripts/register_ogn_nodes
"""
import os
from pathlib import Path
from tempfile import TemporaryDirectory
import omni.graph.core.tests as ogts
import omni.graph.tools.ogn as ogn
from .._impl.register_ogn_nodes import find_import_locations
class TestRegisterOgnNodes(ogts.OmniGraphTestCase):
"""Unit test class"""
# --------------------------------------------------------------------------------------------------------------
def test_find_import_locations(self):
"""Test for the utility function find_import_locations
Test data consists of list of (inputs, outputs, failure):
inputs (2-tuple):
Path to file calling the scripts
Python import path for the extension
outputs (2-tuple):
Expected location of the import path's root directory
Expected location of the calling file's directory
failure (bool):
Should the test raise an exception?
"""
no_exception = False
exception = True
drive = "C:" if os.name == "nt" else "/drive"
test_data = [
[(f"{drive}/a/b/c/d.py", "b.c"), (f"{drive}/a", f"{drive}/a/b/c"), no_exception],
[(f"{drive}/a/b/c/d.py", "b.c.d"), (), exception],
]
for (index, test_run) in enumerate(test_data):
if test_run[2]:
with self.assertRaises(ValueError, msg=f"Expected failure in test {index} - {test_run}"):
_ = find_import_locations(test_run[0][0], test_run[0][1])
else:
results = find_import_locations(test_run[0][0], test_run[0][1])
self.assertEqual(results[0], test_run[1][0], f"Import root for {test_run}")
self.assertEqual(results[1], test_run[1][1], f"Generated directory for {test_run}")
# --------------------------------------------------------------------------------------------------------------
def test_generate_automatic_test_imports(self):
"""Test for the utility function generate_automatic_test_imports
Test data consists of list of (test_files, output, should_modify):
inputs (List[str]):
List of test file names to create
output (str):
Expected contents of __init__.py
should_modify (bool):
Should the test have modified __init__.py
"""
full_test_file = ogn.import_file_contents()
test_data = [
[], # Generate an empty init file if no tests are available
["TestOgnTest1.py"], # Add a new test case
["TestOgnTest1.py"], # No new testcases so no changes should be made
["TestOgnTest1.py", "TestOgnTest2.py"], # Add a new test case
[], # No testcases leaves the file in place
]
# Set up temporary test directory
with TemporaryDirectory() as test_directory_fd:
test_directory = Path(test_directory_fd)
import_filepath = test_directory / "__init__.py"
for test_run, test_files in enumerate(test_data):
# Create empty test files
for file in test_files:
with open(test_directory / file, "a", encoding="utf-8"):
pass
ogn.generate_test_imports(test_directory, write_file=True)
# Verify __init__.py contents
with open(import_filepath, "r", encoding="utf-8") as import_fd:
self.assertCountEqual(
[line.rstrip() for line in import_fd.readlines()],
full_test_file,
f"Generated incorrect test import file for run {test_run}",
)
# Delete generated test files to prepare for the next test
for file in test_directory.glob("TestOgn*.py"):
file.unlink()
| 3,964 | Python | 42.571428 | 116 | 0.53557 |
omniverse-code/kit/exts/omni.graph/omni/graph/core/tests/omnigraph_test_utils.py | # noqa: PLC0302
"""A set of utilities useful for testing OmniGraph.
Note that this file should not be imported directly, the API is in omni.graph.core.tests.
Available in this module are:
- omni.graph.core.tests.DataTypeHelper - a utility class to help iterate over all available data types
- omni.graph.core.tests.find_build_directory_above - find the root directory of the build
- omni.graph.core.tests.load_test_file - load a test file and wait for it to be ready
- omni.graph.core.tests.insert_sublayer - load a test file as a sublayer
- omni.graph.core.tests.dump_graph - conditionally call omni.graph.core.tests.print_current_graph
- omni.graph.core.tests.print_current_graph - print out the contents of the existing OmniGraphs
- omni.graph.core.tests.compare_lists - do an unordered comparison of two lists
- omni.graph.core.tests.verify_connections - confirm that a set of expected connections exists
- omni.graph.core.tests.verify_node_existence - confirm that a set of expected nodes exists
- omni.graph.core.tests.verify_values - confirm that a set of expected attribute values are correct
- omni.graph.core.tests.create_scope_node - create a Scope prim
- omni.graph.core.tests.create_cube - create a Cube prim
- omni.graph.core.tests.create_sphere - create a Sphere prim
- omni.graph.core.tests.create_cone - create a Cube prim
- omni.graph.core.tests.create_grid_mesh - Create a simple mesh consisting of a grid
- omni.graph.core.tests.create_input_and_output_grid_meshes - Create two meshes consisting of grids
"""
import inspect
import os
import unittest
from abc import ABC, abstractmethod
from contextlib import suppress
from dataclasses import dataclass
from math import isclose, isnan
from typing import Any, Dict, List, Optional, Tuple, Union
import carb
import numpy as np
import omni.graph.core as og
import omni.graph.tools as ogt
import omni.graph.tools.ogn as ogn
import omni.kit
import omni.usd
from pxr import OmniGraphSchemaTools, Sdf, Usd, UsdGeom
# If a node type version is unspecified then this is the value it gets.
# Keep in sync with kDefaultNodeTypeVersion in include/omni/graph/core/NodeTypeRegistrar.h
NODE_TYPE_VERSION_DEFAULT = 1
# ==============================================================================================================
class TestContextManager(ABC):
"""Definition of the context classes that can be temporarily enabled during tests.
These can be passed in to the test_case_class() factory method to extend the capabilities it has that are
hardcoded in this file by instantiating one of these classes and passing it through the extra_contexts= parameter.
The __init__ gets called to instantiate the base class information required by the test case.
The setUp() method gets called when the test case's setUp method is called (once for every test).
The tearDown() method gets called when the test case's tearDown method is called (once for every test)
"""
@abstractmethod
def __init__(self):
"""Remember the setting name."""
@abstractmethod
async def setUp(self):
"""Called when the test case setUp() is called"""
@abstractmethod
async def tearDown(self):
"""Called when the test case tearDown() is called"""
# ==============================================================================================================
class SettingContext(TestContextManager):
"""Helper class with an setUp and tearDown for modifying and restoring a carb setting"""
def __init__(self, setting_name: str, temporary_value: any):
"""Remember the setting name."""
super().__init__()
self.__setting_name = setting_name
self.__temporary_value = temporary_value
self.__original_value = None
async def setUp(self):
"""Save the current value of the setting and set it to the desired temporary value"""
settings = carb.settings.get_settings()
self.__original_value = settings.get(self.__setting_name)
ogt.dbg(f"SETUP Setting: Change {self.__setting_name} from {self.__original_value} to {self.__temporary_value}")
settings.set(self.__setting_name, self.__temporary_value)
async def tearDown(self):
"""Restore the original value of the setting"""
ogt.dbg(
f"TEARDOWN Setting: Restore {self.__setting_name} to {self.__original_value} from {self.__temporary_value}"
)
carb.settings.get_settings().set(self.__setting_name, self.__original_value)
# ==============================================================================================================
class __ClearSceneContext(TestContextManager):
"""Helper class with an setUp and tearDown for potentially clearing the scene when a test is complete"""
def __init__(self): # noqa: PLW0246
"""Empty init is required since the parent is abstract"""
super().__init__()
async def setUp(self):
"""Nothing to do when setting up the test but the method is required"""
ogt.dbg("SETUP ClearScene")
async def tearDown(self):
"""If a clear was requested on tearDown do it now"""
ogt.dbg("TEARDOWN ClearScene")
await omni.usd.get_context().new_stage_async()
# ==============================================================================================================
def test_case_class(**kwargs) -> object:
""" "Factory to return a base class to use for a test case configured with certain transient settings.
The argument list is intentionally generic so that future changes can happen without impacting existing cases.
The contexts will be invoked in the order specified below, with the extra_contexts being invoked in the order
of the list passed in.
Args:
no_clear_on_finish (bool): If True then the scene will not be cleared after the test is complete
extra_contexts (List[TestContextManager]): List of user-defined context managers to pass in
deprecated (Tuple[str, DeprecationLevel]): Used to indicate this instantiation of the class has been deprecated
base_class (object): Alternative base class for the test case, defaults to omni.kit.test.AsyncTestCase
Return:
Class object representing the base class for a test case with the given properties
"""
# Check to see if an alternative base class was passed in
base_class = omni.kit.test.AsyncTestCase
with suppress(KeyError):
base_class = kwargs["base_class"]
# Issue the deprecation message if specified, but continue on
deprecation = None
with suppress(KeyError):
deprecation = kwargs["deprecated"]
# Create a container for classes that will manage the temporary setting changes
custom_actions = []
with suppress(KeyError):
extra_contexts = kwargs["extra_contexts"]
if not isinstance(extra_contexts, list):
extra_contexts = [extra_contexts]
for extra_context in extra_contexts:
if not isinstance(extra_context, TestContextManager):
raise ValueError(f"extra_contexts {extra_context} is not a TestContextManager")
custom_actions.append(extra_context)
if "no_clear_on_finish" not in kwargs or not kwargs["no_clear_on_finish"]:
custom_actions.append(__ClearSceneContext())
# --------------------------------------------------------------------------------------------------------------
# Construct the customized test case base class object using the temporary setting and base class information
class OmniGraphCustomTestCase(base_class):
"""A custom constructed test case base class that performs the prescribed setUp and tearDown actions.
Members:
__actions: List of actions to perform on setUp (calls action.setUp()) and tearDown (calls action.tearDown())
"""
async def setUp(self):
"""Set up the test by saving and then setting up all of the action contexts"""
super().setUp()
if deprecation is not None:
ogt.DeprecateMessage.deprecated(deprecation[0], deprecation[1])
# Start with no test failures registered
og.set_test_failure(False)
# Always start with a clean slate as the settings may conflict with something in the scene
await omni.usd.get_context().new_stage_async()
await omni.kit.app.get_app().next_update_async()
# Perform the custom action entries
self.__action_contexts = custom_actions
for action in self.__action_contexts:
await action.setUp()
async def tearDown(self):
"""Complete the test by tearing down all of the action contexts"""
# Perform the custom action tearDowns
for action in reversed(self.__action_contexts):
await action.tearDown()
super().tearDown()
# Return the constructed class definition
return OmniGraphCustomTestCase
OmniGraphTestCase = test_case_class()
"""Default test case base class used for most OmniGraph tests"""
OmniGraphTestCaseNoClear = test_case_class(no_clear_on_finish=True)
"""Test case class that leaves the stage as it was when the test completed"""
# ==============================================================================================================
class DataTypeHelper:
"""
Class providing utility methods to assist with the comprehensive data type tests.
Example of how to walk all of the valid input attribute values:
for attribute_type in DataTypeHelper.all_attribute_types():
try:
input_value = DataTypeHelper.test_input_value(attribute_type)
process(input_value)
except TypeError:
pass # Cannot process this type yet
"""
_ATTR_TEST_DATA = None
# --------------------------------------------------------------------------------------------------------------
@staticmethod
def all_test_data() -> Dict[str, List[Any]]:
"""Returns a dict mapping all available Sdf attribute type names and a pair of sample values of those types"""
if DataTypeHelper._ATTR_TEST_DATA is None:
# Lazily initialize since this data is not needed until tests request it
test_data = {}
for type_name in ogn.supported_attribute_type_names():
attribute_type = og.AttributeType.type_from_ogn_type_name(type_name)
sdf_type_name = og.AttributeType.sdf_type_name_from_type(attribute_type)
if sdf_type_name is not None:
test_data[sdf_type_name] = ogn.get_attribute_manager_type(type_name).sample_values()
DataTypeHelper._ATTR_TEST_DATA = test_data
return DataTypeHelper._ATTR_TEST_DATA
# --------------------------------------------------------------------------------------------------------------
@staticmethod
def all_attribute_types() -> List[str]:
"""Return the list of all supported attribute Sdf type names, including array versions"""
return list(DataTypeHelper.all_test_data().keys())
# --------------------------------------------------------------------------------------------------------------
@staticmethod
def test_input_value(attribute_type_name: str) -> Any:
"""
:return: Test value on the input side of a node for the given attribute type
:raise TypeError: If the attribute type is not yet supported
"""
try:
return DataTypeHelper.all_test_data()[attribute_type_name][0] # noqa: PLE1136
except KeyError as error:
raise TypeError(f"Not yet supporting attribute type {attribute_type_name}") from error
# --------------------------------------------------------------------------------------------------------------
@staticmethod
def test_output_value(attribute_type_name: str) -> any:
"""
:return: Test value on the output side of a node for the given attribute type
:raise TypeError: If the attribute type is not yet supported
"""
try:
return DataTypeHelper.all_test_data()[attribute_type_name][1] # noqa: PLE1136
except KeyError as error:
raise TypeError(f"Not yet supporting attribute type {attribute_type_name}") from error
# --------------------------------------------------------------------------------------------------------------
@staticmethod
def attribute_names(attribute_type_name: str, is_downstream_node: bool):
"""
:param attribute_type_name: One of the available attribute types, including arrays of them (e.g. int and int[])
:param is_downstream_node: True means it is one of the nodes accepting inputs, not computing anything itself
:return: Pair of (INPUT_ATTRIBUTE_NAME, OUTPUT_ATTRIBUTE_NAME) used for the data test nodes
"""
suffixes = ["from_input", "from_output"] if is_downstream_node else ["original", "computed"]
return [f"a_{attribute_type_name.replace('[]','_array')}_{suffixes[i]}" for i in range(2)]
# --------------------------------------------------------------------------------------------------------------
def dump_graph(force_dump: bool = False):
"""Utility to conditionally print the current contents of the scene and graph"""
if ogt.OGN_DEBUG or force_dump:
print_current_graph()
print(omni.usd.get_context().get_stage().GetRootLayer().ExportToString())
# --------------------------------------------------------------------------------------------------------------
def find_build_directory_above(start_at: Optional[str] = None) -> str:
"""Find the absolute path to the _build/ directory above the current one.
If any of the folder up that path contains `dev/ogn` subfolder that is prioritized over `_build/`
for shallow package support which don't have _build folder packaged at all.
Using this method avoids the problems associated with following symlinks up a tree.
:param start_at: Location at which to start looking; if None start at this script's location
:raises ValueError: if there is no build directory above this file's directory
:return: Path in which the _build/ directory was found
"""
starting_file = __file__ if start_at is None else start_at
build_directory = os.path.abspath(starting_file)
(parent_directory, leaf_directory) = os.path.split(build_directory)
while leaf_directory != "_build":
if os.path.exists(f"{parent_directory}/dev/ogn"):
return f"{parent_directory}/dev"
build_directory = parent_directory
(parent_directory, leaf_directory) = os.path.split(build_directory)
if parent_directory == build_directory:
raise ValueError(f"No _build/ directory above {starting_file}")
return build_directory
# --------------------------------------------------------------------------------------------------------------
async def load_test_file(test_file_name: str, use_caller_subdirectory: bool = False) -> Tuple[bool, str]:
"""
Load the contents of the USD test file onto the stage, synchronously, when called as "await load_test_file(X)".
In a testing environment we need to run one test at a time since there is no guarantee
that tests can run concurrently, especially when loading files. This method encapsulates
the logic necessary to load a test file using the omni.kit.asyncapi method and then wait
for it to complete before returning.
Args:
test_file_name: Name of the test file to load - if an absolute path use it as-is
use_caller_subdirectory: If True, look in the data/ subdirectory of the caller's directory for the file
otherwise it will look in the data/ subdirectory below this directory
Returns:
(LOAD_SUCCEEDED[bool], LOAD_ERROR[str])
Raises:
ValueError if the test file is not a valid USD file
"""
if not Usd.Stage.IsSupportedFile(test_file_name):
raise ValueError("Only USD files can be loaded with this method")
if os.path.isabs(test_file_name):
path_to_file = test_file_name
elif use_caller_subdirectory:
path_to_file = os.path.join(os.path.dirname(inspect.stack()[1][1]), "data", test_file_name)
else:
path_to_file = os.path.join(os.path.dirname(__file__), "data", test_file_name)
# Unicode error might happen if the file is a .usd rather than .usda and it was already pulled so that case is okay
with suppress(UnicodeDecodeError):
with open(path_to_file, "r", encoding="utf-8") as test_fd:
first_line = test_fd.readline()
if first_line.startswith("version"):
raise ValueError(f"Do a 'git lfs pull' to update the contents of {path_to_file}")
usd_context = omni.usd.get_context()
usd_context.disable_save_to_recent_files()
(result, error) = await usd_context.open_stage_async(path_to_file)
usd_context.enable_save_to_recent_files()
dump_graph()
await omni.kit.app.get_app().next_update_async()
return (result, str(error))
# --------------------------------------------------------------------------------------------------------------
async def insert_sublayer(test_file_name: str, use_caller_subdirectory: bool = False) -> bool:
"""
Inserts a sublayer from the given usd file into the current stage
Args:
test_file_name: Name of the test file to load - if an absolute path use it as-is
use_caller_subdirectory: If True, look in the data/ subdirectory of the caller's directory for the file
otherwise it will look in the data/ subdirectory below this directory
Returns:
True if the layer was loaded successfully, false otherwise
"""
if os.path.isabs(test_file_name):
path_to_file = test_file_name
elif use_caller_subdirectory:
path_to_file = os.path.join(os.path.dirname(inspect.stack()[1][1]), "data", test_file_name)
else:
path_to_file = os.path.join(os.path.dirname(__file__), "data", test_file_name)
root_layer = omni.usd.get_context().get_stage().GetRootLayer()
sublayer_position = len(root_layer.subLayerPaths)
new_layer = Sdf.Layer.FindOrOpen(path_to_file)
if new_layer:
relative_path = omni.client.make_relative_url(root_layer.identifier, new_layer.identifier).replace("\\", "/")
root_layer.subLayerPaths.insert(sublayer_position, relative_path)
else:
return False
await omni.kit.app.get_app().next_update_async()
return True
# --------------------------------------------------------------------------------------------------------------
def print_current_graph(show_attributes: bool = True, show_connections: bool = True, show_evaluation: bool = True):
"""
Finds the current compute graph and prints out the nodes and attributes in it.
Args:
show_attributes: If True then include the attributes on the nodes
show_connections: If True then include the connections between the nodes
show_evaluation: If True then include the evaluation info for the graph
"""
flags = []
if show_attributes:
flags.append("attributes")
if show_connections:
flags.append("connections")
if show_evaluation:
flags.append("evaluation")
print(og.OmniGraphInspector().as_json(og.get_all_graphs()[0], flags=flags), flush=True)
# --------------------------------------------------------------------------------------------------------------
def compare_lists(expected_values: list, actual_values: list, comparing_what: str):
"""Compare the values in two lists, returning a relevant message if they are different, None if not"""
extra_values = set(actual_values) - set(expected_values)
missing_values = set(expected_values) - set(actual_values)
if extra_values:
return f"Unexpected {comparing_what} found - {extra_values}"
if missing_values:
return f"Expected {comparing_what} missing - {missing_values}"
return None
# --------------------------------------------------------------------------------------------------------------
def verify_connections(connections_expected: list):
"""
Confirm that the list of connections passed in exists in the compute graph, and are the only connections present.
The argument is a list of pairs (SRC, DST) corresponding to the connection SRC -> DST
"""
graph = og.get_all_graphs()[0]
if not graph.is_valid():
return "Compute graph has no valid contexts"
ogt.dbg(f"Expecting {connections_expected}")
# Collect connection information in both directions to verify they are the same
upstream_connections_found = []
downstream_connections_found = []
comparison_errors = []
nodes = graph.get_nodes()
# Ignore the default nodes since they may change and this test doesn't care
nodes_of_interest = [
node
for node in nodes
if node.get_prim_path().find("/default") != 0
and node.get_prim_path().find("/Omniverse") < 0
and node.get_prim_path() != "/World"
and node.get_prim_path() != "/"
]
for node in nodes_of_interest:
attributes_on_node = node.get_attributes()
for attribute in attributes_on_node:
this_attr = node.get_attribute(attribute.get_name())
this_attr_name = f"{node.get_prim_path()}.{attribute.get_name()}"
upstream_connections = this_attr.get_upstream_connections()
if len(upstream_connections) > 0:
for connection in upstream_connections:
upstream_attr_name = f"{connection.get_node().get_prim_path()}.{connection.get_name()}"
upstream_connections_found.append((upstream_attr_name, this_attr_name))
downstream_connections = this_attr.get_downstream_connections()
if len(downstream_connections) > 0:
for connection in downstream_connections:
downstream_attr_name = f"{connection.get_node().get_prim_path()}.{connection.get_name()}"
downstream_connections_found.append((this_attr_name, downstream_attr_name))
ogt.dbg(f"Upstream = {upstream_connections_found}")
ogt.dbg(f"Downstream = {downstream_connections_found}")
comparison_error = compare_lists(
upstream_connections_found, downstream_connections_found, "upstream/downstream pair"
)
if comparison_error is not None:
comparison_errors.append(comparison_error)
comparison_error = compare_lists(connections_expected, downstream_connections_found, "connection")
if comparison_error is not None:
comparison_errors.append(comparison_error)
return comparison_errors
# --------------------------------------------------------------------------------------------------------------
def verify_node_existence(primitives_expected: list):
"""
Confirm that the list of nodes passed in exists in the compute graph.
Args:
primitives_expected: List of node names expected in the graph.
Returns:
A list of errors found, empty list if none
"""
graph = og.get_all_graphs()[0]
if not graph.is_valid():
return ["Compute graph has no valid contexts"]
comparison_errors = []
nodes = graph.get_nodes()
# Get the current nodes in the world, ignoring the defaults since they may change and this test doesn't care
primitives_found = [node.get_prim_path() for node in nodes if node.get_prim_path() in primitives_expected]
comparison_error = compare_lists(primitives_expected, primitives_found, "compute graph primitives")
if comparison_error is not None:
comparison_errors.append(comparison_error)
return comparison_errors
# --------------------------------------------------------------------------------------------------------------
def verify_values(expected_value, actual_value, error_message: str):
"""Generic assert comparison which uses introspection to choose the correct method to compare the data values
Args:
expected_value: Value that was expected to be seen
actual_value: Actual value that was seen
error_message: Message describing the error if they do not match
Raises:
ValueError: With error message if the values do not match
"""
ogt.dbg(f"Comparing {actual_value} with expected {expected_value} - error = '{error_message}'")
def to_np_array(from_value: Union[List, Tuple, np.ndarray]) -> np.ndarray:
"""Returns the list of values as a flattened numpy array"""
# TODO: The only reason this is flattened at the moment is because Python matrix values are incorrectly
# extracted as a flat array. They should maintain their data shape.
return np.array(from_value).flatten()
def is_close(first_value: float, second_value: float):
"""Raise a ValueError iff the single float values are not equal or floating-point close"""
# Handle the NaN values first, which don't equal each other but should compare to equal for testing purposes
if isnan(first_value) and isnan(second_value):
return
if isnan(first_value) or isnan(second_value):
raise ValueError("NaN is only equal to other NaN values")
# Default tolerance is 1e-9, which is a little tight for most simple uses
if not isclose(first_value, second_value, rel_tol=1e-9):
if not isclose(first_value, second_value, rel_tol=1e-5):
raise ValueError
ogt.dbg("The tolerance had to be loosened to make this pass")
try:
if isinstance(expected_value, (list, tuple, np.ndarray)):
# Empty arrays are okay but only if both are empty. Using len() to handle both lists and numpy arrays
if not len(expected_value) or not len(actual_value): # noqa: PLC1802
if not len(expected_value) and not len(actual_value): # noqa: PLC1802
return
raise ValueError
# Lists of strings must be compared elementwise, numeric arrays can use numpy
if isinstance(expected_value[0], str):
if set(actual_value) != set(expected_value):
raise ValueError
else:
expected_array = to_np_array(expected_value)
actual_array = to_np_array(actual_value)
# If there are any NaN values then the array has to be checked element-by-element
if any(np.isnan(expected_array)) and any(np.isnan(actual_array)):
for expected, actual in zip(expected_array, actual_array):
is_close(expected, actual)
elif not np.allclose(expected_array, actual_array):
raise ValueError
elif isinstance(actual_value, (float, np.float32, np.float64, np.half)):
is_close(actual_value, expected_value)
else:
if actual_value != expected_value:
raise ValueError
except ValueError as error:
raise ValueError(
f"{error_message}: Expected '{expected_value}' ({type(expected_value)}), "
f"saw '{actual_value}' ({type(actual_value)})"
) from error
# --------------------------------------------------------------------------------------------------------------
def create_scope_node(prim_name: str, attribute_data: Optional[Dict[str, Any]] = None) -> str:
"""Create a Scope prim at the given path, populated with the attribute data.
This prim is a good source for a bundle attribute connection for testing.
Args:
prim_name: Name to give the prim within the current stage
attribute_data: Dictionary of attribute names and the value the attribute should have in the prim
The key is the name of the attribute in the prim.
The value is the attribute information as a tuple of (TYPE, ATTRIBUTE_VALUE)
TYPE: OGN name of the base data type
ATTRIBUTE_VALUE: Data stored in the attribute within the prim
Returns:
Full path to the prim within the current stage (usually the path passed in)
"""
if attribute_data is None:
attribute_data = {}
stage = omni.usd.get_context().get_stage()
prim_path = omni.usd.get_stage_next_free_path(stage, "/" + prim_name, True)
prim = stage.DefinePrim(prim_path, "Scope")
prim.CreateAttribute("node:type", Sdf.ValueTypeNames.Token).Set("Scope")
return prim
# --------------------------------------------------------------------------------------------------------------
def create_cube(stage, prim_name: str, displayColor: tuple) -> Usd.Prim: # noqa: N803
path = omni.usd.get_stage_next_free_path(stage, "/" + prim_name, True)
prim = stage.DefinePrim(path, "Cube")
prim.CreateAttribute("primvars:displayColor", Sdf.ValueTypeNames.Color3fArray).Set([displayColor])
prim.CreateAttribute("size", Sdf.ValueTypeNames.Double).Set(1.0)
return prim
# --------------------------------------------------------------------------------------------------------------
def create_sphere(stage, prim_name: str, displayColor: tuple) -> Usd.Prim: # noqa: N803
path = omni.usd.get_stage_next_free_path(stage, "/" + prim_name, True)
prim = stage.DefinePrim(path, "Sphere")
prim.CreateAttribute("primvars:displayColor", Sdf.ValueTypeNames.Color3fArray).Set([displayColor])
prim.CreateAttribute("radius", Sdf.ValueTypeNames.Double).Set(1.0)
return prim
# --------------------------------------------------------------------------------------------------------------
def create_cone(stage, prim_name: str, displayColor: tuple) -> Usd.Prim: # noqa: N803
path = omni.usd.get_stage_next_free_path(stage, "/" + prim_name, True)
prim = stage.DefinePrim(path, "Cone")
prim.CreateAttribute("primvars:displayColor", Sdf.ValueTypeNames.Color3fArray).Set([displayColor])
prim.CreateAttribute("radius", Sdf.ValueTypeNames.Double).Set(1.0)
prim.CreateAttribute("height", Sdf.ValueTypeNames.Double).Set(1.0)
return prim
# --------------------------------------------------------------------------------------------------------------
def create_grid_mesh(stage, path, counts=(32, 32), domain=(620, 620, 20), display_color=(1, 1, 1)):
mesh = UsdGeom.Mesh.Define(stage, path)
mesh.CreateDoubleSidedAttr().Set(True)
num_vertices = counts[0] * counts[1]
num_triangles = (counts[0] - 1) * (counts[1] - 1)
mesh.CreateFaceVertexCountsAttr().Set([3] * num_triangles * 2)
face_vertex_indices = [0] * num_triangles * 6
for i in range(counts[0] - 1):
for j in range(counts[1] - 1):
a = i * counts[0] + j
b = a + 1
c = a + counts[0]
d = c + 1
k = (i * (counts[0] - 1) + j) * 6
face_vertex_indices[k : k + 6] = [a, b, d, a, d, c]
mesh.CreateFaceVertexIndicesAttr().Set(face_vertex_indices)
points = [(0, 0, 0)] * num_vertices
for i in range(counts[0]):
for j in range(counts[1]):
points[i * counts[0] + j] = (i * domain[0] / (counts[0] - 1), j * domain[1] / (counts[1] - 1), domain[2])
mesh.CreatePointsAttr().Set(points)
mesh.CreateDisplayColorPrimvar().Set([display_color])
return mesh
# --------------------------------------------------------------------------------------------------------------
def create_input_and_output_grid_meshes(stage):
input_grid = create_grid_mesh(stage, "/defaultPrim/inputGrid", display_color=(0.2784314, 0.64705884, 1))
output_grid = create_grid_mesh(stage, "/defaultPrim/outputGrid", display_color=(0.784314, 0.64705884, 0.1))
return (input_grid, output_grid)
# ==============================================================================================================
# Below here is support for generated tests
#
@dataclass
class _TestGraphAndNode:
"""Helper class to pass graph and node around in test utility methods below"""
graph: og.Graph = None
node: og.Node = None
# --------------------------------------------------------------------------------------------------------------
async def _test_clear_scene(tc: unittest.TestCase, test_run: Dict[str, Any]):
"""Clear the scene if test run requires it
Args:
tc: Unit test case executing this method. Used to raise errors
test_run: Dictionary of consist of four sub-lists and a dictionary:
- values for input attributes, set before the test starts
- values for output attributes, checked after the test finishes
- initial values for state attributes, set before the test starts
- final values for state attributes, checked after the test finishes
- setup to be used for populating the scene via controller
For complete implementation see generate_user_test_data.
"""
setup = test_run.get("setup", None)
if setup is None or setup:
await omni.usd.get_context().new_stage_async()
# --------------------------------------------------------------------------------------------------------------
async def _test_setup_scene(
tc: unittest.TestCase,
controller: og.Controller,
test_graph_name: str,
test_node_name: str,
test_node_type: str,
test_run: Dict[str, Any],
last_test_info: _TestGraphAndNode,
instance_count=0,
) -> _TestGraphAndNode:
"""Setup the scene based on given test run dictionary
Args:
tc: Unit test case executing this method. Used to raise errors
controller: Controller object to use when constructing the scene (e.g. may have undo support disabled)
test_graph_name: Graph name to use when constructing the scene
test_node_name: Node name to use when constructing the scene without "setup" explicitly provided in test_run
test_node_type: Node type to use when constructing the scene without "setup" explicitly provided in test_run
test_run: Dictionary of consist of four sub-lists and a dictionary:
- values for input attributes, set before the test starts
- values for output attributes, checked after the test finishes
- initial values for state attributes, set before the test starts
- final values for state attributes, checked after the test finishes
- setup to be used for populating the scene via controller
For complete implementation see generate_user_test_data.
last_test_info: When executing multiple tests cases for the same node, this represents graph and node used in previous run
instance_count: number of instances to create assotiated to this graph, in order to test vectorized compute
Returns:
Graph and node to use in current execution of the test
"""
test_info = last_test_info
setup = test_run.get("setup", None)
if setup:
(test_info.graph, test_nodes, _, _) = controller.edit(test_graph_name, setup)
tc.assertTrue(test_nodes)
test_info.node = test_nodes[0]
elif setup is None:
test_info.graph = controller.create_graph(test_graph_name)
test_info.node = controller.create_node((test_node_name, test_info.graph), test_node_type)
else:
tc.assertTrue(
test_info.graph is not None and test_info.graph.is_valid(),
"Test is misconfigured - empty setup cannot be in the first test",
)
tc.assertTrue(test_info.graph is not None and test_info.graph.is_valid(), "Test graph invalid")
tc.assertTrue(test_info.node is not None and test_info.node.is_valid(), "Test node invalid")
test_info.graph.set_auto_instancing_allowed(False)
await controller.evaluate(test_info.graph)
inputs = test_run.get("inputs", [])
state_set = test_run.get("state_set", [])
values_to_set = inputs + state_set
if values_to_set:
for attribute_name, attribute_value, _ in values_to_set:
controller.set(attribute=(attribute_name, test_info.node), value=attribute_value)
# create some instance prims, and apply the graph on it
if instance_count != 0:
stage = omni.usd.get_context().get_stage()
for i in range(instance_count):
prim_name = f"/World/Test_Instance_Prim_{i}"
stage.DefinePrim(prim_name)
OmniGraphSchemaTools.applyOmniGraphAPI(stage, prim_name, test_graph_name)
return test_info
# --------------------------------------------------------------------------------------------------------------
def _test_verify_scene(
tc: unittest.TestCase,
controller: og.Controller,
test_run: Dict[str, Any],
test_info: _TestGraphAndNode,
error_msg: str,
instance_count=0,
):
"""Verify the scene state based on given test run dictionary
Args:
tc: Unit test case executing this method. Used to raise errors
controller: Controller object to use when constructing the scene (e.g. may have undo support disabled)
test_run: Dictionary of consist of four sub-lists and a dictionary:
- values for input attributes, set before the test starts
- values for output attributes, checked after the test finishes
- initial values for state attributes, set before the test starts
- final values for state attributes, checked after the test finishes
- setup to be used for populating the scene via controller
For complete implementation see generate_user_test_data.
error_msg: Customized error message to use as a prefix for all unit test errors detected within this method
instance_count: number of instances assotiated to this graph that needs to be verified
"""
outputs = test_run.get("outputs", [])
state_get = test_run.get("state_get", [])
for attribute_name, expected_value, _ in outputs + state_get:
test_attribute = controller.attribute(attribute_name, test_info.node)
expected_type = None
if isinstance(expected_value, dict):
expected_type = expected_value["type"]
expected_value = expected_value["value"]
if instance_count != 0:
for i in range(instance_count):
actual_output = controller.get(attribute=test_attribute, instance=i)
verify_values(
expected_value,
actual_output,
f"{error_msg}: {attribute_name} attribute value error on instance {i}",
)
else:
actual_output = controller.get(attribute=test_attribute)
verify_values(expected_value, actual_output, f"{error_msg}: {attribute_name} attribute value error")
if expected_type:
tp = og.AttributeType.type_from_ogn_type_name(expected_type)
actual_type = test_attribute.get_resolved_type()
if tp != actual_type:
raise ValueError(
f"{error_msg} - {attribute_name}: Expected {expected_type}, saw {actual_type.get_ogn_type_name()}"
)
# ==============================================================================================================
# _____ ______ _____ _____ ______ _____ _______ ______ _____
# | __ \ | ____|| __ \ | __ \ | ____|/ ____| /\ |__ __|| ____|| __ \
# | | | || |__ | |__) || |__) || |__ | | / \ | | | |__ | | | |
# | | | || __| | ___/ | _ / | __| | | / /\ \ | | | __| | | | |
# | |__| || |____ | | | | \ \ | |____| |____ / ____ \ | | | |____ | |__| |
# |_____/ |______||_| |_| \_\|______|\_____|/_/ \_\|_| |______||_____/
#
| 39,995 | Python | 47.538835 | 130 | 0.60185 |
omniverse-code/kit/exts/omni.graph/omni/graph/core/tests/test_internal_registration.py | # pylint: disable=too-many-lines
"""Tests the correct generation of node type definitions into the cache"""
from __future__ import annotations
import sys
from contextlib import ExitStack
from pathlib import Path
from tempfile import TemporaryDirectory
import omni.graph.core as og
import omni.graph.core.tests as ogts
import omni.graph.tools._internal as ogi
import omni.kit.test
from omni.graph.core._impl._registration.extension_management import extension_management_factory
from omni.graph.tools.tests.internal_utils import TemporaryPathAddition
from ._internal_utils import _TestExtensionManager
# Helper constants shared by many tests
_CURRENT_VERSIONS = ogi.GenerationVersions(ogi.Compatibility.FullyCompatible)
_EXT_INDEX = 0
# ==============================================================================================================
class ModuleContexts:
def __init__(self, stack: ExitStack):
"""Set up a stack of contexts to use for tests running in individual temporary directory"""
global _EXT_INDEX
_EXT_INDEX += 1
self.ext_name = f"omni.test.internal.registration{_EXT_INDEX}"
# Default extension version is 0.1.0 so create an ID with that
self.ext_id = f"{self.ext_name}-0.1.0"
# Put all temporary files in a temporary directory for easy disposal
self.test_directory = Path(stack.enter_context(TemporaryDirectory())) # pylint: disable=consider-using-with
self.python_root = Path(self.test_directory) / "exts"
self.module_name = self.ext_name
self.module_path = self.python_root / self.ext_name / self.ext_name.replace(".", "/")
# Redirect the usual node cache to the temporary directory
self.cache_root = stack.enter_context(ogi.TemporaryCacheLocation(self.test_directory / "cache"))
# Add the import path of the new extension to the system path
self.path_addition = stack.enter_context(TemporaryPathAddition(self.python_root / self.ext_name))
# Uncomment this to dump debugging information while the tests are running
# self.log = stack.enter_context(ogi.TemporaryLogLocation("stdout"))
# ==============================================================================================================
def _expected_cache_contents(
cache_root: Path, node_type_name: str, exclusions: list[ogi.FileType] = None
) -> list[Path]:
"""Returns a list of the files that should be in the generated cache at the given root for the given node type"""
file_list = [cache_root / "__init__.py", cache_root / f"{node_type_name}Database.py"]
if ogi.FileType.DOCS not in (exclusions or []):
file_list.append(cache_root / "docs" / f"{node_type_name}.rst")
if ogi.FileType.TEST not in (exclusions or []):
file_list.append(cache_root / "tests" / "__init__.py")
file_list.append(cache_root / "tests" / f"Test{node_type_name}.py")
if ogi.FileType.USD not in (exclusions or []):
file_list.append(cache_root / "tests" / "usd" / f"{node_type_name}Template.usda")
return file_list
# ==============================================================================================================
def _expected_1_18_module_files(
module_root: Path, node_type_name: str, exclusions: list[ogi.FileType] = None
) -> list[Path]:
"""Returns a list of the files that should be in a standard V1.18 generated module directory for one node type"""
file_list = [
module_root / "__init__.py",
module_root / "ogn" / "nodes" / f"{node_type_name}.ogn",
module_root / "ogn" / "nodes" / f"{node_type_name}.py",
module_root / "ogn" / f"{node_type_name}Database.py",
]
if ogi.FileType.TEST not in (exclusions or []):
file_list.append(module_root / "ogn" / "tests" / "__init__.py")
file_list.append(module_root / "ogn" / "tests" / f"Test{node_type_name}.py")
if ogi.FileType.USD not in (exclusions or []):
file_list.append(module_root / "ogn" / "tests" / "usd" / f"{node_type_name}Template.usda")
return file_list
# ==============================================================================================================
def _expected_standalone_module_files(module_root: Path, node_type_name: str) -> list[Path]:
"""Returns a list of the files that should be in a non-generated module directory for one node type"""
return [
module_root / "__init__.py",
module_root / "nodes" / f"{node_type_name}.ogn",
module_root / "nodes" / f"{node_type_name}.py",
]
# ==============================================================================================================
class TestInternalRegistration(ogts.OmniGraphTestCase):
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
self.maxDiff = None # Diffs of file path lists can be large so let the full details be seen
# --------------------------------------------------------------------------------------------------------------
async def _test_extension_modules(self, import_ogn: bool, import_ogn_tests: bool, generate_tests: bool):
"""Metatest that the utility to create a test extension creates the proper imports for a single configuration
Args:
import_ogn: Add the ogn submodule to the extension.toml python module list
import_ogn: Add the ogn.tests submodule to the extension.toml python module list
generate_tests: Generate/initialize test files for the node type generated code
"""
with ExitStack() as stack:
ctx = ModuleContexts(stack)
self.assertTrue(str(ctx.python_root / ctx.ext_name) in sys.path)
ext_contents = _TestExtensionManager(
ctx.python_root,
ctx.ext_name,
_CURRENT_VERSIONS,
import_ogn=import_ogn,
import_ogn_tests=import_ogn_tests,
)
exclusions = [] if generate_tests else [ogi.FileType.TEST]
exclusions += [ogi.FileType.USD, ogi.FileType.DOCS]
ext_contents.add_v1_18_node("OgnTestNode", exclusions)
expected_files = [
ctx.python_root / ctx.ext_name / "config" / "extension.toml",
]
expected_files += _expected_1_18_module_files(ctx.module_path, "OgnTestNode", exclusions)
actual_files = []
for root, _dirs, files in ogi.walk_with_excludes(ctx.test_directory, ["__pycache__"]):
for file in files:
actual_files.append(Path(root) / file)
self.assertCountEqual(expected_files, actual_files, "Created extension contents")
ext_ogn_mgr = extension_management_factory(ctx.ext_id, ctx.ext_name, ctx.python_root / ctx.ext_name)
self.assertIsNotNone(ext_ogn_mgr)
ext_ogn_mgr.scan_for_nodes()
ext_ogn_mgr.ensure_files_up_to_date()
(ogn_module, ogn_test_module) = ext_ogn_mgr.ensure_required_modules_exist()
self.assertIsNotNone(ogn_module)
if generate_tests:
self.assertIsNotNone(ogn_test_module)
else:
self.assertIsNone(ogn_test_module)
# --------------------------------------------------------------------------------------------------------------
async def test_extension_modules(self):
"""Metatest that the utility to create a test extension creates the proper modules for all configurations"""
for test_configuration in [0b000, 0b100, 0b110, 0b001, 0b101, 0b111]:
import_ogn = test_configuration & 0b100 != 0
import_ogn_tests = test_configuration & 0b010 != 0
generate_tests = test_configuration & 0b001 != 0
with self.subTest(import_ogn=import_ogn, import_ogn_tests=import_ogn_tests, generate_tests=generate_tests):
await self._test_extension_modules(
import_ogn=import_ogn, import_ogn_tests=import_ogn_tests, generate_tests=generate_tests
)
# --------------------------------------------------------------------------------------------------------------
async def _test_extension_imports(self, import_ogn: bool, import_ogn_tests: bool, generate_tests: bool):
"""Metatest that the utility to create a test extension creates the proper imports for a single configuration
Args:
import_ogn: Add the ogn submodule to the extension.toml python module list
import_ogn: Add the ogn.tests submodule to the extension.toml python module list
generate_tests: Generate/initialize test files for the node type generated code
"""
test_config = f"import_ogn={import_ogn}, import_ogn_tests={import_ogn_tests}"
with ExitStack() as stack:
ctx = ModuleContexts(stack)
self.assertTrue(str(ctx.python_root / ctx.ext_name) in sys.path)
ext_contents = _TestExtensionManager(
ctx.python_root,
ctx.ext_name,
_CURRENT_VERSIONS,
import_ogn=import_ogn,
import_ogn_tests=import_ogn_tests,
)
exclusions = [] if generate_tests else [ogi.FileType.TEST]
exclusions += [ogi.FileType.USD, ogi.FileType.DOCS]
ext_contents.add_v1_18_node("OgnTestNode", exclusions)
expected_files = [
ctx.python_root / ctx.ext_name / "config" / "extension.toml",
]
expected_files += _expected_1_18_module_files(ctx.module_path, "OgnTestNode", exclusions)
actual_files = []
for root, _dirs, files in ogi.walk_with_excludes(ctx.test_directory, ["__pycache__"]):
for file in files:
actual_files.append(Path(root) / file)
self.assertCountEqual(expected_files, actual_files, f"Created extension contents using {test_config}")
ext_ogn_mgr = extension_management_factory(ctx.ext_id, ctx.ext_name, ctx.python_root / ctx.ext_name)
self.assertIsNotNone(ext_ogn_mgr, test_config)
ext_ogn_mgr.scan_for_nodes()
ext_ogn_mgr.ensure_files_up_to_date()
# Ensure that the OGN submodules could be found in the newly created extension
(ogn_module, ogn_test_module) = ext_ogn_mgr.ensure_required_modules_exist()
self.assertIsNotNone(ogn_module, test_config)
self.assertTrue(not generate_tests or ogn_test_module is not None, test_config)
(ogn_module, ogn_test_module) = ext_ogn_mgr.do_python_imports()
# Do it twice because the second time it should just pick it up from sys.modules
(ogn_module_2, ogn_test_module_2) = ext_ogn_mgr.do_python_imports()
self.assertEqual(ogn_module, ogn_module_2, test_config)
self.assertEqual(ogn_test_module, ogn_test_module_2, test_config)
# Check the contents of the ogn submodule to make sure the node class and database were imported
self.assertIsNotNone(ogn_module, test_config)
self.assertTrue(hasattr(ogn_module, ext_ogn_mgr.NODE_STORAGE_OBJECT), test_config)
self.assertTrue(getattr(ogn_module, ext_ogn_mgr.NODE_STORAGE_OBJECT), test_config)
self.assertTrue(hasattr(ogn_module, "OgnTestNodeDatabase"), test_config)
ogn_module_file_path = ogi.get_module_path(ogn_module)
self.assertIsNotNone(ogn_module_file_path, test_config)
self.assertTrue(ctx.module_path in ogn_module_file_path.parents, test_config)
# If tests were requested then confirm the generated tests was imported into the ogn.tests submodule
if generate_tests:
self.assertIsNotNone(ogn_test_module, test_config)
self.assertTrue(hasattr(ogn_test_module, "TestOgnTestNode"), test_config)
ogn_test_module_file_path = ogi.get_module_path(ogn_test_module)
self.assertIsNotNone(ogn_test_module_file_path, test_config)
self.assertTrue(ctx.module_path in ogn_test_module_file_path.parents, test_config)
else:
self.assertIsNone(ogn_test_module, test_config)
# --------------------------------------------------------------------------------------------------------------
async def test_extension_imports(self):
"""Metatest that the utility to create a test extension imports the proper modules for all configurations"""
for test_configuration in [0b000, 0b100, 0b110, 0b001, 0b101, 0b111]:
import_ogn = test_configuration & 0b100 != 0
import_ogn_tests = test_configuration & 0b010 != 0
generate_tests = test_configuration & 0b001 != 0
with self.subTest(import_ogn=import_ogn, import_ogn_tests=import_ogn_tests, generate_tests=generate_tests):
await self._test_extension_imports(
import_ogn=import_ogn, import_ogn_tests=import_ogn_tests, generate_tests=generate_tests
)
# --------------------------------------------------------------------------------------------------------------
async def _test_extension_cached_imports(
self,
import_ogn: bool,
import_ogn_tests: bool,
generate_tests: bool,
use_prebuilt_cache: bool,
):
"""Metatest that the utility to create a test extension creates the proper imports for a single configuration
Args:
import_ogn: Add the ogn submodule to the extension.toml python module list
import_ogn: Add the ogn.tests submodule to the extension.toml python module list
generate_tests: Generate/initialize test files for the node type generated code
use_prebuilt_cache: If True then prebuild the up-to-date cache files, otherwise generate old ones to ignore
"""
# ogi.set_registration_logging("stdout") # Uncomment for test debugging information
test_config = (
f"import_ogn={import_ogn}, import_ogn_tests={import_ogn_tests}, "
f"tests={generate_tests}, prebuilt={use_prebuilt_cache}"
)
with ExitStack() as stack:
ctx = ModuleContexts(stack)
self.assertTrue(str(ctx.python_root / ctx.ext_name) in sys.path, test_config)
# Create an old cache to make sure it gets ignored as well
exclusions = [] if generate_tests else [ogi.FileType.TEST]
exclusions += [ogi.FileType.USD, ogi.FileType.DOCS]
ext_contents_incompatible = _TestExtensionManager(
ctx.python_root,
ctx.ext_name,
ogi.GenerationVersions(ogi.Compatibility.Incompatible),
import_ogn=import_ogn,
import_ogn_tests=import_ogn_tests,
)
ext_contents_incompatible.add_v1_18_node("OgnTestNode", exclusions)
compatibility = ogi.Compatibility.FullyCompatible if use_prebuilt_cache else ogi.Compatibility.Incompatible
cache_versions = ogi.GenerationVersions(compatibility)
current_cache_directory = ogi.full_cache_path(cache_versions, ctx.ext_id, ctx.module_name)
ext_contents = _TestExtensionManager(
ctx.python_root,
ctx.ext_name,
cache_versions,
import_ogn=import_ogn,
import_ogn_tests=import_ogn_tests,
)
ext_contents.add_cache_for_node("OgnTestNode", exclusions)
cached_files = _expected_cache_contents(current_cache_directory, "OgnTestNode", exclusions)
# If using the obsolete cache then add in the ones that will be built when the generator runs
if not use_prebuilt_cache:
current_cache_directory = ogi.full_cache_path(_CURRENT_VERSIONS, ctx.ext_id, ctx.module_name)
cached_files += _expected_cache_contents(current_cache_directory, "OgnTestNode", exclusions)
expected_files = [
ctx.python_root / ctx.ext_name / "config" / "extension.toml", # Not in the cache
]
expected_files += _expected_1_18_module_files(ctx.module_path, "OgnTestNode", exclusions)
expected_files += cached_files
ext_ogn_mgr = extension_management_factory(ctx.ext_id, ctx.ext_name, ctx.python_root / ctx.ext_name)
self.assertIsNotNone(ext_ogn_mgr, test_config)
ext_ogn_mgr.scan_for_nodes()
ext_ogn_mgr.ensure_files_up_to_date()
actual_files = []
for root, _dirs, files in ogi.walk_with_excludes(ctx.test_directory, ["__pycache__"]):
for file in files:
actual_files.append(Path(root) / file)
self.assertCountEqual(expected_files, actual_files, f"Created extension contents with {test_config}")
# Ensure that the OGN submodules could be found in the newly created extension
(ogn_module, ogn_test_module) = ext_ogn_mgr.do_python_imports()
# Do it twice because the second time it should just pick it up from sys.modules
(ogn_module_2, ogn_test_module_2) = ext_ogn_mgr.do_python_imports()
self.assertEqual(ogn_module, ogn_module_2, test_config)
self.assertEqual(ogn_test_module, ogn_test_module_2, test_config)
# Check the contents of the ogn submodule to make sure the node class and database were imported
self.assertIsNotNone(ogn_module, test_config)
self.assertTrue(hasattr(ogn_module, ext_ogn_mgr.NODE_STORAGE_OBJECT), test_config)
self.assertTrue(getattr(ogn_module, ext_ogn_mgr.NODE_STORAGE_OBJECT), test_config)
self.assertTrue(hasattr(ogn_module, "OgnTestNodeDatabase"), test_config)
ogn_module_file_path = ogi.get_module_path(ogn_module.OgnTestNodeDatabase)
self.assertIsNotNone(ogn_module_file_path, test_config)
self.assertTrue(
current_cache_directory in ogn_module_file_path.parents,
f"Cache {current_cache_directory} not in {ogn_module_file_path} - {test_config}",
)
# If tests were requested then confirm the generated tests was imported into the ogn.tests submodule
if generate_tests:
self.assertIsNotNone(ogn_test_module, test_config)
self.assertTrue(hasattr(ogn_test_module, "TestOgnTestNode"), test_config)
ogn_test_module_file_path = ogi.get_module_path(ogn_test_module)
self.assertIsNotNone(ogn_test_module_file_path, test_config)
self.assertTrue(
current_cache_directory in ogn_module_file_path.parents,
f"Cache {current_cache_directory} not in {ogn_module_file_path} - {test_config}",
)
else:
self.assertIsNone(ogn_test_module, test_config)
# --------------------------------------------------------------------------------------------------------------
async def test_extension_cached_imports_ffff(self):
"""Metatest that the utility to create a test extension that requires building a cache imports the proper
modules for all configurations from that cache. These all have to run as separate tests in order to
avoid stomping on each other's import spaces and cache directories.
"""
await self._test_extension_cached_imports(False, False, False, False)
async def test_extension_cached_imports_tfff(self):
await self._test_extension_cached_imports(True, False, False, False)
async def test_extension_cached_imports_ttff(self):
await self._test_extension_cached_imports(True, True, False, False)
async def test_extension_cached_imports_fftf(self):
await self._test_extension_cached_imports(False, False, True, False)
async def test_extension_cached_imports_tftf(self):
await self._test_extension_cached_imports(True, False, True, False)
async def test_extension_cached_imports_tttf(self):
await self._test_extension_cached_imports(True, True, True, False)
async def test_extension_cached_imports_ffft(self):
await self._test_extension_cached_imports(False, False, False, True)
async def test_extension_cached_imports_tfft(self):
await self._test_extension_cached_imports(True, False, False, True)
async def test_extension_cached_imports_ttft(self):
await self._test_extension_cached_imports(True, True, False, True)
async def test_extension_cached_imports_fftt(self):
await self._test_extension_cached_imports(False, False, True, True)
async def test_extension_cached_imports_tftt(self):
await self._test_extension_cached_imports(True, False, True, True)
async def test_extension_cached_imports_tttt(self):
await self._test_extension_cached_imports(True, True, True, True)
# --------------------------------------------------------------------------------------------------------------
def __confirm_module_contents(self, expected_modules_and_contents: list[tuple[str, str]]):
"""Asserts if the module does not contain at least all of the expected symbols.
Args:
expected_modules_and_contents: List of (MODULE_NAME, EXPECTED_SYMBOLS) to verify
"""
for expected_name, symbols in expected_modules_and_contents:
self.assertTrue(expected_name in sys.modules, f"Looking for module {expected_name}")
actual_contents = dir(sys.modules[expected_name])
for expected_symbol in symbols:
self.assertTrue(
expected_symbol in actual_contents, f"Looking for symbol {expected_symbol} in {expected_name}"
)
# --------------------------------------------------------------------------------------------------------------
async def test_raw_extension_creation(self):
"""Metatest that the utility to create a test extension using the generated files and successfully load a
file of the generated type into a scene.
"""
with ExitStack() as stack:
ctx = ModuleContexts(stack)
self.assertTrue(str(ctx.python_root / ctx.ext_name) in sys.path)
ext_contents = _TestExtensionManager(
ctx.python_root,
ctx.ext_name,
_CURRENT_VERSIONS,
import_ogn=False,
import_ogn_tests=False,
)
ext_contents.add_v1_18_node("OgnTestNode")
ext_ogn_mgr = extension_management_factory(ctx.ext_id, ctx.ext_name, ctx.python_root / ctx.ext_name)
self.assertIsNotNone(ext_ogn_mgr)
ext_ogn_mgr.scan_for_nodes()
ext_ogn_mgr.ensure_files_up_to_date()
(ogn_module, ogn_test_module) = ext_ogn_mgr.do_python_imports()
self.assertIsNotNone(ogn_module)
self.assertIsNotNone(ogn_test_module)
ext_ogn_mgr.do_registration()
# Enable the extension inside Kit
await ext_contents.enable()
# Confirm that the test node type now exists and can be instantiated
(_, (test_node,), _, _) = og.Controller.edit(
"/TestGraph", {og.Controller.Keys.CREATE_NODES: [("TestNode", f"{ctx.ext_name}.OgnTestNode")]}
)
self.assertIsNotNone(test_node)
self.assertTrue(test_node.is_valid())
# Confirm that the modules were correctly created
expected_modules_and_contents = [
(ctx.ext_name, ["_PublicExtension"]),
(f"{ctx.ext_name}.ogn", ["OgnTestNodeDatabase"]),
(f"{ctx.ext_name}.ogn.OgnTestNodeDatabase", ["OgnTestNodeDatabase"]),
(f"{ctx.ext_name}.ogn.nodes.OgnTestNode", ["OgnTestNode"]),
(f"{ctx.ext_name}.ogn.tests", ["TestOgnTestNode"]),
(f"{ctx.ext_name}.ogn.tests.TestOgnTestNode", ["TestOgn"]),
]
self.__confirm_module_contents(expected_modules_and_contents)
# Clear the scene and disable the extension
await omni.usd.get_context().new_stage_async()
await ext_contents.disable()
# Confirm that the test node type no longer exists
with self.assertRaises(og.OmniGraphError):
(_, (test_node,), _, _) = og.Controller.edit(
"/TestGraph", {og.Controller.Keys.CREATE_NODES: [("TestNode", f"{ctx.ext_name}.OgnTestNode")]}
)
# --------------------------------------------------------------------------------------------------------------
async def test_cache_generation(self):
"""Test that an extension with no prebuilt files registers and is seen correctly.
This entails enabling the test extension and then looking at the modules to ensure that:
- the database exists and can be imported
- the node type was correctly registered
- the generated test was correctly registered
- the database, node type, and generated test are removed when the extension is disabled
"""
with ExitStack() as stack:
ctx = ModuleContexts(stack)
cache_directory = ogi.full_cache_path(_CURRENT_VERSIONS, ctx.ext_id, ctx.module_name)
ext_contents = _TestExtensionManager(
ctx.python_root,
ctx.ext_name,
ogi.GenerationVersions(),
import_ogn=False,
import_ogn_tests=False,
)
ext_contents.add_standalone_node("OgnTestNode")
expected_cache_files = _expected_cache_contents(cache_directory, "OgnTestNode")
expected_files = [
ctx.python_root / ctx.ext_name / "config" / "extension.toml",
]
expected_files += _expected_standalone_module_files(ctx.module_path, "OgnTestNode")
expected_files += expected_cache_files
# Register the extension and enable it
try:
await ext_contents.enable()
actual_files = []
for root, _dirs, files in ogi.walk_with_excludes(ctx.test_directory, ["__pycache__"]):
for file in files:
actual_files.append(Path(root) / file)
self.assertCountEqual(expected_files, actual_files, "Rebuilt cached extension")
# Confirm that the test node type now exists and can be instantiated
key_create = og.Controller.Keys.CREATE_NODES
(_, (test_node,), _, _) = og.Controller.edit(
"/TestGraph", {key_create: [("TestNode", f"{ctx.ext_name}.OgnTestNode")]}
)
self.assertIsNotNone(test_node)
self.assertTrue(test_node.is_valid())
# Confirm that the modules were correctly created
expected_modules_and_contents = [
(ctx.ext_name, ["_PublicExtension"]),
(f"{ctx.ext_name}.nodes.OgnTestNode", ["OgnTestNode"]),
(f"{ctx.ext_name}.ogn", ["OgnTestNodeDatabase"]),
(f"{ctx.ext_name}.ogn.OgnTestNodeDatabase", ["OgnTestNodeDatabase"]),
(f"{ctx.ext_name}.ogn.tests", ["TestOgnTestNode"]),
(f"{ctx.ext_name}.ogn.tests.TestOgnTestNode", ["TestOgn"]),
]
self.__confirm_module_contents(expected_modules_and_contents)
# Double check the imported database file to make sure it is using the cached one
db_object = getattr(sys.modules[f"{ctx.ext_name}.ogn.OgnTestNodeDatabase"], "OgnTestNodeDatabase", None)
self.assertIsNotNone(db_object, "Could not get the database from the extension imports")
generator_version = getattr(db_object, ogi.VersionProperties.GENERATOR.value, None)
self.assertEqual(generator_version, ogi.get_generator_extension_version())
target_version = getattr(db_object, ogi.VersionProperties.TARGET.value, None)
self.assertEqual(target_version, ogi.get_target_extension_version())
ogn_module_file_path = ogi.get_module_path(sys.modules[f"{ctx.ext_name}.ogn"])
self.assertIsNotNone(ogn_module_file_path)
self.assertTrue(cache_directory in ogn_module_file_path.parents)
# Clear the scene and disable the extension
await omni.usd.get_context().new_stage_async()
finally:
await ext_contents.disable()
# Confirm that the test node type no longer exists
with self.assertRaises(og.OmniGraphError):
(_, (test_node,), _, _) = og.Controller.edit(
"/TestGraph", {key_create: [("TestNode", f"{ctx.ext_name}.OgnTestNode")]}
)
# --------------------------------------------------------------------------------------------------------------
async def test_cache_generation_from_old_build(self):
"""Test that an extension with prebuilt files that are out of date registers and is seen correctly.
This entails enabling the test extension and then looking at the modules to ensure that:
- the database exists and can be imported
- the node type was correctly registered
- the generated test was correctly registered
- the database, node type, and generated test are removed when the extension is disabled
"""
with ExitStack() as stack:
ctx = ModuleContexts(stack)
cache_directory = ogi.full_cache_path(_CURRENT_VERSIONS, ctx.ext_id, ctx.module_name)
ext_contents = _TestExtensionManager(
ctx.python_root,
ctx.ext_name,
ogi.GenerationVersions(ogi.Compatibility.Incompatible),
import_ogn=False,
import_ogn_tests=False,
)
ext_contents.add_v1_18_node("OgnTestNode")
expected_files = [
ctx.python_root / ctx.ext_name / "config" / "extension.toml",
]
expected_files += _expected_cache_contents(cache_directory, "OgnTestNode")
expected_files += _expected_1_18_module_files(ctx.module_path, "OgnTestNode")
# Register the extension and enable it
try:
await ext_contents.enable()
actual_files = []
for root, _dirs, files in ogi.walk_with_excludes(ctx.test_directory, ["__pycache__"]):
for file in files:
actual_files.append(Path(root) / file)
self.assertCountEqual(expected_files, actual_files, "Rebuilt cached extension")
# Confirm that the test node type now exists and can be instantiated
key_create = og.Controller.Keys.CREATE_NODES
(_, (test_node,), _, _) = og.Controller.edit(
"/TestGraph", {key_create: [("TestNode", f"{ctx.ext_name}.OgnTestNode")]}
)
self.assertIsNotNone(test_node)
self.assertTrue(test_node.is_valid())
# Confirm that the modules were correctly created
expected_modules_and_contents = [
(ctx.ext_name, ["_PublicExtension"]),
(f"{ctx.ext_name}.ogn", ["OgnTestNodeDatabase"]),
(f"{ctx.ext_name}.ogn.nodes.OgnTestNode", ["OgnTestNode"]),
(f"{ctx.ext_name}.ogn.OgnTestNodeDatabase", ["OgnTestNodeDatabase"]),
(f"{ctx.ext_name}.ogn.tests", ["TestOgnTestNode"]),
(f"{ctx.ext_name}.ogn.tests.TestOgnTestNode", ["TestOgn"]),
]
self.__confirm_module_contents(expected_modules_and_contents)
# Double check the version number in the imported database file to make sure it is using the cached one
db_module = sys.modules[f"{ctx.ext_name}.ogn.OgnTestNodeDatabase"]
db_object = getattr(db_module, "OgnTestNodeDatabase", None)
self.assertIsNotNone(db_object, "Could not get the database from the extension imports")
generator_version = getattr(db_object, ogi.VersionProperties.GENERATOR.value, None)
self.assertEqual(generator_version, ogi.get_generator_extension_version())
target_version = getattr(db_object, ogi.VersionProperties.TARGET.value, None)
self.assertEqual(target_version, ogi.get_target_extension_version())
db_module_path = ogi.get_module_path(db_module)
self.assertIsNotNone(db_module_path)
self.assertTrue(cache_directory in db_module_path.parents)
# Clear the scene and disable the extension
await omni.usd.get_context().new_stage_async()
finally:
await ext_contents.disable()
# Confirm that the test node type no longer exists
with self.assertRaises(og.OmniGraphError):
(_, (test_node,), _, _) = og.Controller.edit(
"/TestGraph", {key_create: [("TestNode", f"{ctx.ext_name}.OgnTestNode")]}
)
# --------------------------------------------------------------------------------------------------------------
async def test_cache_update(self):
"""Test that an extension with prebuilt files that are from a compatible version but whose .ogn files are
out of date correctly notices and rebuilds cached files and registers them correctly.
This entails enabling the test extension and then looking at the modules to ensure that:
- the database exists and can be imported
- the node type was correctly registered
- the generated test was correctly registered
- the database, node type, and generated test are removed when the extension is disabled
"""
with ExitStack() as stack:
ctx = ModuleContexts(stack)
incompatible = ogi.GenerationVersions(ogi.Compatibility.Incompatible)
cache_directory = ogi.full_cache_path(_CURRENT_VERSIONS, ctx.ext_id, ctx.module_name)
old_cache_directory = ogi.full_cache_path(incompatible, ctx.ext_id, ctx.module_name)
ext_contents = _TestExtensionManager(
ctx.python_root,
ctx.ext_name,
_CURRENT_VERSIONS,
import_ogn=False,
import_ogn_tests=False,
)
ext_contents.add_v1_18_node("OgnTestNode")
ext_contents_incompatible = _TestExtensionManager(
ctx.python_root,
ctx.ext_name,
incompatible,
import_ogn=False,
import_ogn_tests=False,
)
ext_contents_incompatible.add_cache_for_node("OgnTestNode")
expected_files = [
ctx.python_root / ctx.ext_name / "config" / "extension.toml",
]
expected_files += _expected_cache_contents(old_cache_directory, "OgnTestNode")
expected_files += _expected_1_18_module_files(ctx.module_path, "OgnTestNode")
actual_files = []
for root, _dirs, files in ogi.walk_with_excludes(ctx.test_directory, ["__pycache__"]):
for file in files:
actual_files.append(Path(root) / file)
self.assertCountEqual(expected_files, actual_files, "Rebuilt cached extension")
ogn_file = ctx.module_path / "ogn" / "nodes" / "OgnTestNode.ogn"
ogn_file.touch()
# Files that will be built when the cache updates after registration
expected_cache_files = _expected_cache_contents(cache_directory, "OgnTestNode")
# Register the extension and enable it
try:
await ext_contents.enable()
actual_files = []
for root, _dirs, files in ogi.walk_with_excludes(ctx.test_directory, ["__pycache__"]):
for file in files:
actual_files.append(Path(root) / file)
self.assertCountEqual(expected_files + expected_cache_files, actual_files, "Rebuilt cached extension")
# Confirm that the test node type now exists and can be instantiated
key_create = og.Controller.Keys.CREATE_NODES
(_, (test_node,), _, _) = og.Controller.edit(
"/TestGraph", {key_create: [("TestNode", f"{ctx.ext_name}.OgnTestNode")]}
)
self.assertIsNotNone(test_node)
self.assertTrue(test_node.is_valid())
# Confirm that the modules were correctly created
expected_modules_and_contents = [
(ctx.ext_name, ["_PublicExtension"]),
(f"{ctx.ext_name}.ogn", ["OgnTestNodeDatabase"]),
(f"{ctx.ext_name}.ogn.nodes.OgnTestNode", ["OgnTestNode"]),
(f"{ctx.ext_name}.ogn.OgnTestNodeDatabase", ["OgnTestNodeDatabase"]),
(f"{ctx.ext_name}.ogn.tests", ["TestOgnTestNode"]),
(f"{ctx.ext_name}.ogn.tests.TestOgnTestNode", ["TestOgn"]),
]
self.__confirm_module_contents(expected_modules_and_contents)
# Double check the version number in the imported database file to make sure it is using the cached one
db_module = sys.modules[f"{ctx.ext_name}.ogn.OgnTestNodeDatabase"]
db_object = getattr(db_module, "OgnTestNodeDatabase", None)
self.assertIsNotNone(db_object, "Could not get the database from the extension imports")
generator_version = getattr(db_object, ogi.VersionProperties.GENERATOR.value, None)
self.assertEqual(generator_version, ogi.get_generator_extension_version())
target_version = getattr(db_object, ogi.VersionProperties.TARGET.value, None)
self.assertEqual(target_version, ogi.get_target_extension_version())
db_module_path = ogi.get_module_path(db_module)
self.assertIsNotNone(db_module_path)
self.assertTrue(cache_directory in db_module_path.parents)
# Double check the path to the registered test to make sure it is using the newly generated cache
test_module = sys.modules[f"{ctx.ext_name}.ogn.tests.TestOgnTestNode"]
test_module_path = ogi.get_module_path(test_module)
self.assertIsNotNone(test_module_path)
self.assertTrue(cache_directory in test_module_path.parents)
# Clear the scene and disable the extension
await omni.usd.get_context().new_stage_async()
finally:
await ext_contents.disable()
# Confirm that the test node type no longer exists
with self.assertRaises(og.OmniGraphError):
(_, (test_node,), _, _) = og.Controller.edit(
"/TestGraph", {key_create: [("TestNode", f"{ctx.ext_name}.OgnTestNode")]}
)
# --------------------------------------------------------------------------------------------------------------
async def test_hot_reload(self):
"""Test that an extension cache is correctly generated when loading, then regenerated after a .ogn change.
The .ogn change is such that it can be checked at runtime (adding an attribute).
"""
with ExitStack() as stack:
ctx = ModuleContexts(stack)
cache_directory = ogi.full_cache_path(_CURRENT_VERSIONS, ctx.ext_id, ctx.module_name)
ext_contents = _TestExtensionManager(
ctx.python_root,
ctx.ext_name,
ogi.GenerationVersions(ogi.Compatibility.Incompatible),
import_ogn=False,
import_ogn_tests=False,
)
ext_contents.add_v1_18_node("OgnTestNode")
expected_files = [
ctx.python_root / ctx.ext_name / "config" / "extension.toml",
]
expected_files += _expected_cache_contents(cache_directory, "OgnTestNode")
expected_files += _expected_1_18_module_files(ctx.module_path, "OgnTestNode")
# Register the extension and enable it
try:
await ext_contents.enable()
actual_files = []
for root, _dirs, files in ogi.walk_with_excludes(ctx.test_directory, ["__pycache__"]):
for file in files:
actual_files.append(Path(root) / file)
self.assertCountEqual(expected_files, actual_files, "Rebuilt cached extension")
# Confirm that the test node type now exists and can be instantiated
key_create = og.Controller.Keys.CREATE_NODES
(_, (test_node,), _, _) = og.Controller.edit(
"/TestGraph", {key_create: [("TestNode", f"{ctx.ext_name}.OgnTestNode")]}
)
await og.Controller.evaluate()
self.assertIsNotNone(test_node)
self.assertTrue(test_node.is_valid())
# Modify the .ogn to add in a new attribute, then wait for the scene to reattach
await ext_contents.add_hot_attribute_to_ogn()
# This syncs are to wait for the hot reload to happen
await omni.kit.app.get_app().next_update_async()
await omni.kit.app.get_app().next_update_async()
actual_files = []
for root, _dirs, files in ogi.walk_with_excludes(ctx.test_directory, ["__pycache__"]):
for file in files:
actual_files.append(Path(root) / file)
self.assertCountEqual(expected_files, actual_files, "After hot reload")
# Rebuild the scene. This is necessary because the scene reattach process does not currently update any
# modified nodes with their new attributes so the only way to test this is to create a new node and
# check that it picks up the new definition.
await omni.usd.get_context().new_stage_async()
(_, (test_node,), _, _) = og.Controller.edit(
"/TestGraph", {key_create: [("TestNode", f"{ctx.ext_name}.OgnTestNode")]}
)
await og.Controller.evaluate()
self.assertIsNotNone(test_node)
self.assertTrue(test_node.is_valid())
# Confirm that the hot-reloading attribute now exists
hot_attribute = og.Controller.attribute("inputs:hot", test_node)
self.assertIsNotNone(hot_attribute)
self.assertTrue(hot_attribute.is_valid())
# Confirm that the modules were correctly created
expected_modules_and_contents = [
(ctx.ext_name, ["_PublicExtension"]),
(f"{ctx.ext_name}.ogn", ["OgnTestNodeDatabase"]),
(f"{ctx.ext_name}.ogn.nodes.OgnTestNode", ["OgnTestNode"]),
(f"{ctx.ext_name}.ogn.OgnTestNodeDatabase", ["OgnTestNodeDatabase"]),
(f"{ctx.ext_name}.ogn.tests", ["TestOgnTestNode"]),
(f"{ctx.ext_name}.ogn.tests.TestOgnTestNode", ["TestOgn"]),
]
self.__confirm_module_contents(expected_modules_and_contents)
# Double check the imported database file to make sure it is using the cached one
db_object = getattr(sys.modules[f"{ctx.ext_name}.ogn.OgnTestNodeDatabase"], "OgnTestNodeDatabase", None)
self.assertIsNotNone(db_object, "Could not get the database from the extension imports")
generator_version = getattr(db_object, ogi.VersionProperties.GENERATOR.value, None)
self.assertEqual(generator_version, ogi.get_generator_extension_version())
target_version = getattr(db_object, ogi.VersionProperties.TARGET.value, None)
self.assertEqual(target_version, ogi.get_target_extension_version())
db_file_path = ogi.get_module_path(sys.modules[f"{ctx.ext_name}.ogn.OgnTestNodeDatabase"])
self.assertIsNotNone(db_file_path)
self.assertTrue(
cache_directory in db_file_path.parents,
f"Expected {cache_directory} to be a parent of {db_file_path}",
)
# Clear the scene and disable the extension
await omni.usd.get_context().new_stage_async()
finally:
await ext_contents.disable()
# Confirm that the test node type no longer exists
with self.assertRaises(og.OmniGraphError):
(_, (test_node,), _, _) = og.Controller.edit(
"/TestGraph", {key_create: [("TestNode", f"{ctx.ext_name}.OgnTestNode")]}
)
# --------------------------------------------------------------------------------------------------------------
async def test_multiple_nodes(self):
"""Test that a built extension with more than one node correctly imports all of them"""
with ExitStack() as stack:
ctx = ModuleContexts(stack)
cache_directory = ogi.full_cache_path(_CURRENT_VERSIONS, ctx.ext_id, ctx.module_name)
ext_contents = _TestExtensionManager(
ctx.python_root,
ctx.ext_name,
_CURRENT_VERSIONS,
import_ogn=False,
import_ogn_tests=False,
)
ext_contents.add_v1_18_node("OgnTestNode")
ext_contents.add_v1_18_node("OgnGoodTestNode")
expected_files = [
ctx.python_root / ctx.ext_name / "config" / "extension.toml",
]
expected_files += _expected_1_18_module_files(ctx.module_path, "OgnTestNode")
expected_files += _expected_1_18_module_files(ctx.module_path, "OgnGoodTestNode")
expected_files += _expected_cache_contents(cache_directory, "OgnTestNode")
expected_files = list(set(expected_files))
# Touch the .ogn file to make it out of date
outdated_ogn = ctx.module_path / "ogn" / "nodes" / "OgnTestNode.ogn"
outdated_ogn.touch()
# Register the extension and enable it
try:
await ext_contents.enable()
actual_files = []
for root, _dirs, files in ogi.walk_with_excludes(ctx.test_directory, ["__pycache__"]):
for file in files:
actual_files.append(Path(root) / file)
self.assertCountEqual(expected_files, actual_files, "Rebuilt cached extension")
# Confirm that the test node type now exists and can be instantiated
key_create = og.Controller.Keys.CREATE_NODES
(_, (test_node, test_good_node), _, _) = og.Controller.edit(
"/TestGraph",
{
key_create: [
("TestNode", f"{ctx.ext_name}.OgnTestNode"),
("GoodTestNode", f"{ctx.ext_name}.OgnGoodTestNode"),
]
},
)
self.assertIsNotNone(test_node)
self.assertTrue(test_node.is_valid())
self.assertIsNotNone(test_good_node)
self.assertTrue(test_good_node.is_valid())
# Confirm that the modules were correctly created
expected_modules_and_contents = [
(ctx.ext_name, ["_PublicExtension"]),
(f"{ctx.ext_name}.ogn", ["OgnTestNodeDatabase"]),
(f"{ctx.ext_name}.ogn.nodes.OgnTestNode", ["OgnTestNode"]),
(f"{ctx.ext_name}.ogn.OgnTestNodeDatabase", ["OgnTestNodeDatabase"]),
(f"{ctx.ext_name}.ogn.tests", ["TestOgnTestNode"]),
(f"{ctx.ext_name}.ogn.tests.TestOgnTestNode", ["TestOgn"]),
(f"{ctx.ext_name}.ogn.OgnGoodTestNodeDatabase", ["OgnGoodTestNodeDatabase"]),
(f"{ctx.ext_name}.ogn.tests", ["TestOgnGoodTestNode"]),
(f"{ctx.ext_name}.ogn.tests.TestOgnGoodTestNode", ["TestOgn"]),
]
self.__confirm_module_contents(expected_modules_and_contents)
# Double check the version number in the imported database file to make sure it is using the cached one
db_module = sys.modules[f"{ctx.ext_name}.ogn.OgnTestNodeDatabase"]
db_object = getattr(db_module, "OgnTestNodeDatabase", None)
self.assertIsNotNone(db_object, "Could not get the cached database from the extension imports")
generator_version = getattr(db_object, ogi.VersionProperties.GENERATOR.value, None)
self.assertEqual(generator_version, ogi.get_generator_extension_version())
target_version = getattr(db_object, ogi.VersionProperties.TARGET.value, None)
self.assertEqual(target_version, ogi.get_target_extension_version())
db_module_path = ogi.get_module_path(db_module)
self.assertIsNotNone(db_module_path)
self.assertTrue(cache_directory in db_module_path.parents)
test_module = sys.modules[f"{ctx.ext_name}.ogn.tests.TestOgnTestNode"]
test_object = getattr(test_module, "TestOgn", None)
self.assertIsNotNone(test_object, "Could not get the cached test from the extension imports")
test_module_path = ogi.get_module_path(test_module)
self.assertIsNotNone(test_module_path)
self.assertTrue(cache_directory in test_module_path.parents)
# Check that the node that did not have to be rebuilt imports from the build directory, not the cache
db_module = sys.modules[f"{ctx.ext_name}.ogn.OgnGoodTestNodeDatabase"]
db_object = getattr(db_module, "OgnGoodTestNodeDatabase", None)
self.assertIsNotNone(db_object, "Could not get the built database from the extension imports")
generator_version = getattr(db_object, ogi.VersionProperties.GENERATOR.value, None)
self.assertEqual(generator_version, ogi.get_generator_extension_version())
target_version = getattr(db_object, ogi.VersionProperties.TARGET.value, None)
self.assertEqual(target_version, ogi.get_target_extension_version())
db_module_path = ogi.get_module_path(db_module)
self.assertIsNotNone(db_module_path)
self.assertTrue(ctx.module_path in db_module_path.parents)
test_module = sys.modules[f"{ctx.ext_name}.ogn.tests.TestOgnGoodTestNode"]
test_object = getattr(test_module, "TestOgn", None)
self.assertIsNotNone(test_object, "Could not get the built test from the extension imports")
test_module_path = ogi.get_module_path(test_module)
self.assertIsNotNone(test_module_path)
self.assertTrue(ctx.module_path in test_module_path.parents)
# Clear the scene and disable the extension
await omni.usd.get_context().new_stage_async()
finally:
await ext_contents.disable()
# Confirm that the test node type no longer exists
with self.assertRaises(og.OmniGraphError):
(_, (test_node,), _, _) = og.Controller.edit(
"/TestGraph",
{
key_create: [
("TestNode", f"{ctx.ext_name}.OgnTestNode"),
]
},
)
with self.assertRaises(og.OmniGraphError):
(_, (test_node,), _, _) = og.Controller.edit(
"/TestGraph",
{
key_create: [
("GoodTestNode", f"{ctx.ext_name}.OgnGoodTestNode"),
]
},
)
# --------------------------------------------------------------------------------------------------------------
async def test_multiple_standalone_nodes(self):
"""Test that a built extension with more than one node without generation correctly imports all of them"""
with ExitStack() as stack:
ctx = ModuleContexts(stack)
cache_directory = ogi.full_cache_path(_CURRENT_VERSIONS, ctx.ext_id, ctx.module_name)
ext_contents = _TestExtensionManager(
ctx.python_root,
ctx.ext_name,
_CURRENT_VERSIONS,
import_ogn=False,
import_ogn_tests=False,
)
ext_contents.add_standalone_node("OgnTestNode")
ext_contents.add_standalone_node("OgnGoodTestNode")
expected_files = [
ctx.python_root / ctx.ext_name / "config" / "extension.toml",
ctx.module_path / "__init__.py",
]
expected_files += _expected_standalone_module_files(ctx.module_path, "OgnTestNode")
expected_files += _expected_standalone_module_files(ctx.module_path, "OgnGoodTestNode")
expected_files += _expected_cache_contents(cache_directory, "OgnTestNode")
expected_files += _expected_cache_contents(cache_directory, "OgnGoodTestNode")
expected_files = list(set(expected_files))
# Register the extension and enable it
try:
await ext_contents.enable()
actual_files = []
for root, _dirs, files in ogi.walk_with_excludes(ctx.test_directory, ["__pycache__"]):
for file in files:
actual_files.append(Path(root) / file)
self.assertCountEqual(expected_files, actual_files, "Rebuilt cached extension")
# Confirm that the test node type now exists and can be instantiated
key_create = og.Controller.Keys.CREATE_NODES
(_, (test_node, test_good_node), _, _) = og.Controller.edit(
"/TestGraph",
{
key_create: [
("TestNode", f"{ctx.ext_name}.OgnTestNode"),
("GoodTestNode", f"{ctx.ext_name}.OgnGoodTestNode"),
]
},
)
self.assertIsNotNone(test_node)
self.assertTrue(test_node.is_valid())
self.assertIsNotNone(test_good_node)
self.assertTrue(test_good_node.is_valid())
# Confirm that the modules were correctly created
expected_modules_and_contents = [
(ctx.ext_name, ["_PublicExtension"]),
(f"{ctx.ext_name}.nodes.OgnTestNode", ["OgnTestNode"]),
(f"{ctx.ext_name}.ogn", ["OgnTestNodeDatabase"]),
(f"{ctx.ext_name}.ogn.OgnTestNodeDatabase", ["OgnTestNodeDatabase"]),
(f"{ctx.ext_name}.ogn.tests", ["TestOgnTestNode"]),
(f"{ctx.ext_name}.ogn.tests.TestOgnTestNode", ["TestOgn"]),
(f"{ctx.ext_name}.nodes.OgnGoodTestNode", ["OgnGoodTestNode"]),
(f"{ctx.ext_name}.ogn", ["OgnGoodTestNodeDatabase"]),
(f"{ctx.ext_name}.ogn.OgnGoodTestNodeDatabase", ["OgnGoodTestNodeDatabase"]),
(f"{ctx.ext_name}.ogn.tests", ["TestOgnGoodTestNode"]),
(f"{ctx.ext_name}.ogn.tests.TestOgnGoodTestNode", ["TestOgn"]),
]
self.__confirm_module_contents(expected_modules_and_contents)
# Double check the version number in the imported database file to make sure it is using the cached one
db_module = sys.modules[f"{ctx.ext_name}.ogn.OgnTestNodeDatabase"]
db_object = getattr(db_module, "OgnTestNodeDatabase", None)
self.assertIsNotNone(db_object, "Could not get the cached database from the extension imports")
generator_version = getattr(db_object, ogi.VersionProperties.GENERATOR.value, None)
self.assertEqual(generator_version, ogi.get_generator_extension_version())
target_version = getattr(db_object, ogi.VersionProperties.TARGET.value, None)
self.assertEqual(target_version, ogi.get_target_extension_version())
db_module_path = ogi.get_module_path(db_module)
self.assertIsNotNone(db_module_path)
self.assertTrue(cache_directory in db_module_path.parents)
test_module = sys.modules[f"{ctx.ext_name}.ogn.tests.TestOgnTestNode"]
test_object = getattr(test_module, "TestOgn", None)
self.assertIsNotNone(test_object, "Could not get the cached test from the extension imports")
test_module_path = ogi.get_module_path(test_module)
self.assertIsNotNone(test_module_path)
self.assertTrue(cache_directory in test_module_path.parents)
# Check that the node that did not have to be rebuilt imports from the build directory, not the cache
db_module = sys.modules[f"{ctx.ext_name}.ogn.OgnGoodTestNodeDatabase"]
db_object = getattr(db_module, "OgnGoodTestNodeDatabase", None)
self.assertIsNotNone(db_object, "Could not get the built database from the extension imports")
generator_version = getattr(db_object, ogi.VersionProperties.GENERATOR.value, None)
self.assertEqual(generator_version, ogi.get_generator_extension_version())
target_version = getattr(db_object, ogi.VersionProperties.TARGET.value, None)
self.assertEqual(target_version, ogi.get_target_extension_version())
db_module_path = ogi.get_module_path(db_module)
self.assertIsNotNone(db_module_path)
self.assertTrue(
cache_directory in db_module_path.parents, f"{db_module_path} must be a child of {cache_directory}"
)
test_module = sys.modules[f"{ctx.ext_name}.ogn.tests.TestOgnGoodTestNode"]
test_object = getattr(test_module, "TestOgn", None)
self.assertIsNotNone(test_object, "Could not get the built test from the extension imports")
test_module_path = ogi.get_module_path(test_module)
self.assertIsNotNone(test_module_path)
self.assertTrue(cache_directory in test_module_path.parents)
# Clear the scene and disable the extension
await omni.usd.get_context().new_stage_async()
finally:
await ext_contents.disable()
# Confirm that the test node type no longer exists
with self.assertRaises(og.OmniGraphError):
(_, (test_node,), _, _) = og.Controller.edit(
"/TestGraph",
{
key_create: [
("TestNode", f"{ctx.ext_name}.OgnTestNode"),
]
},
)
with self.assertRaises(og.OmniGraphError):
(_, (test_node,), _, _) = og.Controller.edit(
"/TestGraph",
{
key_create: [
("GoodTestNode", f"{ctx.ext_name}.OgnGoodTestNode"),
]
},
)
| 60,394 | Python | 54.561178 | 120 | 0.572375 |
omniverse-code/kit/exts/omni.graph/omni/graph/core/tests/_internal_utils.py | """Helpers for configuring and running local tests, not meant for general use"""
from __future__ import annotations
import json
from collections import defaultdict
from pathlib import Path
import omni.ext
import omni.graph.tools._internal as ogi
import omni.graph.tools.ogn as ogn
import omni.kit
from omni.graph.tools.tests.internal_utils import CreateHelper
# ==============================================================================================================
class _TestExtensionManager:
"""Object that lets you create and control a dynamically generated extension
Attributes:
__root: Path to the directory in which the extension will be created
__ext_path: Path to the created extension directory
__ext_name: Name of the created extension
__ogn_files: Dictionary of class name to .ogn file implementing the class
__module_path: Path to the Python module directory inside the extension
__exclusions: List of file types to exclude from any generated code
__creator: Helper that creates files of various types
"""
# Dictionary of Path:count that tracks how many test extensions are using a given path, tracked so that the
# extension manager's path information can be properly managed.
PATHS_ADDED = defaultdict(lambda: 0)
def __init__(
self,
root: Path,
ext_name: str,
versions: ogi.GenerationVersions,
import_ogn: bool,
import_ogn_tests: bool,
):
"""Initialize the temporary extension object, creating the required files.
The files will not be deleted by this class, their lifespan must be managed by the caller, e.g. through using
a TempDirectory for their location.
Args:
root: Directory that contains all extensions
ext_name: Name of the extension to create (e.g. 'omni.my.extension')
versions: Versions to use in any generated code
import_ogn: Add a python module spec for the .ogn submodule in the extension.toml
import_ogn_tests: Add a python module spec for the .ogn.tests submodule in the extension.toml
Raises:
AttributeError if there was a problem creating the extension configuration
"""
ogi.LOG.info("Creating extension %s at %s", ext_name, root)
self.__root: Path = root
self.__ext_path: Path = root / ext_name
self.__ext_name: str = ext_name
self.__ogn_files: dict[str, Path] = {} # Class name to .ogn file implementing it
self.__module_path: Path = self.__ext_path / ext_name.replace(".", "/")
self.__module_path.mkdir(parents=True, exist_ok=True)
self.__exclusions: list[ogi.FileType] = []
self.__creator: CreateHelper = CreateHelper(ext_name, self.__root, versions)
self.__creator.add_extension_module(self.__root, ext_name, self.__module_path, import_ogn, import_ogn_tests)
# --------------------------------------------------------------------------------------------------------------
def add_standalone_node(
self,
node_type_name: str,
exclusions: list[ogi.FileType] = None,
):
"""Add a node definition for a node with no generated code. See CreateHelper.add_standalone_node for details"""
created_files = self.__creator.add_standalone_node(node_type_name, exclusions)
self.__exclusions = exclusions
for created_file in created_files:
if created_file.suffix == ".ogn":
self.__ogn_files[node_type_name] = created_file
return
raise ValueError(f"No .ogn file found in standalone created files {created_files}")
# --------------------------------------------------------------------------------------------------------------
def add_v1_18_node(
self,
node_type_name: str,
exclusions: list[ogi.FileType] = None,
):
"""Add a node definition using the V1.18 and earlier pattern. See CreateHelper.add_v1_18_node for details"""
created_files = self.__creator.add_v1_18_node(node_type_name, exclusions)
self.__exclusions = exclusions
for created_file in created_files:
if created_file.suffix == ".ogn":
self.__ogn_files[node_type_name] = created_file
return
raise ValueError(f"No .ogn file found in V1.18 created files {created_files}")
# --------------------------------------------------------------------------------------------------------------
def add_v1_19_node(
self,
node_type_name: str,
exclusions: list[ogi.FileType] = None,
):
"""Add a node definition using the V1.19 pattern. See CreateHelper.add_v1_19_node for details"""
created_files = self.__creator.add_v1_19_node(node_type_name, exclusions)
self.__exclusions = exclusions
for created_file in created_files:
if created_file.suffix == ".ogn":
self.__ogn_files[node_type_name] = created_file
return
raise ValueError(f"No .ogn file found in V1.19 created files {created_files}")
# --------------------------------------------------------------------------------------------------------------
def add_cache_for_node(
self,
node_type_name: str,
exclusions: list[ogi.FileType] = None,
):
"""Add a node definition to the cache. See CreateHelper.add_cache_for_node for details"""
self.__creator.add_cache_for_node(node_type_name, exclusions)
self.__exclusions = exclusions
# --------------------------------------------------------------------------------------------------------------
async def add_hot_attribute_to_ogn(self):
"""Rewrite the .ogn file with a new input attribute "hot_attribute" for hot reload testing"""
ogi.LOG.info("!!! Adding hot reload attribute to %s", str(self.__ogn_files))
# Remember the .ogn definitions for use in the generation of sample code
ogn_definitions = {
class_name: {
ogn.NodeTypeKeys.DESCRIPTION: "None",
ogn.NodeTypeKeys.VERSION: 1,
ogn.NodeTypeKeys.EXCLUDE: self.__exclusions or [],
ogn.NodeTypeKeys.LANGUAGE: ogn.LanguageTypeValues.PYTHON,
ogn.NodeTypeKeys.INPUTS: {
"hot": {"type": "bool", "description": "Additional attribute added for hot reload"}
},
}
for class_name in self.__ogn_files
}
ogi.LOG.info("Updated ogn definition(s) in %s", self.__ogn_files)
for class_name, ogn_path in self.__ogn_files.items():
ogn_path = CreateHelper.safe_create(
self.__module_path / "ogn" / "nodes",
class_name,
ogi.FileType.OGN,
json.dumps({class_name: ogn_definitions[class_name]}),
)
self.__ogn_files[class_name] = ogn_path
ogi.LOG.info("!!! Attribute added from hot reload")
# --------------------------------------------------------------------------------------------------------------
def add_extra_import(self, directory_name: str, file_name: str, object_to_define: str) -> Path:
"""Add a new file under the ogn/ directory that acts as a proxy for an import that results from the links
that the LUA function add_ogn_subdirectory() adds. Returns the path to the newly created file.
"""
return CreateHelper.safe_create(
# self.__module_path / "ogn" / directory_name / file_name,
self.__module_path / "ogn" / file_name,
None,
None,
f"{object_to_define} = True\n",
)
# --------------------------------------------------------------------------------------------------------------
async def enable(self):
"""Make the constructed extension visible to the extension manager, if it hasn't yet been, and enable it"""
ogi.LOG.info("Enabling extension %s at %s", self.__ext_name, self.__ext_path)
manager = omni.kit.app.get_app().get_extension_manager()
# Remove and add back to ensure that the path is scanned for the new content
manager.remove_path(str(self.__root))
manager.add_path(str(self.__root), omni.ext.ExtensionPathType.COLLECTION_USER)
# This sync is to get the manager to refresh its paths
await omni.kit.app.get_app().next_update_async()
manager.set_extension_enabled(self.__ext_name, True)
self.PATHS_ADDED[self.__root] += 1
# This sync is to allow time for executing the extension enabled hooks
await omni.kit.app.get_app().next_update_async()
# --------------------------------------------------------------------------------------------------------------
async def disable(self):
"""Disable the constructed extension, if enabled and decrement the accesses to its path"""
ogi.LOG.info("Disabling extension %s", self.__ext_name)
manager = omni.kit.app.get_app().get_extension_manager()
# If this was the last extension to need the path then remove it from the manager's path. Either way the
# path is removed first to force the path to be scanned for the remaining content.
manager.set_extension_enabled(self.__ext_name, False)
# This sync is to ensure the extension is disabled before removing its path
await omni.kit.app.get_app().next_update_async()
manager.remove_path(str(self.__root))
self.PATHS_ADDED[self.__root] -= 1
# If some other creator exists in the same path then bring the path back for continued use
if self.PATHS_ADDED[self.__root] > 0:
manager.add_path(str(self.__root), omni.ext.ExtensionPathType.COLLECTION_USER)
# This sync is to get the manager to executing the extension disabled hooks and refresh the paths
await omni.kit.app.get_app().next_update_async()
| 10,058 | Python | 49.044776 | 119 | 0.568304 |
omniverse-code/kit/exts/omni.graph/omni/graph/core/tests/test_api.py | """Testing the stability of the API in this module"""
import omni.graph.core as og
import omni.graph.core._impl.commands as ogc
import omni.graph.core.autonode as autonode
import omni.graph.core.typing as ogty
import omni.kit
from omni.graph.tools.tests.internal_utils import _check_module_api_consistency, _check_public_api_contents
# ======================================================================
class _TestOmniGraphApi(omni.kit.test.AsyncTestCase):
_UNPUBLISHED = ["bindings", "tests", "omni", "commands"]
async def test_api(self):
_check_module_api_consistency(og.tests, [], is_test_module=True) # noqa: PLW0212
_check_module_api_consistency(autonode) # noqa: PLW0212
_check_module_api_consistency(ogty) # noqa: PLW0212
_check_module_api_consistency(ogc, ogc._HIDDEN) # noqa: PLW0212
# Since the og module also contains all of the previously exposed objects for backward compatibility, they
# have to be added to the list of unpublished elements here as they, rightly, do not appear in __all__
all_unpublished = (
self._UNPUBLISHED
+ og._HIDDEN # noqa: PLW0212
+ ogc._HIDDEN # noqa: PLW0212
+ [module_object for module_object in dir(autonode) if not module_object.startswith("_")]
+ [module_object for module_object in dir(ogty) if not module_object.startswith("_")]
)
_check_module_api_consistency(og, all_unpublished) # noqa: PLW0212
async def test_api_features(self):
"""Test that the known public API features continue to exist"""
_check_public_api_contents(
og,
[ # noqa: PLW0212
"attribute_value_as_usd",
"AttributeDataValueHelper",
"AttributeValueHelper",
"autonode",
"Bundle",
"BundleContainer",
"BundleContents",
"cmds",
"Controller",
"data_shape_from_type",
"Database",
"DataView",
"DataWrapper",
"Device",
"Dtype",
"DynamicAttributeAccess",
"DynamicAttributeInterface",
"ExtensionInformation",
"get_global_orchestration_graphs",
"get_graph_settings",
"get_port_type_namespace",
"GraphController",
"GraphSettings",
"in_compute",
"is_attribute_plain_data",
"is_in_compute",
"MetadataKeys",
"NodeController",
"ObjectLookup",
"OmniGraphError",
"OmniGraphInspector",
"OmniGraphValueError",
"PerNodeKeys",
"python_value_as_usd",
"ReadOnlyError",
"resolve_base_coupled",
"resolve_fully_coupled",
"RuntimeAttribute",
"Settings",
"ThreadsafetyTestUtils",
"TypedValue",
"typing",
"WrappedArrayType",
],
self._UNPUBLISHED,
only_expected_allowed=False,
)
| 3,295 | Python | 39.195121 | 114 | 0.527769 |
omniverse-code/kit/exts/omni.graph/omni/graph/core/tests/__init__.py | """
Imports from the test module are only recommended for use in OmniGraph tests.
To get documentation on this module and methods import this file into a Python interpreter and run dir/help, like this:
.. code-block:: python
import omni.graph.core.tests as ogts
dir(ogts)
help(ogts.load_test_file)
"""
# fmt: off
# isort: off
# Exported interface for testing utilities that are of general use.
# (Others exist but are legacy or specific to one use only and imported directly)
from ._unittest_support import construct_test_class
from ._unittest_support import OmniGraphTestConfiguration
from .omnigraph_test_utils import OmniGraphTestCase
from .omnigraph_test_utils import OmniGraphTestCaseNoClear
from .omnigraph_test_utils import SettingContext
from .omnigraph_test_utils import TestContextManager
from .expected_error import ExpectedError
from .omnigraph_test_utils import create_cone
from .omnigraph_test_utils import create_cube
from .omnigraph_test_utils import create_grid_mesh
from .omnigraph_test_utils import create_input_and_output_grid_meshes
from .omnigraph_test_utils import create_sphere
from .omnigraph_test_utils import DataTypeHelper
from .omnigraph_test_utils import dump_graph
from .omnigraph_test_utils import insert_sublayer
from .omnigraph_test_utils import load_test_file
from .omnigraph_test_utils import test_case_class
from .omnigraph_test_utils import verify_connections
from .omnigraph_test_utils import verify_node_existence
from .omnigraph_test_utils import verify_values
from .validation import validate_abi_interface
scan_for_test_modules = True
"""The presence of this object causes the test runner to automatically scan the directory for unit test cases"""
# ==============================================================================================================
# _____ ______ _____ _____ ______ _____ _______ ______ _____
# | __ \ | ____|| __ \ | __ \ | ____|/ ____| /\ |__ __|| ____|| __ \
# | | | || |__ | |__) || |__) || |__ | | / \ | | | |__ | | | |
# | | | || __| | ___/ | _ / | __| | | / /\ \ | | | __| | | | |
# | |__| || |____ | | | | \ \ | |____| |____ / ____ \ | | | |____ | |__| |
# |_____/ |______||_| |_| \_\|______|\_____|/_/ \_\|_| |______||_____/
#
# isort: on
# fmt: on
| 2,342 | Python | 42.388888 | 119 | 0.595218 |
omniverse-code/kit/exts/omni.graph/omni/graph/core/tests/test_bundle_dirty_id.py | import omni.graph.core as og
import omni.graph.core.tests as ogt
class BundleTestSetup(ogt.OmniGraphTestCase):
async def setUp(self):
"""Set up test environment, to be torn down when done"""
await super().setUp()
self.graph = og.Controller.create_graph("/graph")
self.context = self.graph.get_default_graph_context()
self.factory = og.IBundleFactory.create()
self.assertTrue(self.factory is not None)
self.dirty = og._og_unstable.IDirtyID2.create(self.context) # noqa: PLW0212
self.assertTrue(self.dirty is not None)
# bundle paths
self.bundle2Name = "bundle2"
self.bundle3Name = "bundle3"
self.attr1Name = "attr1"
self.attr1Type = og.Type(og.BaseDataType.INT)
self.attr2Name = "attr2"
self.attr2Type = og.Type(og.BaseDataType.FLOAT)
self.attr3Name = "attr3"
self.attr3Type = og.Type(og.BaseDataType.INT, 1, 1)
self.attr4Name = "attr4"
self.attr4Type = og.Type(og.BaseDataType.INT, 2, 0)
class TestBundleDirtyID(BundleTestSetup):
async def setUp(self):
"""Set up test environment, to be torn down when done"""
await super().setUp()
async def test_create_bundle(self):
bundle1 = self.factory.create_bundle(self.context, "bundle1")
bundle2 = self.factory.create_bundle(self.context, "bundle2")
self.dirty.setup(bundle1, True)
self.dirty.setup(bundle2, True)
ids = self.dirty.get([bundle1, bundle2])
self.assertTrue(self.dirty.is_valid(ids[0]))
self.assertTrue(self.dirty.is_valid(ids[1]))
self.assertNotEqual(ids[0], ids[1])
async def test_create_attribute(self):
bundle = self.factory.create_bundle(self.context, "bundle")
self.dirty.setup(bundle, True)
ids0 = self.dirty.get([bundle])
bundle.create_attribute(self.attr1Name, self.attr1Type)
ids1 = self.dirty.get([bundle])
self.assertTrue(self.dirty.is_valid(ids0[0]))
self.assertTrue(self.dirty.is_valid(ids1[0]))
self.assertNotEqual(ids0[0], ids1[0])
async def test_create_child_bundle(self):
bundle = self.factory.create_bundle(self.context, "bundle")
self.dirty.setup(bundle, True)
ids0 = self.dirty.get([bundle])
self.assertTrue(self.dirty.is_valid(ids0[0]))
bundle.create_child_bundle(self.bundle2Name)
ids1 = self.dirty.get([bundle])
self.assertTrue(self.dirty.is_valid(ids1[0]))
self.assertNotEqual(ids0[0], ids1[0])
async def test_remove_attribute(self):
bundle = self.factory.create_bundle(self.context, "bundle")
self.dirty.setup(bundle, True)
bundle.create_attribute(self.attr1Name, self.attr1Type)
ids0 = self.dirty.get([bundle])
self.assertTrue(self.dirty.is_valid(ids0[0]))
bundle.remove_attribute(self.attr1Name)
ids1 = self.dirty.get([bundle])
self.assertTrue(self.dirty.is_valid(ids1[0]))
self.assertNotEqual(ids0[0], ids1[0])
async def test_remove_child_bundles(self):
bundle = self.factory.create_bundle(self.context, "bundle")
self.dirty.setup(bundle, True)
bundle2 = bundle.create_child_bundle("child")
ids0 = self.dirty.get([bundle])
self.assertTrue(self.dirty.is_valid(ids0[0]))
bundle.remove_child_bundle(bundle2)
ids1 = self.dirty.get([bundle])
self.assertTrue(self.dirty.is_valid(ids1[0]))
self.assertNotEqual(ids0[0], ids1[0])
async def test_clear_contents(self):
"""Test if clearing bundle results with new dirty id"""
bundle = self.factory.create_bundle(self.context, "bundle")
self.dirty.setup(bundle, True)
ids0 = self.dirty.get([bundle])
self.assertTrue(self.dirty.is_valid(ids0[0]))
bundle.clear_contents()
ids1 = self.dirty.get([bundle])
self.assertTrue(self.dirty.is_valid(ids1[0]))
self.assertNotEqual(ids0[0], ids1[0])
async def test_copy_attribute(self):
bundle1 = self.factory.create_bundle(self.context, "bundle1")
bundle2 = self.factory.create_bundle(self.context, "bundle2")
self.dirty.setup(bundle1, True)
self.dirty.setup(bundle2, True)
attr1 = bundle1.create_attribute(self.attr1Name, self.attr1Type)
ids0 = self.dirty.get([bundle2])
self.assertTrue(self.dirty.is_valid(ids0[0]))
bundle2.copy_attribute(attr1)
ids1 = self.dirty.get([bundle2])
self.assertTrue(self.dirty.is_valid(ids1[0]))
self.assertNotEqual(ids0[0], ids1[0])
async def test_copy_child_bundle(self):
"""Test if CoW reference is resolved."""
bundle1 = self.factory.create_bundle(self.context, "bundle1")
bundle2 = self.factory.create_bundle(self.context, "bundle2")
self.dirty.setup(bundle1, True)
self.dirty.setup(bundle2, True)
ids0 = self.dirty.get([bundle1])
self.assertTrue(self.dirty.is_valid(ids0[0]))
bundle1.copy_child_bundle(self.bundle2Name, bundle2)
ids1 = self.dirty.get([bundle1])
self.assertTrue(self.dirty.is_valid(ids1[0]))
self.assertNotEqual(ids0[0], ids1[0])
async def test_copy_bundle(self):
"""Copying bundle creates a shallow copy - a reference.
To obtain the dirty id the reference needs to be resolved"""
bundle1 = self.factory.create_bundle(self.context, "bundle1")
bundle2 = self.factory.create_bundle(self.context, "bundle2")
self.dirty.setup(bundle1, True)
self.dirty.setup(bundle2, True)
ids0 = self.dirty.get([bundle1, bundle2])
self.assertNotEqual(ids0[0], ids0[1])
self.assertTrue(self.dirty.is_valid(ids0[0]))
self.assertTrue(self.dirty.is_valid(ids0[1]))
bundle2.copy_bundle(bundle1)
ids1 = self.dirty.get([bundle1, bundle2])
self.assertTrue(self.dirty.is_valid(ids1[0]))
self.assertTrue(self.dirty.is_valid(ids1[1]))
self.assertEqual(ids1[0], ids1[1])
async def test_get_attribute_by_name(self):
"""Getting writable attribute data handle does not change dirty id.
Only writing to an attribute triggers id to be changed."""
bundle = self.factory.create_bundle(self.context, "bundle")
self.dirty.setup(bundle, True)
bundle.create_attribute(self.attr1Name, self.attr1Type)
ids0 = self.dirty.get([bundle])
self.assertTrue(self.dirty.is_valid(ids0[0]))
bundle.get_attribute_by_name(self.attr1Name)
ids1 = self.dirty.get([bundle])
self.assertTrue(self.dirty.is_valid(ids1[0]))
self.assertEqual(ids0[0], ids1[0])
async def test_get_child_bundle_by_name(self):
"""Getting writable bundle handle does not change dirty id.
Only creating/removing attributes and children triggers id to be
changed."""
bundle = self.factory.create_bundle(self.context, "bundle")
self.dirty.setup(bundle, True)
bundle.create_child_bundle(self.bundle2Name)
ids0 = self.dirty.get([bundle])
self.assertTrue(self.dirty.is_valid(ids0[0]))
bundle.get_child_bundle_by_name(self.bundle2Name)
ids1 = self.dirty.get([bundle])
self.assertTrue(self.dirty.is_valid(ids1[0]))
self.assertEqual(ids0[0], ids1[0])
async def test_get_simple_attribute_data(self):
"""Getting simple attribute data should not change dirty id"""
bundle = self.factory.create_bundle(self.context, "bundle")
self.dirty.setup(bundle, True)
attr = bundle.create_attribute(self.attr1Name, self.attr1Type)
attr.set(42)
ids0 = self.dirty.get([bundle])
self.assertTrue(self.dirty.is_valid(ids0[0]))
self.assertEqual(attr.as_read_only().get(), 42)
ids1 = self.dirty.get([bundle])
self.assertTrue(self.dirty.is_valid(ids1[0]))
self.assertEqual(ids0[0], ids1[0])
async def test_get_array_attribute_data(self):
"""Getting array attribute data should not change dirty id"""
bundle = self.factory.create_bundle(self.context, "bundle")
self.dirty.setup(bundle, True)
attr = bundle.create_attribute(self.attr3Name, self.attr3Type)
attr.set([42])
ids0 = self.dirty.get([bundle])
self.assertTrue(self.dirty.is_valid(ids0[0]))
self.assertEqual(attr.as_read_only().get()[0], 42)
ids1 = self.dirty.get([bundle])
self.assertTrue(self.dirty.is_valid(ids1[0]))
self.assertEqual(ids0[0], ids1[0])
async def _get_array_rw_attribute_data(self, on_gpu):
"""Getting array attribute data for read-write"""
bundle = self.factory.create_bundle(self.context, "bundle")
self.dirty.setup(bundle, True)
attr = bundle.create_attribute(self.attr3Name, self.attr3Type)
attr.set([42])
ids0 = self.dirty.get([bundle])
self.assertTrue(self.dirty.is_valid(ids0[0]))
# no bump
attr.as_read_only().get_array(on_gpu=on_gpu, get_for_write=False, reserved_element_count=1)
ids1 = self.dirty.get([bundle])
self.assertTrue(self.dirty.is_valid(ids1[0]))
self.assertEqual(ids0[0], ids1[0])
# bump
attr.get_array(on_gpu=on_gpu, get_for_write=True, reserved_element_count=1)
ids1 = self.dirty.get([bundle])
self.assertTrue(self.dirty.is_valid(ids1[0]))
self.assertNotEqual(ids0[0], ids1[0])
async def test_get_array_attribute_data_cpu(self):
await self._get_array_rw_attribute_data(False)
async def test_get_array_attribute_data_gpu(self):
await self._get_array_rw_attribute_data(True)
async def test_resize_array_attribute(self):
bundle = self.factory.create_bundle(self.context, "bundle")
self.dirty.setup(bundle, True)
attr = bundle.create_attribute(self.attr3Name, self.attr3Type)
ids0 = self.dirty.get([bundle])
self.assertTrue(self.dirty.is_valid(ids0[0]))
# no bump
attr.size()
ids1 = self.dirty.get([bundle])
self.assertTrue(self.dirty.is_valid(ids1[0]))
self.assertEqual(ids0[0], ids1[0])
# bump
attr.resize(10)
ids1 = self.dirty.get([bundle])
self.assertTrue(self.dirty.is_valid(ids1[0]))
self.assertNotEqual(ids0[0], ids1[0])
async def test_get_tuple_attribute_data(self):
"""Getting array attribute data should not change dirty id"""
bundle = self.factory.create_bundle(self.context, "bundle")
self.dirty.setup(bundle, True)
attr = bundle.create_attribute(self.attr4Name, self.attr4Type)
attr.set([42, 24])
ids0 = self.dirty.get([bundle])
self.assertTrue(self.dirty.is_valid(ids0[0]))
self.assertEqual(attr.as_read_only().get()[0], 42)
self.assertEqual(attr.as_read_only().get()[1], 24)
ids1 = self.dirty.get([bundle])
self.assertTrue(self.dirty.is_valid(ids1[0]))
self.assertEqual(ids0[0], ids1[0])
async def test_change_child_and_propagate_changes_to_parent(self):
r"""
bundle1
\_ child0
\_ child1
\_ child2 <-- create attribute
Will propagate dirty id changes up to `bundle1`
(child2 -> child1 -> child0 -> bundle1)
"""
bundle = self.factory.create_bundle(self.context, "bundle")
self.dirty.setup(bundle, True)
child0 = bundle.create_child_bundle("child0")
child1 = child0.create_child_bundle("child1")
child2 = child1.create_child_bundle("child2")
ids0 = self.dirty.get([bundle, child0, child1])
self.assertTrue(self.dirty.is_valid(ids0[0]))
self.assertTrue(self.dirty.is_valid(ids0[1]))
self.assertTrue(self.dirty.is_valid(ids0[2]))
# creating attribute automatically bumps parent ids
child2.create_attribute(self.attr1Name, self.attr1Type)
ids1 = self.dirty.get([bundle, child0, child1])
self.assertTrue(self.dirty.is_valid(ids1[0]))
self.assertTrue(self.dirty.is_valid(ids1[1]))
self.assertTrue(self.dirty.is_valid(ids1[2]))
self.assertNotEqual(ids0[0], ids1[0])
self.assertNotEqual(ids0[1], ids1[1])
self.assertNotEqual(ids0[2], ids1[2])
class TestAttributeDirtyID(BundleTestSetup):
async def setUp(self):
"""Set up test environment, to be torn down when done"""
await super().setUp()
async def test_create_attribute(self):
bundle = self.factory.create_bundle(self.context, "bundle")
self.dirty.setup(bundle, True)
attr1 = bundle.create_attribute(self.attr1Name, self.attr1Type)
ids0 = self.dirty.get([attr1])
self.assertTrue(self.dirty.is_valid(ids0[0]))
attr2 = bundle.create_attribute(self.attr2Name, self.attr2Type)
ids1 = self.dirty.get([attr2])
self.assertTrue(self.dirty.is_valid(ids1[0]))
self.assertNotEqual(ids0[0], ids1[0])
async def test_create_same_attribute(self):
bundle = self.factory.create_bundle(self.context, "bundle")
self.dirty.setup(bundle, True)
attr1 = bundle.create_attribute(self.attr1Name, self.attr1Type)
ids0 = self.dirty.get([attr1])
self.assertTrue(self.dirty.is_valid(ids0[0]))
attr2 = bundle.create_attribute(self.attr1Name, self.attr1Type)
ids1 = self.dirty.get([attr2])
self.assertTrue(self.dirty.is_valid(ids1[0]))
self.assertEqual(ids0[0], ids1[0])
async def test_create_same_attribute_new_size(self):
bundle = self.factory.create_bundle(self.context, "bundle")
self.dirty.setup(bundle, True)
n = "attr"
t = og.Type(og.BaseDataType.INT, 1, 1)
attr = bundle.create_attribute(n, t, 100)
ids0 = self.dirty.get([attr])
self.assertTrue(self.dirty.is_valid(ids0[0]))
# same size does not bump dirty ids
attr = bundle.create_attribute(n, t, 100)
ids1 = self.dirty.get([attr])
self.assertTrue(self.dirty.is_valid(ids1[0]))
self.assertEqual(ids0[0], ids1[0])
# new size bumps dirty ids
attr = bundle.create_attribute(n, t, 10)
ids1 = self.dirty.get([attr])
self.assertTrue(self.dirty.is_valid(ids1[0]))
self.assertNotEqual(ids0[0], ids1[0])
async def test_get_simple_attribute_data(self):
"""Getting simple attribute data should not change dirty id"""
bundle = self.factory.create_bundle(self.context, "bundle")
self.dirty.setup(bundle, True)
attr = bundle.create_attribute(self.attr1Name, self.attr1Type)
attr.set(42)
ids0 = self.dirty.get([attr])
self.assertTrue(self.dirty.is_valid(ids0[0]))
self.assertEqual(attr.as_read_only().get(), 42)
ids1 = self.dirty.get([attr])
self.assertTrue(self.dirty.is_valid(ids1[0]))
self.assertEqual(ids0[0], ids1[0])
async def test_get_array_attribute_data(self):
"""Getting array attribute data should not change dirty id"""
bundle = self.factory.create_bundle(self.context, "bundle")
self.dirty.setup(bundle, True)
attr = bundle.create_attribute(self.attr3Name, self.attr3Type)
attr.set([42])
ids0 = self.dirty.get([attr])
self.assertTrue(self.dirty.is_valid(ids0[0]))
self.assertEqual(attr.as_read_only().get()[0], 42)
ids1 = self.dirty.get([attr])
self.assertTrue(self.dirty.is_valid(ids1[0]))
self.assertEqual(ids0[0], ids1[0])
async def test_get_tuple_attribute_data(self):
"""Getting tuple attribute data should not change dirty id"""
bundle = self.factory.create_bundle(self.context, "bundle")
self.dirty.setup(bundle, True)
attr = bundle.create_attribute(self.attr4Name, self.attr4Type)
attr.set([42, 24])
ids0 = self.dirty.get([attr])
self.assertTrue(self.dirty.is_valid(ids0[0]))
self.assertEqual(attr.as_read_only().get()[0], 42)
self.assertEqual(attr.as_read_only().get()[1], 24)
ids1 = self.dirty.get([attr])
self.assertTrue(self.dirty.is_valid(ids1[0]))
self.assertEqual(ids0[0], ids1[0])
async def test_set_simple_attribute_data(self):
"""Setting simple attribute data changes dirty id"""
bundle = self.factory.create_bundle(self.context, "bundle")
self.dirty.setup(bundle, True)
attr = bundle.create_attribute(self.attr1Name, self.attr1Type)
ids0 = self.dirty.get([attr, bundle])
self.assertTrue(self.dirty.is_valid(ids0[0]))
self.assertTrue(self.dirty.is_valid(ids0[1]))
attr.set(42)
ids1 = self.dirty.get([attr, bundle])
self.assertTrue(self.dirty.is_valid(ids1[0]))
self.assertTrue(self.dirty.is_valid(ids1[1]))
self.assertNotEqual(ids0[0], ids1[0])
self.assertNotEqual(ids0[1], ids1[1])
async def test_set_array_attribute_data(self):
"""Setting array attribute data changes dirty id"""
bundle = self.factory.create_bundle(self.context, "bundle")
self.dirty.setup(bundle, True)
attr = bundle.create_attribute(self.attr3Name, self.attr3Type)
ids0 = self.dirty.get([attr, bundle])
self.assertTrue(self.dirty.is_valid(ids0[0]))
self.assertTrue(self.dirty.is_valid(ids0[1]))
attr.set([42])
ids1 = self.dirty.get([attr, bundle])
self.assertTrue(self.dirty.is_valid(ids1[0]))
self.assertTrue(self.dirty.is_valid(ids1[1]))
self.assertNotEqual(ids0[0], ids1[0])
self.assertNotEqual(ids0[1], ids1[1])
async def test_set_tuple_attribute_data(self):
"""Setting tuple attribute data changes dirty id"""
bundle = self.factory.create_bundle(self.context, "bundle")
self.dirty.setup(bundle, True)
attr = bundle.create_attribute(self.attr4Name, self.attr4Type)
ids0 = self.dirty.get([attr, bundle])
self.assertTrue(self.dirty.is_valid(ids0[0]))
self.assertTrue(self.dirty.is_valid(ids0[1]))
attr.set([42, 24])
ids1 = self.dirty.get([attr, bundle])
self.assertTrue(self.dirty.is_valid(ids1[0]))
self.assertTrue(self.dirty.is_valid(ids1[1]))
self.assertNotEqual(ids0[0], ids1[0])
self.assertNotEqual(ids0[1], ids1[1])
| 18,506 | Python | 38.62955 | 99 | 0.635199 |
omniverse-code/kit/exts/omni.graph/omni/graph/core/tests/test_unittest_support.py | """Tests that exercise the capabilities provided for OmniGraph unit testing"""
from contextlib import asynccontextmanager, contextmanager
import carb
import omni.graph.core.tests as ogts
import omni.graph.tools as ogt
import omni.kit.test
import omni.usd
# Name of a fake setting that will be used for testing
TEST_SETTING = "/not/a/setting"
# ==============================================================================================================
class TestOmniGraphTestFeatures(omni.kit.test.AsyncTestCase):
"""Run targeted tests on the test helper functions and classes directly, not as part of the test definition"""
async def test_configuration_class(self):
"""Tests the functionality of customized OmniGraphTestConfiguration objects"""
settings = carb.settings.get_settings()
with ogts.OmniGraphTestConfiguration(settings={TEST_SETTING: True}):
self.assertEqual(settings.get(TEST_SETTING), True)
self.assertEqual(settings.get(TEST_SETTING), None)
# --------------------------------------------------------------------------------------------------------------
CONTEXT_FLAG = 0
async def test_custom_contexts(self):
"""Tests the functionality of providing my own custom contexts via the contextmanager decorator"""
@contextmanager
def context_add_1():
TestOmniGraphTestFeatures.CONTEXT_FLAG = TestOmniGraphTestFeatures.CONTEXT_FLAG + 1
try:
yield True
finally:
TestOmniGraphTestFeatures.CONTEXT_FLAG = TestOmniGraphTestFeatures.CONTEXT_FLAG - 1
@asynccontextmanager
async def async_context_add_10():
TestOmniGraphTestFeatures.CONTEXT_FLAG = TestOmniGraphTestFeatures.CONTEXT_FLAG + 10
try:
yield True
finally:
TestOmniGraphTestFeatures.CONTEXT_FLAG = TestOmniGraphTestFeatures.CONTEXT_FLAG - 10
my_configuration = ogts.OmniGraphTestConfiguration(
contexts=[context_add_1], async_contexts=[async_context_add_10]
)
self.assertEqual(TestOmniGraphTestFeatures.CONTEXT_FLAG, 0)
with my_configuration:
self.assertEqual(TestOmniGraphTestFeatures.CONTEXT_FLAG, 1)
self.assertEqual(TestOmniGraphTestFeatures.CONTEXT_FLAG, 0)
async with my_configuration:
self.assertEqual(TestOmniGraphTestFeatures.CONTEXT_FLAG, 11)
self.assertEqual(TestOmniGraphTestFeatures.CONTEXT_FLAG, 0)
# --------------------------------------------------------------------------------------------------------------
async def test_construct_test_class(self):
"""Tests the ability to create a base class using the construct_test_class() function"""
# Test the deprecated keyword
message = "I am deprecated"
deprecated_class = ogts.construct_test_class(deprecated=message)
self.assertTrue(omni.kit.test.AsyncTestCase in deprecated_class.__bases__)
with ogt.DeprecateMessage.NoLogging():
instance = deprecated_class()
await instance.setUp()
messages_logged = ogt.DeprecateMessage.messages_logged()
self.assertTrue(message in messages_logged, f"'{message}' not in {messages_logged}")
# Test the base_class keyword
class BaseTestClass(omni.kit.test.AsyncTestCase):
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
self.i_exist = True
derived_class = ogts.construct_test_class(base_class=BaseTestClass)
instance = derived_class()
self.assertTrue(hasattr(instance, "i_exist") and instance.i_exist, f"No 'i_exist' in {dir(instance)}")
self.assertTrue(isinstance(instance, BaseTestClass))
# Test the configure keyword
configuration = ogts.OmniGraphTestConfiguration(settings={TEST_SETTING: True})
configured_class = ogts.construct_test_class(configuration=configuration)
instance = configured_class()
self.assertEqual(type(configuration), type(instance._OmniGraphCustomTestCase__configuration)) # noqa PLW0212
with self.assertRaises(TypeError):
_ = ogts.construct_test_class(configuration=3)
# Test the extensions_enabled keyword
test_extension = "omni.graph.scriptnode"
manager = omni.kit.app.get_app().get_extension_manager()
was_enabled = manager.is_extension_enabled(test_extension)
manager.set_extension_enabled_immediate(test_extension, False)
configuration = ogts.OmniGraphTestConfiguration(extensions_enabled=[test_extension])
with configuration:
self.assertTrue(manager.is_extension_enabled(test_extension))
manager.set_extension_enabled_immediate(test_extension, was_enabled)
# Test the extensions_disabled keyword
manager.set_extension_enabled_immediate(test_extension, True)
configuration = ogts.OmniGraphTestConfiguration(extensions_disabled=[test_extension])
with configuration:
self.assertFalse(manager.is_extension_enabled(test_extension))
manager.set_extension_enabled_immediate(test_extension, was_enabled)
# ==============================================================================================================
class TestStandardConfiguration(ogts.OmniGraphTestCase):
"""Run tests using the standard OmniGraph test configuration"""
async def setUp(self):
await super().setUp()
async def tearDown(self):
await super().tearDown()
async def test_settings(self):
"""Test that the standard settings are applied by the test case"""
# ==============================================================================================================
class TestCustomSetUp(omni.kit.test.AsyncTestCase):
"""Run tests using an OmniGraphTestConfiguration customization using the Kit base class"""
async def test_configuration(self):
with ogts.OmniGraphTestConfiguration(settings={TEST_SETTING: True}):
self.assertTrue(carb.settings.get_settings().get(TEST_SETTING))
# ==============================================================================================================
MyTestClass = ogts.construct_test_class(settings={TEST_SETTING: True})
class TestManualConfiguration(MyTestClass):
"""Run tests using a custom created base test class"""
async def test_constructed_base_class(self):
self.assertTrue(carb.settings.get_settings().get(TEST_SETTING))
# ==============================================================================================================
class TestCustomBaseClass(MyTestClass):
"""Run tests using a custom created base test class derived from another custom base class"""
async def test_constructed_derived_class(self):
with self.assertRaises(TypeError):
MyDerivedTestClass = ogts.construct_test_class(base_class=MyTestClass) # noqa F841
# ==============================================================================================================
class TestOverrideSetUp(ogts.OmniGraphTestCase):
"""Run tests using a customization that is based on the standard configuration"""
async def test_configuration(self):
with ogts.OmniGraphTestConfiguration(settings={TEST_SETTING: True}):
self.assertTrue(carb.settings.get_settings().get(TEST_SETTING))
| 7,480 | Python | 45.465838 | 117 | 0.61484 |
omniverse-code/kit/exts/omni.graph/omni/graph/core/tests/_unittest_support.py | """Support for creating unittest style test cases that use OmniGraph components.
Note the leading underscore in the file name, indicating that it should not be imported directly. Instead use this:
.. code-block:: python
import omni.graph.core.tests as ogts
There are three primary workflows for setting up unit test case classes that manage OmniGraph state.
If your test case uses OmniGraph and just wants a standard configuration while running then you can use the
predefined test case base class :py:class:`omni.graph.core.tests.OmniGraphTestCase`.
.. code-block:: python
import omni.graph.core.tests as ogts
class TestMyStuff(ogts.OmniGraphTestCase):
async def test_my_stuff(self):
pass # My stuff always works
If instead you wish to make use of only a subset of the various OmniGraph configuration values or use your own test
base class then you can use :py:class:`omni.graph.core.tests.OmniGraphTestConfiguration` to build up a set of temporary
conditions in force while the test runs, such as using an empty scene, defining settings, etc.
.. code-block:: python
import omni.graph.core.tests as ogts
class TestMyStuff(omni.kit.test.AsyncTestCase):
async def test_my_stuff(self):
with ogts.OmniGraphTestConfiguration(clear_on_start=False):
pass # My stuff always works
You can also use the test case class constructor to define your own base class that can be used in multiple locations:
.. code-block:: python
import omni.graph.core.tests as ogts
MyDebugTestClass = ogts.test_case_class(clear_on_finish=False, clear_on_start=False)
class TestMyStuff(MyDebugTestClass):
async def test_my_stuff(self):
pass # My stuff always works
"""
from __future__ import annotations
import asyncio
import inspect
from contextlib import AsyncExitStack, ExitStack, asynccontextmanager, contextmanager
import omni.graph.core as og
import omni.graph.tools as ogt
import omni.kit
import omni.usd
# ==============================================================================================================
class OmniGraphTestConfiguration:
"""Class to manage testing configuration parameters as a context manager that brackets a test run.
You can either use it around a single test to modify configuration for just that test:
.. code-block:: python
import omni.graph.core.tests as ogts
class TestRun(ogts.OmniGraphTestCase):
'''By default the tests in this class will clear the scene on start and finish of the test'''
async def test_without_clearing(self):
async with ogts.OmniGraphTestConfiguration(clear_on_start=False):
run_my_test()
# Before this particular test the scene will not be cleared before starting
See :py:func:`construct_test_class` for a way of applying it to every test in the test case.
.. code-block:: python
class TestRun(ogts.construct_test_class(clear_on_start=True)):
async def test_without_clearing(self):
run_my_test()
If you can't change your base class you can still use it by adding it to the test case setUp/tearDown
.. code-block:: python
class TestRun(omni.kit.test.AsyncTestCase):
async def setUp(self):
self.configuration = ogts.OmniGraphTestConfiguration(clear_on_start=True)
await self.configuration.__enter__()
async def tearDown(self):
await self.configuration.__exit__()
async def test_without_clearing(self):
run_my_test()
It also has the ability to include user-defined contexts as part of the test configuration, which will be
unwound in the order added using the standard *contextlib.{A}ExitStack()* functionality.
.. code-block:: python
@contextmanager
def my_context():
resource = acquire_my_resource()
try:
yield 1
finally:
release_my_resource(resource)
@asynccontextmanager
async def my_async_context():
resource = await acquire_my_async_resource()
try:
yield 1
finally:
await release_my_async_resource(resource)
my_configuration = OmniGraphTestConfiguration(contexts=[my_context], async_contexts=[my_async_context])
MyCustomClass = ogts.construct_test_class(configuration=my_configuration)
class TestRun(MyCustomClass):
async def test_without_clearing(self):
run_my_test()
"""
def __init__(self, **kwargs):
"""Construct the stack objects that will hold the test contexts
Args:
clear_on_start (bool=False): Clear the scene before the test starts
clear_on_finish (bool=False): Clear the scene after the test ends
settings (dict=None): Dictionary of settingName:value to set while the test runs and restore after
contexts (list=None): List of contextmanager functions or decorated classes to wrap the test runs
async_contexts (list=None): List of asynccontextmanager functions or decorated classes to wrap the test runs
extensions_enabled (list=None): List of the names of extensions to temporarily enable for the test
extensions_disabled (list=None): List of the names of extensions to temporarily disable for the test
Note:
Be careful when using the extensions_{en,dis}abled options to ensure that you do not inadvertently force a
hot reload of the extension containing the test.
"""
self.stack = ExitStack()
self.async_stack = AsyncExitStack()
self.__kwargs = dict(kwargs)
# --------------------------------------------------------------------------------------------------------------
def __set_up_stack(self):
"""Define the parts of the ExitStack requested by the current keyword args"""
@contextmanager
def __enable_extensions(extensions: list[str]):
manager = omni.kit.app.get_app().get_extension_manager()
try:
for name in extensions:
manager.set_extension_enabled_immediate(name, True)
yield True
finally:
pass
@contextmanager
def __disable_extensions(extensions: list[str]):
manager = omni.kit.app.get_app().get_extension_manager()
try:
for name in extensions:
manager.set_extension_enabled_immediate(name, False)
yield True
finally:
pass
for key, value in self.__kwargs.items():
if key == "settings":
for setting, temporary_value in value.items():
self.stack.enter_context(og.Settings.temporary(setting, temporary_value))
elif key == "extensions_enabled":
self.stack.enter_context(__enable_extensions(value))
elif key == "extensions_disabled":
self.stack.enter_context(__disable_extensions(value))
elif key == "contexts":
if not isinstance(value, list):
value = [value]
for context in value:
self.stack.enter_context(context())
# --------------------------------------------------------------------------------------------------------------
async def __set_up_async_stack(self):
"""Define the parts of the AsyncExitStack requested by the current keyword args"""
@asynccontextmanager
async def __clear_scene_on_enter():
try:
yield await omni.usd.get_context().new_stage_async()
finally:
pass
@asynccontextmanager
async def __clear_scene_on_exit():
try:
yield None
finally:
await omni.usd.get_context().new_stage_async()
for key, value in self.__kwargs.items():
if key == "clear_on_start" and value:
await self.async_stack.enter_async_context(__clear_scene_on_enter())
if key == "clear_on_finish" and value:
await self.async_stack.enter_async_context(__clear_scene_on_exit())
if key == "async_contexts":
if not isinstance(value, list):
value = [value]
for context in value:
await self.async_stack.enter_async_context(context())
# --------------------------------------------------------------------------------------------------------------
def __enter__(self):
"""When used as a context manager this class calls this at the start of a 'with' clause"""
self.__set_up_stack()
asyncio.ensure_future(self.__set_up_async_stack())
self.stack.__enter__()
asyncio.ensure_future(self.async_stack.__aenter__())
def __exit__(self, exc_type=None, exc_value=None, exc_tb=None):
"""When used as a context manager this class calls this at the end of a 'with' clause"""
self.stack.__exit__(exc_type, exc_value, exc_tb)
asyncio.ensure_future(self.async_stack.__aexit__(exc_type, exc_value, exc_tb))
# --------------------------------------------------------------------------------------------------------------
async def __aenter__(self):
"""When used as an async context manager this class calls this at the start of a 'with' clause"""
self.__set_up_stack()
await self.__set_up_async_stack()
self.stack.__enter__()
await self.async_stack.__aenter__()
async def __aexit__(self, exc_type=None, exc_value=None, exc_tb=None):
"""When used as an async context manager this class calls this at the end of a 'with' clause"""
self.stack.__exit__(exc_type, exc_value, exc_tb)
await self.async_stack.__aexit__(exc_type, exc_value, exc_tb)
# ==============================================================================================================
def construct_test_class(**kwargs):
"""Construct a new test case base class that configures the test in a predictable way.
You can use the same parameters as :py:class:`OmniGraphTestConfiguration` to configure your test class,
or you can construct one and pass it in as an argument
Args:
configuration (OmniGraphTestConfiguration): Full configuration definition
deprecated (str | tuple[str, DeprecationLevel]): Used when this instantiation of the class has been deprecated
base_class (object): Alternative base class for the test case, defaults to omni.kit.test.AsyncTestCase
Other arguments can be seen in the parameters to :py:func:`OmniGraphTestConfiguration.setUp`
Raises:
TypeError if a base class was specified that is also a constructed class
"""
# Check to see if an alternative base class was passed in
base_class = kwargs.get("base_class", omni.kit.test.AsyncTestCase)
# Issue the deprecation message if specified, but continue on
deprecation = kwargs.get("deprecated", None)
try:
configuration = kwargs["configuration"]
if not isinstance(configuration, OmniGraphTestConfiguration):
raise TypeError(f"configuration only accepts type OmniGraphTestConfiguration, not {type(configuration)}")
except KeyError:
configuration = OmniGraphTestConfiguration(**kwargs)
# --------------------------------------------------------------------------------------------------------------
# Construct the customized test case base class object using the temporary setting and base class information
class OmniGraphCustomTestCase(base_class):
"""A custom constructed test case base class that performs the prescribed setUp and tearDown actions."""
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
self.__configuration = configuration
self.__deprecation = deprecation
async def setUp(self):
"""Set up the test by saving and then setting up all of the action contexts"""
# Start with no test failures registered
og.set_test_failure(False)
if inspect.iscoroutinefunction(super().setUp):
await super().setUp()
else:
super().setUp()
if self.__deprecation is not None:
if isinstance(self.__deprecation, tuple):
if len(self.__deprecation) != 2:
raise ValueError(
"deprecation argument can only be a message or (message, level) pair"
f" - saw {self.__deprecation}"
)
ogt.DeprecateMessage.deprecated(self.__deprecation[0], self.__deprecation[1])
else:
ogt.DeprecateMessage.deprecated(self.__deprecation)
await self.__configuration.__aenter__() # noqa PLC2801
async def tearDown(self):
"""Complete the test by tearing down all of the action contexts"""
await self.__configuration.__aexit__()
if inspect.iscoroutinefunction(super().setUp):
await super().tearDown()
else:
super().tearDown()
# Recursive class definition is more complicated and can be done other ways
if base_class.__name__ == "OmniGraphCustomTestCase":
raise TypeError(
"Recursive class definition is not supported (construct_test_class(base_class=construct_test_class(...)))"
)
# Return the constructed class definition
return OmniGraphCustomTestCase
| 13,880 | Python | 43.777419 | 120 | 0.596974 |
omniverse-code/kit/exts/omni.graph/omni/graph/core/tests/test_node_type_forwarding.py | """Tests that exercise the INodeTypeForwarding interface"""
import omni.graph.core._unstable as ogu
import omni.graph.core.tests as ogts
import omni.kit.test
import omni.usd
# ==============================================================================================================
class TestNodeTypeForwarding(omni.kit.test.AsyncTestCase):
async def test_bindings(self):
"""Tests that the bindings for the ABI operate as expected"""
interface_class = ogu.INodeTypeForwarding
ogts.validate_abi_interface(
interface_class,
instance_methods=[
"define_forward",
"remove_forward",
"remove_forwarded_type",
],
static_methods=[
"find_forward",
"get_forwarding",
],
properties=["forward_count"],
)
get_interface = ogu.get_node_type_forwarding_interface
self.assertIsNotNone(get_interface)
interface = get_interface()
self.assertIsNotNone(interface)
self.assertTrue(isinstance(interface, ogu.INodeTypeForwarding))
try:
# Try defining a simple forward
original_forwarding = interface.forward_count
replacement = ("ReplacementNodeType", 1, "omni.test.extension")
original = ("ForwardedNodeType", 2)
self.assertTrue(interface.define_forward(*original, *replacement))
self.assertEqual(original_forwarding + 1, interface.forward_count)
all_forwarding = interface.get_forwarding()
self.assertEqual(all_forwarding[original], replacement)
found_forward = interface.find_forward(*original)
self.assertEqual(found_forward, replacement)
# Define a second forward
secondary_replacement = ("SecondNodeType", 4, "omni.test.extension")
secondary = ("SomeOtherNodeType", 2)
self.assertTrue(interface.define_forward(*secondary, *secondary_replacement))
self.assertEqual(original_forwarding + 2, interface.forward_count)
all_forwarding = interface.get_forwarding()
self.assertEqual(all_forwarding[original], replacement)
self.assertEqual(all_forwarding[secondary], secondary_replacement)
# Define a chained forward ("ChainedNodeType", 1) -> ("ReplacementNodeType", 1) -> ("ForwardedNodeType", 2)
chained_replacement = ("ChainedNodeType", 1, "omni.test.extension")
chained = (replacement[0], replacement[1])
self.assertTrue(interface.define_forward(*chained, *chained_replacement))
found_forward = interface.find_forward(*chained)
self.assertEqual(found_forward, chained_replacement)
found_forward = interface.find_forward(*original)
self.assertEqual(found_forward, chained_replacement)
# Define a few forwarding for the same node type at different versions
# ("ReplacementNodeType", 1) -> ("ForwardedNodeType", 2, "omni.test.extension")
# ("ReplacementNodeType", 3) -> ("BetterNodeType", 1, "omni.borg.extension")
# ("ReplacementNodeType", 7) -> ("SecondaryNodeType", 4, "omni.test.extension")
better_replacement = ("BetterNodeType", 4, "omni.borg.extension")
latest_forward = (replacement[0], replacement[1] + 2)
self.assertTrue(interface.define_forward(*latest_forward, *better_replacement))
prototype_forward = (replacement[0], replacement[1] + 6)
self.assertTrue(interface.define_forward(*prototype_forward, *secondary_replacement))
# What the "replacement" forward is expected to map to for the version equal to the index of the list...
expected_versions = [
chained_replacement,
chained_replacement,
better_replacement,
better_replacement,
better_replacement,
better_replacement,
secondary_replacement,
secondary_replacement,
secondary_replacement,
]
for index, version_to_test in enumerate(expected_versions):
self.assertEqual(
version_to_test,
interface.find_forward(replacement[0], index + 1),
f"Checking {replacement[0]}-{index + 1} maps to {version_to_test}",
)
# Ensure that attempting to look up a version earlier than the first forward returns nothing
early_version = (replacement[0], 0)
with self.assertRaises(ValueError):
interface.find_forward(*early_version)
# Attempt to define a circular forward, which should not be allowed
circular = (chained_replacement[0], chained_replacement[1])
with ogts.ExpectedError():
self.assertFalse(interface.define_forward(*circular, *chained_replacement))
# Attempt to define a multiple-step circular forward, which should not be allowed
# ("ChainedNodeType", 1) -> ("ReplacementNodeType", 1) -> ("ForwardedNodeType", 2) -> ("ChainedNodeType", 1)
with ogts.ExpectedError():
self.assertFalse(interface.define_forward(*chained, original[0], original[1], "omni.test.extension"))
# Attempt to redefine the same forward, which should not be allowed
with ogts.ExpectedError():
self.assertFalse(interface.define_forward(*chained, *chained_replacement))
finally:
# Remove all of the forwarding, in reverse order so that earlier failures clean up after themselves
self.assertTrue(interface.remove_forward(*prototype_forward))
self.assertTrue(interface.remove_forward(*latest_forward))
self.assertTrue(interface.remove_forward(*chained))
self.assertTrue(interface.remove_forward(*secondary))
self.assertTrue(interface.remove_forward(*original))
self.assertEqual(original_forwarding, interface.forward_count)
| 6,172 | Python | 50.016529 | 120 | 0.613901 |
omniverse-code/kit/exts/omni.graph/omni/graph/core/tests/test_extension_unloads.py | """
Tests related to omnigraph state/api when extensions get unloaded.
"""
from contextlib import suppress
import carb
import omni.graph.core as og
import omni.graph.core.tests as ogt
import omni.kit.app
import omni.kit.commands
import omni.kit.test
import omni.usd
# ======================================================================
class TestExtensionUnloads(ogt.OmniGraphTestCase):
# -----------------------------------------------------------------------
async def test_nodetype_when_extension_unloads(self):
"""Tests that nodes lose their node type when their extension unloads"""
node_type = "omni.graph.examples.cpp.Simple"
examples_cpp_extension = "omni.graph.examples.cpp"
manager = omni.kit.app.get_app_interface().get_extension_manager()
# If the extension is not found then the test cannot run
examples_cpp_extension_id = None
with suppress(Exception):
examples_cpp_extension_id = manager.get_extension_id_by_module(examples_cpp_extension)
if not examples_cpp_extension_id:
carb.log_warn(
f"test_nodetype_when_extension_unloads cannot run since {examples_cpp_extension} was not found"
)
return
examples_cpp_enabled = manager.is_extension_enabled(examples_cpp_extension)
try:
manager.set_extension_enabled_immediate(examples_cpp_extension, True)
# create a graph with a node from the extension
keys = og.Controller.Keys
controller1 = og.Controller()
(_, nodes, _, _) = controller1.edit(
"/World/Graph",
{
keys.CREATE_NODES: [
("Node", node_type),
],
},
)
self.assertTrue(nodes[0].get_node_type().is_valid())
self.assertEquals(nodes[0].get_node_type().get_node_type(), node_type)
# disable the extension, and validate the node type changes to a default type
# the type is still valid, but is a default type
manager.set_extension_enabled_immediate(examples_cpp_extension, False)
self.assertTrue(nodes[0].get_node_type().is_valid())
self.assertEquals(nodes[0].get_node_type().get_node_type(), None)
# re-enable the extension and validate the node type is restored
manager.set_extension_enabled_immediate(examples_cpp_extension, True)
self.assertTrue(nodes[0].get_node_type().is_valid())
self.assertEquals(nodes[0].get_node_type().get_node_type(), node_type)
finally:
manager.set_extension_enabled_immediate(examples_cpp_extension, examples_cpp_enabled)
| 2,765 | Python | 40.283581 | 111 | 0.594575 |
omniverse-code/kit/exts/omni.graph/omni/graph/core/tests/expected_error.py | # --------------------------------------------------------------------------------------------------------------
class ExpectedError:
"""
Helper class used to prefix any pending error messages with [Expected Error]
stdoutFailPatterns.exclude (defined in extension.toml) will cause these errors
to be ignored when running tests.
Note that it will prepend only the first error.
Usage:
with ExpectedError():
function_that_produced_error_output()
"""
def __enter__(self):
# Preflush any output, otherwise it may be appended to the next statement.
print("", flush=True)
# Output the prefix string without a newline so that the error to be ignored will appear on
# the same line. We do NOT want to flush this because that could allow output from another thread
# to appear between the prefix and the error message.
print("[Ignore this error/warning] ", end="", flush=False)
def __exit__(self, exit_type, value, traceback):
# Print a newline, to avoid actual errors being ignored.
print("", flush=True)
| 1,122 | Python | 39.107141 | 112 | 0.600713 |
omniverse-code/kit/exts/omni.graph/omni/graph/core/tests/test_bundle_hierarchy.py | import omni.graph.core as og
import omni.graph.core.tests as ogt
class BundleTestSetup(ogt.OmniGraphTestCase):
async def setUp(self):
"""Set up test environment, to be torn down when done"""
await super().setUp()
self.graph = og.Controller.create_graph("/graph")
self.context = self.graph.get_default_graph_context()
self.factory = og.IBundleFactory.create()
self.assertTrue(self.factory is not None)
# bundle paths
self.bundle1Name = "bundle1"
self.bundle2Name = "bundle2"
self.bundle3Name = "bundle3"
self.bundle4Name = "bundle4"
# attribute names
self.attr1Name = "attr1"
self.attr2Name = "attr2"
# attribute types
self.attr1Type = og.Type(og.BaseDataType.INT)
self.attr2Type = og.Type(og.BaseDataType.FLOAT)
self.bundle1 = self.factory.create_bundle(self.context, self.bundle1Name)
self.assertTrue(self.bundle1.valid)
# ------------------------------------------------------------------ #
# FOLLOWING TESTS ARE IMPLEMENTATION DETAILS AND MUST NOT BE USED! #
# ------------------------------------------------------------------ #
class TestBundleHierarchyCleanup(BundleTestSetup):
"""This tests exercises cleanup of internals of the bundles."""
async def setUp(self):
"""Set up test environment, to be torn down when done"""
await super().setUp()
def test_recursive_child_bundle_removal(self):
# create hierarchy of bundles
b0 = self.bundle1
b1 = b0.create_child_bundle(self.bundle2Name)
b2 = b1.create_child_bundle(self.bundle3Name)
self.assertTrue(b0)
self.assertTrue(b1)
self.assertTrue(b2)
p0 = f"{self.bundle1Name}"
p1 = f"{self.bundle1Name}/{self.bundle2Name}"
p2 = f"{self.bundle1Name}/{self.bundle2Name}/{self.bundle3Name}"
self.assertTrue(self.factory.get_const_bundle_from_path(self.context, p0))
self.assertTrue(self.factory.get_const_bundle_from_path(self.context, p1))
self.assertTrue(self.factory.get_const_bundle_from_path(self.context, p2))
b0.clear_contents()
# p0 is not removed, only the descendants will be gone
self.assertTrue(self.factory.get_const_bundle_from_path(self.context, p0))
self.assertFalse(self.factory.get_const_bundle_from_path(self.context, p1))
self.assertFalse(self.factory.get_const_bundle_from_path(self.context, p2))
def test_recursive_child_bundle_metadata_removal(self):
b0 = self.bundle1
b1 = b0.create_child_bundle(self.bundle2Name)
# create bundle metadata
b0.create_bundle_metadata(self.attr1Name, self.attr1Type)
b1.create_bundle_metadata(self.attr1Name, self.attr1Type)
# create bundle attributes
b0.create_attribute(self.attr1Name, self.attr1Type)
b1.create_attribute(self.attr1Name, self.attr1Type)
# create attribute metadata
b0.create_attribute_metadata(self.attr1Name, self.attr2Name, self.attr2Type)
b1.create_attribute_metadata(self.attr1Name, self.attr2Name, self.attr2Type)
# TODO: Investigate why passing c-string does not work. The conversion from c-string to PathC produces different ids.
p0 = f"{self.bundle1Name}/__metadata__bundle__"
p1 = f"{self.bundle1Name}/__metadata__bundle__/{self.attr1Name}"
p2 = f"{self.bundle1Name}/{self.bundle2Name}/__metadata__bundle__"
p3 = f"{self.bundle1Name}/{self.bundle2Name}/__metadata__bundle__/{self.attr1Name}"
get = self.factory.get_const_bundle_from_path
self.assertTrue(get(self.context, p0))
self.assertTrue(get(self.context, p1))
self.assertTrue(get(self.context, p2))
self.assertTrue(get(self.context, p3))
b0.clear_contents()
self.assertFalse(get(self.context, p0))
self.assertFalse(get(self.context, p1))
self.assertFalse(get(self.context, p2))
self.assertFalse(get(self.context, p3))
def test_recursive_child_remove_with_cow(self):
child_names = [self.bundle2Name, self.bundle3Name]
b0 = self.bundle1
children = b0.create_child_bundles(child_names)
# Copy-on-Write child bundles
b1 = self.factory.create_bundle(self.context, self.bundle4Name)
b1.copy_child_bundles(child_names, children)
# check content
get = self.factory.get_const_bundle_from_path
# original bundle
p0 = f"{self.bundle1Name}"
p1 = f"{self.bundle1Name}/{self.bundle2Name}"
p2 = f"{self.bundle1Name}/{self.bundle3Name}"
self.assertTrue(get(self.context, p0))
self.assertTrue(get(self.context, p1))
self.assertTrue(get(self.context, p2))
# copied children
p0 = f"{self.bundle4Name}"
p1 = f"{self.bundle4Name}/{self.bundle2Name}"
p2 = f"{self.bundle4Name}/{self.bundle3Name}"
self.assertTrue(get(self.context, p0))
self.assertTrue(get(self.context, p1))
self.assertTrue(get(self.context, p2))
# remove shallow copies, but not the original location
b1.clear_contents()
# shallow children are gone
self.assertTrue(get(self.context, p0))
self.assertFalse(get(self.context, p1))
self.assertFalse(get(self.context, p2))
# but original location stays intact
p0 = f"{self.bundle1Name}"
p1 = f"{self.bundle1Name}/{self.bundle2Name}"
p2 = f"{self.bundle1Name}/{self.bundle3Name}"
self.assertTrue(get(self.context, p0))
self.assertTrue(get(self.context, p1))
self.assertTrue(get(self.context, p2))
| 5,734 | Python | 36.980132 | 125 | 0.637077 |
omniverse-code/kit/exts/omni.graph/omni/graph/core/tests/validation.py | """Support for validation of content"""
import inspect
from enum import Enum
# ==============================================================================================================
class _FunctionType(Enum):
"""Enumeration to make an easy tag type for function type definitions"""
FUNCTION = "function"
"""Type is an untethered function"""
STATIC = "staticmethod"
"""Type is a static method of a class"""
CLASS = "classmethod"
"""Type is a class method (with cls) of a class"""
INSTANCE = "instancemethod"
"""Type is an instance method (with self) of a class"""
NOT_A_FUNCTION = "unknown"
"""Type is not a recognized function type"""
# ==============================================================================================================
def _get_pybind_function_type(func: any) -> _FunctionType:
"""Check to see if the object is a function type of some kind.
The way to check if a function from a pybind interface is static or not is quite different from how you would
check regular functions. The regular methods are instancemethod types, as expected, but the static methods are
classified as builtin methods. The parent class is always PyCapsule so the assumption has to be made that anything
passed in here already belongs to the interface being tested.
Args:
func (any): The object to inspect
Returns:
_FunctionType|None: The type of function @p func is or None if it is not a function
"""
if not inspect.isroutine(func):
return None
function_type = type(func)
if func.__name__ == func.__qualname__ or ".<locals>" in func.__qualname__:
return _FunctionType.FUNCTION
if function_type.__name__ == "builtin_function_or_method":
return _FunctionType.STATIC
if function_type.__name__ == "instancemethod":
return _FunctionType.INSTANCE
return _FunctionType.CLASS
# ==============================================================================================================
def validate_abi_interface(
interface: any,
instance_methods: list[str] = None,
static_methods: list[str] = None,
class_methods: list[str] = None,
properties: list[str] = None,
constants: list[tuple[str, any]] = None,
):
"""Validate an ABI interface's expected contents
Args:
interface (any): The interface object to validate
instance_methods (list[str]): Names of interface members expected to be regular object functions
static_methods (list[str]): Names of interface members expected to be static object functions
class_methods (list[str]): Names of interface members expected to be class level functions
properties (list[str]): Names of interface members expected to be object properties
constants (list[str]): Names and types of interface members expected to be constant object values
Raises:
ValueError: if the interface was not consistent with the expected contents
"""
# Convert members to forms easier to compare
actual_members = {function_name for function_name in dir(interface) if not function_name.startswith("_")}
expected_instance_method_names = set(instance_methods or [])
expected_static_method_names = set(static_methods or [])
expected_class_method_names = set(class_methods or [])
expected_property_names = set(properties or [])
expected_constant_definitions = set(constants or [])
expected_members = (
expected_instance_method_names.union(expected_property_names)
.union(expected_static_method_names)
.union(expected_class_method_names)
.union(name for (name, _) in expected_constant_definitions)
)
unexpected = actual_members - expected_members
not_found = expected_members - actual_members
errors = []
if unexpected:
errors.append(f"Unexpected interface members found - {unexpected}")
if not_found:
errors.append(f"Expected interface members not found - {not_found}")
def _validate_function_type(function_names: list[str], expected_type: _FunctionType):
"""Check that a list of function names have the given type, adding to 'errors' if not"""
for function_name in function_names:
function = getattr(interface, function_name, None)
if not callable(function):
errors.append(f"Expected function {function_name} was not a callable function, it was {type(function)}")
return
function_type = _get_pybind_function_type(function)
if function_type != expected_type:
errors.append(f"Expected function {function_name} to be {expected_type.value}, it was {function_type}")
# Validate the expected functions
_validate_function_type(expected_instance_method_names, _FunctionType.INSTANCE)
_validate_function_type(expected_class_method_names, _FunctionType.CLASS)
_validate_function_type(expected_static_method_names, _FunctionType.STATIC)
# Validate the expected properties
for property_name in expected_property_names:
property_member = getattr(interface, property_name, None)
if not isinstance(property_member, property):
errors.append(f"Expected property {property_name} was not a property, it was {type(property_member)}")
# The constants are already known to be present, now their types must be checked
for constant_name, constant_type in expected_constant_definitions:
constant_member = getattr(interface, constant_name, None)
if not isinstance(constant_member, constant_type):
errors.append(
f"Expected constant {constant_name} to be type {constant_type}, it was {type(constant_member)}"
)
# Raise an exception if any errors were found
if errors:
formatted_errors = "\n ".join(errors)
raise ValueError(f"Errors with interface {interface}\n {formatted_errors}")
| 5,999 | Python | 45.875 | 120 | 0.647441 |
omniverse-code/kit/exts/omni.graph/omni/graph/core/tests/test_bundles.py | import omni.core as oc
import omni.graph.core as og
import omni.graph.core.tests as ogt
class BundleTestCase(ogt.OmniGraphTestCase):
async def setUp(self):
"""Set up test environment, to be torn down when done"""
await super().setUp()
self.graph = og.Controller.create_graph("/graph")
self.context = self.graph.get_default_graph_context()
self.factory = og.IBundleFactory.create()
self.assertTrue(self.factory is not None)
# bundle paths
self.bundle1Name = "bundle1"
self.bundle2Name = "bundle2"
self.bundle3Name = "bundle3"
self.bundle4Name = "bundle4"
self.bundle5Name = "bundle5"
# attribute names
self.attr1Name = "attr1"
self.attr2Name = "attr2"
self.attr3Name = "attr3"
self.attr4Name = "attr4"
# attribute types
self.attr1Type = og.Type(og.BaseDataType.INT)
self.attr2Type = og.Type(og.BaseDataType.FLOAT)
self.attr3Type = og.Type(og.BaseDataType.DOUBLE, 1, 1)
self.attr4Type = og.Type(og.BaseDataType.BOOL, 1, 1)
self.bundle1 = self.factory.create_bundle(self.context, self.bundle1Name)
self.assertTrue(self.bundle1.valid)
async def test_create_bundle(self):
# Check bundle1 does not have a parent bundle.
parent1 = self.bundle1.get_parent_bundle()
self.assertFalse(parent1.valid)
# Check bundle path.
self.assertEqual(self.bundle1.get_path(), self.bundle1Name)
# Test state of attributes.
self.assertEqual(self.bundle1.get_attribute_count(), 0)
self.assertEqual(len(self.bundle1.get_attribute_names()), 0)
self.assertEqual(len(self.bundle1.get_attribute_types()), 0)
self.assertEqual(len(self.bundle1.get_attributes()), 0)
# Test state of child bundles.
self.assertEqual(self.bundle1.get_child_bundle_count(), 0)
self.assertEqual(len(self.bundle1.get_child_bundles()), 0)
async def test_create_child_bundle(self):
# Create bundle hierarchy: bundle1/bundle2/bundle3.
bundle2 = self.bundle1.create_child_bundle(self.bundle2Name)
self.assertTrue(bundle2.valid)
self.assertEqual(bundle2.get_name(), self.bundle2Name)
# Check number of children.
self.assertEqual(self.bundle1.get_child_bundle_count(), 1)
self.assertEqual(bundle2.get_child_bundle_count(), 0) # leaf, no children
self.assertEqual(len(self.bundle1.get_child_bundles()), 1)
self.assertEqual(len(bundle2.get_child_bundles()), 0)
async def test_create_child_bundles(self):
# Create bundle hierarchy: bundle1/bundle2/bundle3.
bundle_paths = [self.bundle2Name, self.bundle3Name]
self.bundle1.create_child_bundles(bundle_paths)
self.assertEqual(self.bundle1.get_child_bundle_count(), 2)
async def test_bundle_parent(self):
# Create hierarchy: bundle1/bundle2/bundle3.
bundle2 = self.bundle1.create_child_bundle(self.bundle2Name)
self.assertTrue(bundle2.valid)
# Check children paths.
self.assertEqual(bundle2.get_path(), "/".join([self.bundle1Name, self.bundle2Name]))
# Check parents paths.
bundle2_parent = bundle2.get_parent_bundle()
self.assertTrue(bundle2_parent.valid)
self.assertEqual(bundle2_parent.get_path(), self.bundle1.get_path())
async def test_remove_child_bundle(self):
# Create hierarchy: bundle1/bundle2/bundle3.
bundle2 = self.bundle1.create_child_bundle(self.bundle2Name)
self.assertTrue(bundle2.valid)
bundle3 = bundle2.create_child_bundle(self.bundle3Name)
self.assertTrue(bundle3.valid)
# We can only remove intermediate children, remove children from bundle1 must fail.
# Disabled because of: OM-48629. Re-enable after OM-48828 is solved.
# with ExpectedError():
# self.assertEqual(self.bundle1.remove_all_child_bundles(), 0) # remove bundle2 from bundle1
# bundle3 is not an intermediate child of bundle1.
self.assertFalse(self.bundle1.remove_child_bundle(bundle3))
self.assertEqual(bundle2.remove_child_bundle(bundle3), oc.Result.SUCCESS)
self.assertEqual(self.bundle1.remove_child_bundle(bundle2), oc.Result.SUCCESS)
async def test_remove_child_bundles(self):
# Create bundle hierarchy.
bundle2 = self.bundle1.create_child_bundle(self.bundle2Name)
self.assertTrue(bundle2.valid)
bundle3 = self.bundle1.create_child_bundle(self.bundle3Name)
self.assertTrue(bundle3.valid)
# Get child bundles.
bundles = self.bundle1.get_child_bundles()
self.assertEqual(len(bundles), 2)
# Remove all child bundles that are in the array.
self.bundle1.remove_child_bundles(bundles)
self.assertEqual(self.bundle1.get_child_bundle_count(), 0)
async def test_remove_child_bundles_by_name(self):
_ = self.bundle1.create_child_bundle(self.bundle2Name)
_ = self.bundle1.create_child_bundle(self.bundle3Name)
_ = self.bundle1.create_child_bundle(self.bundle4Name)
self.bundle1.remove_child_bundles_by_name([self.bundle2Name, self.bundle4Name])
self.assertEqual(self.bundle1.get_child_bundle_count(), 1)
children = self.bundle1.get_child_bundles()
self.assertEqual(len(children), 1)
self.assertEqual(children[0].get_path(), "{}/{}".format(self.bundle1Name, self.bundle3Name))
async def test_copy_child_bundle(self):
child = self.bundle1.create_child_bundle("child")
new_bundle = self.factory.create_bundle(self.context, "new_bundle")
new_bundle.copy_child_bundle(child)
self.assertEqual(new_bundle.get_child_bundle_count(), 1)
new_child = new_bundle.get_child_bundle_by_name("child")
self.assertTrue(new_child.valid)
async def test_copy_child_bundle_with_name(self):
child = self.bundle1.create_child_bundle("child")
new_bundle = self.factory.create_bundle(self.context, "new_bundle")
new_bundle.copy_child_bundle(child, name="foo")
self.assertEqual(new_bundle.get_child_bundle_count(), 1)
new_child = new_bundle.get_child_bundle_by_name("child")
self.assertFalse(new_child.valid)
new_child = new_bundle.get_child_bundle_by_name("foo")
self.assertTrue(new_child.valid)
async def test_copy_child_bundles(self):
children = self.bundle1.create_child_bundles(["childA", "childB"])
new_bundle = self.factory.create_bundle(self.context, "new_bundle")
new_bundle.copy_child_bundles(children)
self.assertEqual(new_bundle.get_child_bundle_count(), 2)
new_children = new_bundle.get_child_bundles_by_name(["childA", "childB"])
self.assertEqual(len(new_children), 2)
self.assertTrue(new_children[0].valid)
self.assertTrue(new_children[1].valid)
async def test_copy_child_bundles_with_names(self):
children = self.bundle1.create_child_bundles(["childA", "childB"])
new_bundle = self.factory.create_bundle(self.context, "new_bundle")
new_bundle.copy_child_bundles(children, names=["foo", "bar"])
self.assertEqual(new_bundle.get_child_bundle_count(), 2)
new_children = new_bundle.get_child_bundles_by_name(["foo", "bar"])
self.assertEqual(len(new_children), 2)
self.assertTrue(new_children[0].valid)
self.assertTrue(new_children[1].valid)
async def test_get_child_bundles_by_name(self):
_ = self.bundle1.create_child_bundle(self.bundle2Name)
_ = self.bundle1.create_child_bundle(self.bundle3Name)
search = [self.bundle2Name, self.bundle3Name, self.bundle4Name]
bundles = self.bundle1.get_child_bundles_by_name(search)
self.assertTrue(bundles[0].valid)
self.assertTrue(bundles[1].valid)
self.assertFalse(bundles[2].valid)
async def test_get_child_bundle_by_name(self):
_ = self.bundle1.create_child_bundle(self.bundle2Name)
_ = self.bundle1.create_child_bundle(self.bundle3Name)
b2 = self.bundle1.get_child_bundle_by_name(self.bundle2Name)
self.assertTrue(b2.valid)
b3 = self.bundle1.get_child_bundle_by_name(self.bundle3Name)
self.assertTrue(b3.valid)
b4 = self.bundle1.get_child_bundle_by_name(self.bundle4Name)
self.assertFalse(b4.valid)
async def test_create_and_get_attribute(self):
# Create each attribute individually.
_ = self.bundle1.create_attribute(self.attr1Name, self.attr1Type)
self.assertEqual(self.bundle1.get_attribute_count(), 1)
attr = self.bundle1.get_attribute_by_name(self.attr1Name)
self.assertFalse(attr is None)
self.assertEqual(attr.get_name(), self.attr1Name)
async def test_create_and_get_attributes(self):
# Create attributes by providing array of names and types.
names = [self.attr1Name, self.attr2Name, self.attr3Name]
types = [self.attr1Type, self.attr2Type, self.attr3Type]
self.bundle1.create_attributes(names, types)
self.assertEqual(self.bundle1.get_attribute_count(), 3)
# Get all attributes.
attrs = self.bundle1.get_attributes()
self.assertEqual(len(attrs), 3)
attrs = {x.get_name(): x for x in attrs if x.is_valid()}
self.assertEqual(len(attrs), 3)
self.assertTrue(self.attr1Name in attrs)
self.assertTrue(self.attr2Name in attrs)
self.assertTrue(self.attr3Name in attrs)
# Find existing attributes.
attrs_query = [self.attr1Name, self.attr3Name]
attrs = self.bundle1.get_attributes_by_name(attrs_query)
self.assertEqual(len(attrs), 2)
attrs = {x.get_name(): x for x in attrs if x}
self.assertEqual(len(attrs), 2)
self.assertTrue(self.attr1Name in attrs)
self.assertTrue(self.attr3Name in attrs)
self.assertTrue(attrs[self.attr1Name])
self.assertTrue(attrs[self.attr3Name])
# Attempt to find not existing attributes.
attrs_query = [self.attr4Name]
attrs = self.bundle1.get_attributes_by_name(attrs_query)
self.assertEqual(len(attrs), 1)
attrs = {x.get_name(): x for x in attrs if x}
self.assertEqual(len(attrs), 0)
async def test_create_array_attribute(self):
# Create array attribute.
attr3 = self.bundle1.create_attribute(self.attr3Name, self.attr3Type, 1000)
self.assertTrue(attr3)
self.assertEqual(attr3.size(), 1000)
attr3 = self.bundle1.create_attribute(self.attr3Name, self.attr3Type, 0)
self.assertEqual(attr3.size(), 0)
async def test_create_attribute_like(self):
attr1 = self.bundle1.create_attribute(self.attr1Name, self.attr1Type)
# Create new bundle and create attribute like.
bundle2 = self.factory.create_bundle(self.context, self.bundle2Name)
like_attr1 = bundle2.create_attribute_like(attr1)
self.assertTrue(like_attr1)
self.assertEqual(like_attr1.get_name(), self.attr1Name)
self.assertEqual(like_attr1.get_type(), self.attr1Type)
async def test_create_attributes_like(self):
# Create attributes in bundle1.
names = [self.attr1Name, self.attr2Name]
types = [self.attr1Type, self.attr2Type]
attrs = self.bundle1.create_attributes(names, types)
# Create bundle2 and create attributes like those from bundle1.
bundle2 = self.factory.create_bundle(self.context, self.bundle2Name)
like_attrs = bundle2.create_attributes_like(attrs)
like_attrs = {x.get_name(): x for x in like_attrs if x}
self.assertEqual(len(like_attrs), 2)
self.assertTrue(self.attr1Name in like_attrs)
self.assertTrue(self.attr2Name in like_attrs)
async def test_remove_attributes(self):
# Create attributes in bundle1.
attr1 = self.bundle1.create_attribute(self.attr1Name, self.attr1Type)
attr2 = self.bundle1.create_attribute(self.attr2Name, self.attr2Type)
# Remove one attribute from bundle.
self.assertEqual(self.bundle1.remove_attribute(attr2), oc.Result.SUCCESS)
self.assertEqual(self.bundle1.get_attribute_count(), 1)
# Try to remove non existing attributes.
bundle2 = self.factory.create_bundle(self.context, self.bundle2Name)
self.assertEqual(bundle2.remove_attributes([attr1, attr2]), 0)
async def test_remove_attributes_by_name(self):
_ = self.bundle1.create_attribute(self.attr1Name, self.attr1Type)
_ = self.bundle1.create_attribute(self.attr2Name, self.attr2Type)
_ = self.bundle1.create_attribute(self.attr3Name, self.attr3Type)
self.bundle1.remove_attributes_by_name([self.attr1Name, self.attr3Name])
self.assertEqual(self.bundle1.get_attribute_count(), 1)
names = self.bundle1.get_attribute_names()
self.assertEqual(len(names), 1)
self.assertEqual(names[0], self.attr2Name)
async def test_copy_attribute(self):
attr1 = self.bundle1.create_attribute(self.attr1Name, self.attr1Type)
self.assertTrue(attr1)
# Create bundle2 and copy attr1 from bundle1.
bundle2 = self.factory.create_bundle(self.context, self.bundle2Name)
cpy_attr1 = bundle2.copy_attribute(attr1)
self.assertTrue(cpy_attr1)
self.assertEqual(cpy_attr1.get_type(), self.attr1Type)
async def test_copy_attributes(self):
# Create attributes.
names = [self.attr1Name, self.attr2Name]
types = [self.attr1Type, self.attr2Type]
src_attrs1 = self.bundle1.create_attributes(names, types)
names = [self.attr3Name, self.attr4Name]
types = [self.attr3Type, self.attr4Type]
bundle2 = self.factory.create_bundle(self.context, self.bundle2Name)
src_attrs2 = bundle2.create_attributes(names, types)
# Create bundle3 and copy attributes from bundle1 and bundle2.
bundle3 = self.factory.create_bundle(self.context, self.bundle3Name)
src_attrs = src_attrs2 + src_attrs1 # reversed elements
cpy_attrs = bundle3.copy_attributes(src_attrs)
self.assertEqual(len(cpy_attrs), 4)
# Check if attributes are valid.
cpy_attrs = {x.get_name(): x for x in cpy_attrs if x}
self.assertEqual(len(cpy_attrs), 4)
# Get copied attributes by name.
cpy_attr1 = bundle3.get_attribute_by_name(self.attr1Name)
cpy_attr2 = bundle3.get_attribute_by_name(self.attr2Name)
cpy_attr3 = bundle3.get_attribute_by_name(self.attr3Name)
cpy_attr4 = bundle3.get_attribute_by_name(self.attr4Name)
# Copied attributes must be valid.
self.assertTrue(cpy_attr1.is_valid())
self.assertTrue(cpy_attr2.is_valid())
self.assertTrue(cpy_attr3.is_valid())
self.assertTrue(cpy_attr4.is_valid())
# Check copied attributes types.
self.assertEqual(cpy_attr1.get_type(), self.attr1Type)
self.assertEqual(cpy_attr2.get_type(), self.attr2Type)
self.assertEqual(cpy_attr3.get_type(), self.attr3Type)
self.assertEqual(cpy_attr4.get_type(), self.attr4Type)
async def test_copy_attributes_override(self):
# create double on bundle1
d_attr = self.bundle1.create_attribute(self.attr1Name, og.Type(og.BaseDataType.DOUBLE, 1, 1), 1000)
self.assertEqual(d_attr.size(), 1000)
# create bool on bundle2
bundle2 = self.factory.create_bundle(self.context, self.bundle2Name)
b_attr = bundle2.create_attribute(self.attr1Name, og.Type(og.BaseDataType.BOOL, 1, 1), 10)
self.assertEqual(b_attr.size(), 10)
# try copy double
attr = bundle2.copy_attribute(d_attr, overwrite=False)
self.assertFalse(attr.is_valid())
# try copy double
attr = bundle2.copy_attribute(d_attr, overwrite=True)
self.assertTrue(attr.is_valid())
self.assertEqual(attr.size(), 1000)
self.assertEqual(attr.get_type().base_type, self.attr3Type.base_type)
async def test_get_path(self):
# Create hierarchy: bundle1/bundle2/bundle3.
bundle1 = self.bundle1
bundle2 = bundle1.create_child_bundle(self.bundle2Name)
self.assertTrue(bundle2.valid)
async def test_create_private_attribute(self):
# This functionality is an implementation detail and should not be abused
bundle = self.factory.create_bundle(self.context, "bundle")
attrib = bundle.create_attribute("__bundle__private__attrib", og.Type(og.BaseDataType.INT))
self.assertTrue(attrib.is_valid())
self.assertEqual(bundle.get_attribute_count(), 0)
async def test_target_attribute_type(self):
target_type = og.Type(og.BaseDataType.RELATIONSHIP, 1, 0, og.AttributeRole.TARGET)
bundle = self.bundle1
bundle.create_attribute("targets", target_type)
self.assertEqual(bundle.get_attribute_count(), 1)
attrib = bundle.get_attributes()[0]
self.assertTrue(attrib.is_valid())
self.assertEqual(attrib.get_type().base_type, og.BaseDataType.RELATIONSHIP)
self.assertEqual(attrib.get_type().role, og.AttributeRole.TARGET)
class TestBundleMetadata(ogt.OmniGraphTestCase):
"""Test bundle metadata management"""
async def setUp(self):
"""Set up test environment, to be torn down when done"""
await super().setUp()
self.graph = og.Controller.create_graph("/graph")
self.context = self.graph.get_default_graph_context()
self.factory = og.IBundleFactory.create()
self.assertTrue(self.factory is not None)
# bundle paths
self.bundle1Name = "bundle1"
self.bundle2Name = "bundle2"
self.bundle3Name = "bundle3"
self.bundle4Name = "bundle4"
self.bundle5Name = "bundle5"
# attribute names
self.attr1Name = "attr1"
self.attr2Name = "attr2"
self.attr3Name = "attr3"
self.attr4Name = "attr4"
# attribute types
self.attr1Type = og.Type(og.BaseDataType.INT)
self.attr2Type = og.Type(og.BaseDataType.FLOAT)
self.attr3Type = og.Type(og.BaseDataType.DOUBLE, 1, 1)
self.attr4Type = og.Type(og.BaseDataType.BOOL, 1, 1)
self.bundle1 = self.factory.create_bundle(self.context, self.bundle1Name)
self.assertTrue(self.bundle1.valid)
async def test_bundle_metadata_create(self):
# check content
self.assertEqual(self.bundle1.get_attribute_count(), 0)
self.assertEqual(self.bundle1.get_child_bundle_count(), 0)
self.assertEqual(self.bundle1.get_bundle_metadata_count(), 0)
# create bundle metadata
field1 = self.bundle1.create_bundle_metadata(self.attr1Name, self.attr1Type)
field2 = self.bundle1.create_bundle_metadata(self.attr2Name, self.attr2Type)
# check content
self.assertEqual(self.bundle1.get_attribute_count(), 0)
self.assertEqual(self.bundle1.get_child_bundle_count(), 0)
self.assertEqual(self.bundle1.get_bundle_metadata_count(), 2)
self.assertTrue(field1.is_valid())
self.assertTrue(field2.is_valid())
# create attributes
self.bundle1.create_attribute(self.attr1Name, self.attr1Type)
self.bundle1.create_attribute(self.attr2Name, self.attr2Type)
# check content
self.assertEqual(self.bundle1.get_attribute_count(), 2)
self.assertEqual(self.bundle1.get_child_bundle_count(), 0)
self.assertEqual(self.bundle1.get_bundle_metadata_count(), 2)
# create children
self.bundle1.create_child_bundle(self.bundle2Name)
self.bundle1.create_child_bundle(self.bundle3Name)
self.assertEqual(self.bundle1.get_attribute_count(), 2)
self.assertEqual(self.bundle1.get_child_bundle_count(), 2)
self.assertEqual(self.bundle1.get_bundle_metadata_count(), 2)
async def test_bundle_metadata_remove_bulk(self):
self.bundle1.create_attribute(self.attr1Name, self.attr1Type)
self.bundle1.create_bundle_metadata([self.attr1Name, self.attr2Name], [self.attr1Type, self.attr2Type])
self.assertEqual(self.bundle1.get_attribute_count(), 1)
self.assertEqual(self.bundle1.get_bundle_metadata_count(), 2)
self.bundle1.remove_bundle_metadata([self.attr1Name, self.attr2Name])
self.assertEqual(self.bundle1.get_attribute_count(), 1)
self.assertEqual(self.bundle1.get_bundle_metadata_count(), 0)
async def test_bundle_metadata_remove_single(self):
self.bundle1.create_attribute(self.attr1Name, self.attr1Type)
self.bundle1.create_bundle_metadata(self.attr1Name, self.attr1Type)
self.bundle1.create_bundle_metadata(self.attr2Name, self.attr2Type)
self.assertEqual(self.bundle1.get_attribute_count(), 1)
self.assertEqual(self.bundle1.get_bundle_metadata_count(), 2)
self.bundle1.remove_bundle_metadata(self.attr1Name)
self.assertEqual(self.bundle1.get_attribute_count(), 1)
self.assertEqual(self.bundle1.get_bundle_metadata_count(), 1)
self.bundle1.remove_bundle_metadata(self.attr2Name)
self.assertEqual(self.bundle1.get_attribute_count(), 1)
self.assertEqual(self.bundle1.get_bundle_metadata_count(), 0)
async def test_bundle_metadata_remove_none(self):
self.assertEqual(self.bundle1.get_attribute_count(), 0)
self.assertEqual(self.bundle1.get_bundle_metadata_count(), 0)
self.bundle1.remove_bundle_metadata(self.attr1Name)
self.assertEqual(self.bundle1.get_attribute_count(), 0)
self.assertEqual(self.bundle1.get_bundle_metadata_count(), 0)
async def test_bundle_metadata_info(self):
"""
Counting number of attributes in metadata bundle.
"""
self.assertEqual(self.bundle1.get_bundle_metadata_count(), 0)
self.assertEqual(len(self.bundle1.get_bundle_metadata_names()), 0)
self.assertEqual(len(self.bundle1.get_bundle_metadata_types()), 0)
# create two metadata attributes
_ = self.bundle1.create_bundle_metadata(self.attr1Name, self.attr1Type)
_ = self.bundle1.create_bundle_metadata(self.attr2Name, self.attr2Type)
# check bundle metadata
self.assertEqual(len(set(self.bundle1.get_bundle_metadata_names())), 2)
self.assertEqual(len(set(self.bundle1.get_bundle_metadata_types())), 2)
self.assertTrue(self.attr1Name in self.bundle1.get_bundle_metadata_names())
self.assertTrue(self.attr2Name in self.bundle1.get_bundle_metadata_names())
async def test_bundle_metadata_child_by_index(self):
"""
Metadata bundle can not be returned in a list of children.
This test confirms that get_child_bundle does not return metadata bundle.
"""
# create two attributes
_ = self.bundle1.create_attribute(self.attr1Name, self.attr1Type)
_ = self.bundle1.create_attribute(self.attr2Name, self.attr2Type)
# create children
ref_paths = [self.bundle2Name, self.bundle3Name, self.bundle4Name, self.bundle5Name]
for i, ref_path in enumerate(ref_paths):
self.bundle1.create_child_bundle(ref_path)
ref_paths[i] = "{}/{}".format(self.bundle1Name, ref_path)
# get child by index
unique_paths = set()
for index in range(len(ref_paths)):
child = self.bundle1.get_child_bundle(index)
unique_paths.add(child.get_path())
self.assertTrue(child.get_path())
self.assertTrue(child.get_path() in ref_paths)
self.assertEqual(len(unique_paths), 4)
async def test_bundle_metadata_by_name(self):
"""
Get bundle metadata by name.
"""
# create two metadata attributes
self.bundle1.create_bundle_metadata(self.attr1Name, self.attr1Type)
self.bundle1.create_bundle_metadata(self.attr2Name, self.attr2Type)
self.assertTrue(self.bundle1.get_bundle_metadata_count(), 2)
attrs = self.bundle1.get_bundle_metadata_by_name([self.attr1Name, self.attr2Name])
self.assertEqual(len(attrs), 2)
self.assertEqual(attrs[0].get_name(), self.attr1Name)
self.assertEqual(attrs[1].get_name(), self.attr2Name)
async def test_metadata_bundle_create_many_fields(self):
self.bundle1.create_bundle_metadata([self.attr1Name, self.attr2Name], [self.attr1Type, self.attr2Type])
self.assertTrue(self.bundle1.get_bundle_metadata_count(), 2)
attrs = self.bundle1.get_bundle_metadata_by_name([self.attr1Name, self.attr2Name])
self.assertEqual(len(attrs), 2)
self.assertEqual(attrs[0].get_name(), self.attr1Name)
self.assertEqual(attrs[1].get_name(), self.attr2Name)
async def test_metadata_bundle_create_single_field(self):
self.bundle1.create_bundle_metadata(self.attr1Name, self.attr1Type)
self.bundle1.create_bundle_metadata(self.attr2Name, self.attr2Type)
self.assertTrue(self.bundle1.get_bundle_metadata_count(), 2)
attrs = self.bundle1.get_bundle_metadata_by_name([self.attr1Name, self.attr2Name])
self.assertEqual(len(attrs), 2)
self.assertEqual(attrs[0].get_name(), self.attr1Name)
self.assertEqual(attrs[1].get_name(), self.attr2Name)
async def test_attribute_metadata_create(self):
# check content
self.assertEqual(self.bundle1.get_attribute_count(), 0)
self.assertEqual(self.bundle1.get_child_bundle_count(), 0)
self.assertEqual(self.bundle1.get_attribute_metadata_count(self.attr1Name), 0)
# Create attribute metadata for not existing attribute should fail
# Disabled because of: OM-48629. Re-enable after OM-48828 is solved.
# field2 = self.bundle1.create_attribute_metadata(self.attr1Name, self.attr2Name, self.attr2Type)
# field3 = self.bundle1.create_attribute_metadata(self.attr1Name, self.attr3Name, self.attr3Type)
# self.assertFalse(field2.is_valid())
# self.assertFalse(field3.is_valid())
# check content
self.assertEqual(self.bundle1.get_attribute_count(), 0)
self.assertEqual(self.bundle1.get_child_bundle_count(), 0)
self.assertEqual(self.bundle1.get_attribute_metadata_count(self.attr1Name), 0)
# create attribute and metadata for existing attribute
self.bundle1.create_attribute(self.attr1Name, self.attr1Type)
field2 = self.bundle1.create_attribute_metadata(self.attr1Name, self.attr2Name, self.attr2Type)
field3 = self.bundle1.create_attribute_metadata(self.attr1Name, self.attr3Name, self.attr3Type)
# check content
self.assertEqual(self.bundle1.get_attribute_count(), 1)
self.assertEqual(self.bundle1.get_child_bundle_count(), 0)
self.assertEqual(self.bundle1.get_attribute_metadata_count(self.attr1Name), 2)
self.assertEqual(self.bundle1.get_attribute_metadata_count(self.attr2Name), 0)
self.assertTrue(field2.is_valid())
self.assertTrue(field3.is_valid())
async def test_attribute_metadata_create_with_ns(self):
# create attribute
self.bundle1.create_attribute(self.attr1Name, self.attr1Type)
# create metadata for attribute that contains namespace in it
name = "node:type"
_ = self.bundle1.create_attribute_metadata(self.attr1Name, name, self.attr2Type)
self.assertEqual(self.bundle1.get_attribute_metadata_count(self.attr1Name), 1)
names = self.bundle1.get_attribute_metadata_names(self.attr1Name)
self.assertTrue(name in names)
async def test_attribute_metadata_names_and_types(self):
self.bundle1.create_attribute(self.attr1Name, self.attr1Type)
_ = self.bundle1.create_attribute_metadata(self.attr1Name, self.attr2Name, self.attr2Type)
_ = self.bundle1.create_attribute_metadata(self.attr1Name, self.attr3Name, self.attr3Type)
names = self.bundle1.get_attribute_metadata_names(self.attr1Name)
types = self.bundle1.get_attribute_metadata_types(self.attr1Name)
self.assertEqual(len(names), 2)
self.assertEqual(len(types), 2)
self.assertTrue(self.attr2Name in names)
self.assertTrue(self.attr3Name in names)
async def test_attribute_metadata_by_name(self):
self.bundle1.create_attribute(self.attr1Name, self.attr1Type)
# not existing
field1 = self.bundle1.get_attribute_metadata_by_name(self.attr1Name, self.attr2Name)
self.assertFalse(field1.is_valid())
# create and query
field1 = self.bundle1.create_attribute_metadata(self.attr1Name, self.attr2Name, self.attr2Type)
self.assertTrue(field1.is_valid())
field1 = self.bundle1.get_attribute_metadata_by_name(self.attr1Name, self.attr2Name)
self.assertTrue(field1.is_valid())
async def test_attribute_metadata_remove(self):
self.bundle1.create_attribute(self.attr1Name, self.attr1Type)
# create
self.bundle1.create_attribute_metadata(self.attr1Name, self.attr2Name, self.attr2Type)
self.bundle1.create_attribute_metadata(self.attr1Name, self.attr3Name, self.attr3Type)
self.assertEqual(self.bundle1.get_attribute_metadata_count(self.attr1Name), 2)
# remove single
self.bundle1.remove_attribute_metadata(self.attr1Name, self.attr2Name)
self.assertEqual(self.bundle1.get_attribute_metadata_count(self.attr1Name), 1)
self.bundle1.remove_attribute_metadata(self.attr1Name, self.attr3Name)
self.assertEqual(self.bundle1.get_attribute_metadata_count(self.attr1Name), 0)
# create
self.bundle1.create_attribute_metadata(self.attr1Name, self.attr2Name, self.attr2Type)
self.bundle1.create_attribute_metadata(self.attr1Name, self.attr3Name, self.attr3Type)
self.assertEqual(self.bundle1.get_attribute_metadata_count(self.attr1Name), 2)
# remove bulk
self.bundle1.remove_attribute_metadata(self.attr1Name, (self.attr2Name, self.attr3Name))
self.assertEqual(self.bundle1.get_attribute_metadata_count(self.attr1Name), 0)
async def test_attribute_remove_with_metadata(self):
attr1 = self.bundle1.create_attribute(self.attr1Name, self.attr1Type)
self.bundle1.create_attribute_metadata(self.attr1Name, self.attr2Name, self.attr2Type)
self.bundle1.create_attribute_metadata(self.attr1Name, self.attr3Name, self.attr3Type)
self.assertEqual(self.bundle1.get_attribute_metadata_count(self.attr1Name), 2)
# remove attribute should remove metadata
self.bundle1.remove_attribute(attr1)
self.assertEqual(self.bundle1.get_attribute_metadata_count(self.attr1Name), 0)
async def test_bundle_array_metadata(self):
met1 = self.bundle1.create_bundle_metadata(self.attr3Name, self.attr3Type, 1000)
self.assertTrue(met1)
self.assertEqual(met1.size(), 1000)
async def test_attribute_array_metadata(self):
self.bundle1.create_attribute(self.attr1Name, self.attr1Type)
met1 = self.bundle1.create_attribute_metadata(self.attr1Name, self.attr3Name, self.attr3Type, 1000)
self.assertTrue(met1)
self.assertEqual(met1.size(), 1000)
async def test_copy_attributes_with_metadata(self):
attr1 = self.bundle1.create_attribute(self.attr1Name, self.attr1Type)
self.bundle1.create_attribute_metadata(self.attr1Name, self.attr2Name, self.attr2Type)
self.bundle1.create_attribute_metadata(self.attr1Name, self.attr3Name, self.attr3Type)
self.assertTrue(attr1)
# Create bundle2 and copy attr1 from bundle1
bundle2 = self.factory.create_bundle(self.context, self.bundle2Name)
cpy_attr1 = bundle2.copy_attribute(attr1)
self.assertTrue(cpy_attr1)
self.assertEqual(cpy_attr1.get_type(), self.attr1Type)
# metadata check
self.assertEqual(bundle2.get_attribute_metadata_count(self.attr1Name), 2)
names = bundle2.get_attribute_metadata_names(self.attr1Name)
types = bundle2.get_attribute_metadata_types(self.attr1Name)
self.assertEqual(len(names), 2)
self.assertEqual(len(types), 2)
self.assertTrue(self.attr2Name in names)
self.assertTrue(self.attr3Name in names)
async def test_copy_bundle(self):
# create bundle metadata
self.bundle1.create_bundle_metadata(self.attr2Name, self.attr2Type)
self.bundle1.create_bundle_metadata(self.attr3Name, self.attr3Type)
self.bundle1.create_bundle_metadata(self.attr4Name, self.attr4Type)
# create attribute metadata
self.bundle1.create_attribute(self.attr1Name, self.attr1Type)
self.bundle1.create_attribute_metadata(self.attr1Name, self.attr2Name, self.attr2Type)
self.bundle1.create_attribute_metadata(self.attr1Name, self.attr3Name, self.attr3Type)
# Create bundle2 and copy attr1 from bundle1
bundle2 = self.factory.create_bundle(self.context, self.bundle2Name)
bundle2.copy_bundle(self.bundle1)
# bundle metadata check
self.assertEqual(bundle2.get_bundle_metadata_count(), 3)
names = bundle2.get_bundle_metadata_names()
types = bundle2.get_bundle_metadata_names()
self.assertTrue(self.attr2Name in names)
self.assertTrue(self.attr3Name in names)
self.assertTrue(self.attr4Name in names)
self.assertEqual(len(types), 3)
# attribute metadata check
self.assertEqual(bundle2.get_attribute_metadata_count(self.attr1Name), 2)
names = bundle2.get_attribute_metadata_names(self.attr1Name)
types = bundle2.get_attribute_metadata_types(self.attr1Name)
self.assertTrue(self.attr2Name in names)
self.assertTrue(self.attr3Name in names)
self.assertEqual(len(types), 2)
async def init_for_clear_contents(self):
# attributes 3
_ = self.bundle1.create_attribute(self.attr1Name, self.attr1Type)
_ = self.bundle1.create_attribute(self.attr2Name, self.attr2Type)
_ = self.bundle1.create_attribute(self.attr3Name, self.attr3Type)
# children 2
_ = self.bundle1.create_child_bundle(self.bundle2Name)
_ = self.bundle1.create_child_bundle(self.bundle3Name)
# bundle metadata 4
self.bundle1.create_bundle_metadata(self.attr1Name, self.attr1Type)
self.bundle1.create_bundle_metadata(self.attr2Name, self.attr2Type)
self.bundle1.create_bundle_metadata(self.attr3Name, self.attr3Type)
self.bundle1.create_bundle_metadata(self.attr4Name, self.attr4Type)
# attr1 metadata 2
self.bundle1.create_attribute_metadata(self.attr1Name, self.attr3Name, self.attr3Type)
self.bundle1.create_attribute_metadata(self.attr1Name, self.attr4Name, self.attr4Type)
# attr2 metadata 1
self.bundle1.create_attribute_metadata(self.attr2Name, self.attr4Name, self.attr4Type)
async def test_clear_contents(self):
await self.init_for_clear_contents()
self.assertEqual(self.bundle1.get_bundle_metadata_count(), 4) # metadata is not destroyed by default
self.bundle1.clear_contents()
# confirm bundle is clear
self.assertEqual(self.bundle1.get_attribute_count(), 0)
self.assertEqual(self.bundle1.get_child_bundle_count(), 0)
self.assertEqual(self.bundle1.get_bundle_metadata_count(), 0) # metadata IS destroyed by default
self.assertEqual(self.bundle1.get_attribute_metadata_count(self.attr1Name), 0)
self.assertEqual(self.bundle1.get_attribute_metadata_count(self.attr2Name), 0)
self.assertTrue(self.bundle1.valid)
async def test_clear_contents_bundle_metadata(self):
await self.init_for_clear_contents()
self.assertEqual(self.bundle1.get_bundle_metadata_count(), 4)
self.bundle1.clear_contents(bundle_metadata=True)
self.assertEqual(self.bundle1.get_bundle_metadata_count(), 0)
async def test_clear_contents_attributes(self):
await self.init_for_clear_contents()
self.assertEqual(self.bundle1.get_attribute_count(), 3)
self.bundle1.clear_contents(attributes=False)
self.assertEqual(self.bundle1.get_attribute_count(), 3)
async def test_clear_contents_child_bundles(self):
await self.init_for_clear_contents()
self.assertEqual(self.bundle1.get_child_bundle_count(), 2)
self.bundle1.clear_contents(child_bundles=False)
self.assertEqual(self.bundle1.get_child_bundle_count(), 2)
class TestBundleFactoryInterface(ogt.OmniGraphTestCase):
async def setUp(self):
"""Set up test environment, to be torn down when done"""
await super().setUp()
self.graph = og.Controller.create_graph("/graph")
self.context = self.graph.get_default_graph_context()
self.factory = og.IBundleFactory.create()
self.assertTrue(self.factory is not None)
self.bundle1Name = "bundle1"
self.bundle2Name = "bundle2"
def test_bundle_conversion_method(self):
"""The factory used to allow the conversion from old Py_Bundle to new I(Const)Bundle interface.
Depending on writability of Py_Bundle, IConstBundle2 or IBundle2 was returned. When Py_Bundle was removed
backwards compatibility conversion methods were kept.
As reported in OM-84762 factory fails to pass through IBundle2, and converts IBundle2 to IConstBundle2.
Eventually this test should be removed in next release when get_bundle conversion method is hard deprecated.
"""
bundle1 = self.factory.create_bundle(self.context, self.bundle1Name)
bundle2 = self.factory.get_bundle(bundle1.get_context(), bundle1)
self.assertTrue(isinstance(bundle2, og.IBundle2))
| 38,021 | Python | 44.426523 | 116 | 0.683122 |
omniverse-code/kit/exts/omni.graph/omni/graph/core/tests/test_bundle_attribute_data_access.py | import omni.graph.core as og
import omni.graph.core.tests as ogt
class TestBundleAttributeAccess(ogt.OmniGraphTestCase):
async def setUp(self):
await super().setUp()
self.graph = og.Controller.create_graph("/graph")
self.context = self.graph.get_default_graph_context()
self.factory = og.IBundleFactory.create()
self.assertTrue(self.factory is not None)
self.bundle1Name = "bundle1"
self.rwBundle = self.factory.create_bundle(self.context, self.bundle1Name)
self.assertTrue(self.rwBundle.valid)
self.attr1Name = "attr1"
self.tupleType = og.Type(og.BaseDataType.INT, 2, 0)
self.arrayType = og.Type(og.BaseDataType.INT, 1, 1)
self.arrayTupleType = og.Type(og.BaseDataType.INT, 2, 1)
async def test_tuple_write_permissions(self):
attr = self.rwBundle.create_attribute(self.attr1Name, self.tupleType)
with self.assertRaises(ValueError):
data = attr.as_read_only().get()
data[0] = 42 # writing to data will throw
data = attr.get()
data[0] = 42 # writing to data will not throw
async def test_array_type_write_permissions(self):
attr = self.rwBundle.create_attribute(self.attr1Name, self.arrayType)
# GPU = False, Write = True
# calling get_array will throw
with self.assertRaises(ValueError):
attr.as_read_only().get_array(False, True, 10)
# GPU = False, Write = False
# calling get_array will not throw
attr.as_read_only().get_array(False, False, 10)
async def test_array_of_tuple_write_permissions(self):
attr = self.rwBundle.create_attribute(self.attr1Name, self.arrayTupleType)
# GPU = False, Write = True
# calling get_array will throw
with self.assertRaises(ValueError):
attr.as_read_only().get_array(False, True, 10)
# GPU = False, Write = False
# calling get_array will not throw
attr.get_array(False, False, 10)
| 2,035 | Python | 36.018181 | 82 | 0.642752 |
omniverse-code/kit/exts/omni.graph/omni/graph/core/tests/test_data_wrapper.py | """Suite of tests to exercise the DataWrapper class as a unit."""
import omni.graph.core as og
import omni.kit.test
# The test needs some non-standard imports to do its thing
from omni.graph.core._impl.dtypes import (
Bool,
BundleOutput,
Double,
Double2,
Double3,
Double4,
Float,
Float2,
Float3,
Float4,
Half,
Half2,
Half3,
Half4,
Int,
Int2,
Int3,
Int4,
Int64,
Matrix2d,
Matrix3d,
Matrix4d,
Token,
UChar,
UInt,
UInt64,
)
class TestDataWrapper(omni.kit.test.AsyncTestCase):
"""Wrapper for unit tests for the og.DataWrapper class"""
# ----------------------------------------------------------------------
async def test_data_wrapper_creation(self):
"""Test creation of the DataWrapper from the raw og.Type"""
# Test data that enumerates all of the OGN types. Values of the list entries are:
# OGN type name
# Expected dtype
# Expected shape for non-gathered attributes
# Expected shape for gathered attributes
test_data = [
("any", Token, None, (2,)),
("bool", Bool, None, (2,)),
("bool[]", Bool, (0,), ((2, 2))),
("bundle", BundleOutput, None, (2,)),
("colord[3]", Double3, (3,), ((2,), 3)),
("colord[3][]", Double3, (0, 3), (((2, 2)), 3)),
("colord[4]", Double4, (4,), ((2,), 4)),
("colord[4][]", Double4, (0, 4), ((2, 2), 4)),
("colorf[3]", Float3, (3,), ((2,), 3)),
("colorf[3][]", Float3, (0, 3), ((2, 2), 3)),
("colorf[4]", Float4, (4,), ((2,), 4)),
("colorf[4][]", Float4, (0, 4), ((2, 2), 4)),
("colorh[3]", Half3, (3,), ((2,), 3)),
("colorh[3][]", Half3, (0, 3), ((2, 2), 3)),
("colorh[4]", Half4, (4,), ((2,), 4)),
("colorh[4][]", Half4, (0, 4), ((2, 2), 4)),
("double", Double, None, (2,)),
("double[]", Double, (0,), ((2, 2))),
("double[2]", Double2, (2,), ((2,), 2)),
("double[2][]", Double2, (0, 2), ((2, 2), 2)),
("double[3]", Double3, (3,), ((2,), 3)),
("double[3][]", Double3, (0, 3), ((2, 2), 3)),
("double[4]", Double4, (4,), ((2,), 4)),
("double[4][]", Double4, (0, 4), ((2, 2), 4)),
("execution", UInt, None, (2,)),
("float", Float, None, (2,)),
("float[]", Float, (0,), ((2, 2))),
("float[2]", Float2, (2,), ((2,), 2)),
("float[2][]", Float2, (0, 2), ((2, 2), 2)),
("float[3]", Float3, (3,), ((2,), 3)),
("float[3][]", Float3, (0, 3), ((2, 2), 3)),
("float[4]", Float4, (4,), ((2,), 4)),
("float[4][]", Float4, (0, 4), ((2, 2), 4)),
("frame[4]", Matrix4d, (4, 4), ((2,), 4, 4)),
("frame[4][]", Matrix4d, (0, 4, 4), ((2, 2), 4, 4)),
("half", Half, None, (2,)),
("half[]", Half, (0,), ((2, 2))),
("half[2]", Half2, (2,), ((2,), 2)),
("half[2][]", Half2, (0, 2), ((2, 2), 2)),
("half[3]", Half3, (3,), ((2,), 3)),
("half[3][]", Half3, (0, 3), ((2, 2), 3)),
("half[4]", Half4, (4,), ((2,), 4)),
("half[4][]", Half4, (0, 4), ((2, 2), 4)),
("int", Int, None, (2,)),
("int[]", Int, (0,), ((2, 2))),
("int[2]", Int2, (2,), ((2,), 2)),
("int[2][]", Int2, (0, 2), ((2, 2), 2)),
("int[3]", Int3, (3,), ((2,), 3)),
("int[3][]", Int3, (0, 3), ((2, 2), 3)),
("int[4]", Int4, (4,), ((2,), 4)),
("int[4][]", Int4, (0, 4), ((2, 2), 4)),
("int64", Int64, None, (2,)),
("int64[]", Int64, (0,), ((2, 2))),
("matrixd[2]", Matrix2d, (2, 2), ((2,), 2, 2)),
("matrixd[2][]", Matrix2d, (0, 2, 2), ((2, 2), 2, 2)),
("matrixd[3]", Matrix3d, (3, 3), ((2,), 3, 3)),
("matrixd[3][]", Matrix3d, (0, 3, 3), ((2, 2), 3, 3)),
("matrixd[4]", Matrix4d, (4, 4), ((2,), 4, 4)),
("matrixd[4][]", Matrix4d, (0, 4, 4), ((2, 2), 4, 4)),
("normald[3]", Double3, (3,), ((2,), 3)),
("normald[3][]", Double3, (0, 3), (((2, 2)), 3)),
("normalf[3]", Float3, (3,), ((2,), 3)),
("normalf[3][]", Float3, (0, 3), ((2, 2), 3)),
("normalh[3]", Half3, (3,), ((2,), 3)),
("normalh[3][]", Half3, (0, 3), ((2, 2), 3)),
("objectId", UInt64, None, (2,)),
("objectId[]", UInt64, (0,), ((2, 2))),
("pointd[3]", Double3, (3,), ((2,), 3)),
("pointd[3][]", Double3, (0, 3), (((2, 2)), 3)),
("pointf[3]", Float3, (3,), ((2,), 3)),
("pointf[3][]", Float3, (0, 3), ((2, 2), 3)),
("pointh[3]", Half3, (3,), ((2,), 3)),
("pointh[3][]", Half3, (0, 3), ((2, 2), 3)),
("quatd[4]", Double4, (4,), ((2,), 4)),
("quatd[4][]", Double4, (0, 4), (((2, 2)), 4)),
("quatf[4]", Float4, (4,), ((2,), 4)),
("quatf[4][]", Float4, (0, 4), ((2, 2), 4)),
("quath[4]", Half4, (4,), ((2,), 4)),
("quath[4][]", Half4, (0, 4), ((2, 2), 4)),
("string", UChar, (0,), ((2, 2))),
("target", BundleOutput, None, (2,)),
("texcoordd[2]", Double2, (2,), ((2,), 2)),
("texcoordd[2][]", Double2, (0, 2), (((2, 2)), 2)),
("texcoordd[3]", Double3, (3,), ((2,), 3)),
("texcoordd[3][]", Double3, (0, 3), ((2, 2), 3)),
("texcoordf[2]", Float2, (2,), ((2,), 2)),
("texcoordf[2][]", Float2, (0, 2), ((2, 2), 2)),
("texcoordf[3]", Float3, (3,), ((2,), 3)),
("texcoordf[3][]", Float3, (0, 3), ((2, 2), 3)),
("texcoordh[2]", Half2, (2,), ((2,), 2)),
("texcoordh[2][]", Half2, (0, 2), ((2, 2), 2)),
("texcoordh[3]", Half3, (3,), ((2,), 3)),
("texcoordh[3][]", Half3, (0, 3), ((2, 2), 3)),
("timecode", Double, None, (2,)),
("timecode[]", Double, (0,), ((2, 2))),
("token", Token, None, (2,)),
("token[]", Token, (0,), ((2, 2))),
("uchar", UChar, None, (2,)),
("uchar[]", UChar, (0,), ((2, 2))),
("uint", UInt, None, (2,)),
("uint[]", UInt, (0,), ((2, 2))),
("uint64", UInt64, None, (2,)),
("uint64[]", UInt64, (0,), ((2, 2))),
("vectord[3]", Double3, (3,), ((2,), 3)),
("vectord[3][]", Double3, (0, 3), (((2, 2)), 3)),
("vectorf[3]", Float3, (3,), ((2,), 3)),
("vectorf[3][]", Float3, (0, 3), ((2, 2), 3)),
("vectorh[3]", Half3, (3,), ((2,), 3)),
("vectorh[3][]", Half3, (0, 3), ((2, 2), 3)),
]
for name, expected_dtype, expected_ungathered_shape, expected_gathered_shape in test_data:
attribute_type = og.AttributeType.type_from_ogn_type_name(name)
ungathered_dtype, ungathered_shape = og.data_shape_from_type(attribute_type, is_gathered=False)
gathered_dtype, gathered_shape = og.data_shape_from_type(attribute_type, is_gathered=True)
self.assertEqual(ungathered_dtype.__class__, expected_dtype, f"Mismatched type for {name}")
self.assertEqual(ungathered_shape, expected_ungathered_shape, f"Mismatched shape for {name}")
self.assertEqual(ungathered_dtype, gathered_dtype, f"Mismatched gathered type for {name}")
self.assertEqual(gathered_shape, expected_gathered_shape, f"Mismatched gathered shape for {name}")
# ----------------------------------------------------------------------
async def test_data_wrapper_indexing(self):
"""Test indexing of the DataWrapper for all of the documented supported types"""
# Test data drives all of the test cases for expected index results. The data is a list of test
# configurations consisting of:
# Dtype of the parent wrapper
# Shape of the parent wrapper
# Index to be be taken to get the child
# Expected Dtype of the child wrapper (None means to expect an exception raised)
# Expected shape of the child wrapper
# Expected memory location offset of the child at index 1 from the parent
test_data = [
[Float, None, 1, None, None, 0], # Single value
[Float, (3,), 1, Float, None, Float.size], # Array of 3 simple values
[Float3, (3,), 1, Float, None, Float.size], # Tuple of 3 simple values
[Float3, (2, 3), 1, Float3, (3,), Float3.size], # Array of 2 triple values
[Matrix2d, (2, 2), 1, Double2, (2,), Double2.size], # A 2x2 matrix
[Matrix2d, (3, 2, 2), 1, Matrix2d, (2, 2), Matrix2d.size], # An array of 3 2x2 matrixes
[Float3, (3,), -1, None, None, 0], # Index too low
[Float3, (3, 3), -1, None, None, 0],
[Float3, ((3,), 3), -1, None, None, 0],
[Float3, ((3, 4), 3), -1, None, None, 0],
[Float, (3,), -1, None, None, 0],
[Float, ((3,), 3), -1, None, None, 0],
[Float, ((3, 4), 3), -1, None, None, 0],
[Matrix2d, (2, 2), -1, None, None, 0],
[Matrix2d, (3, 2, 2), -1, None, None, 0],
[Matrix2d, ((3,), 2, 2), -1, None, None, 0],
[Matrix2d, ((3, 4), 2, 2), -1, None, None, 0],
[Float3, (3,), 4, None, None, 0], # Index too high
[Float3, (3, 3), 4, None, None, 0],
[Float3, ((3,), 3), 4, None, None, 0],
[Float3, ((3, 4), 3), 4, None, None, 0],
[Float, (3,), 4, None, None, 0],
[Float, ((3,), 3), 4, None, None, 0],
[Float, ((3, 4), 3), 4, None, None, 0],
[Matrix2d, (2, 2), 4, None, None, 0],
[Matrix2d, (3, 2, 2), 4, None, None, 0],
[Matrix2d, ((3,), 2, 2), 4, None, None, 0],
[Matrix2d, ((3, 4), 2, 2), 4, None, None, 0],
[Float, (3, 3), 1, None, None, 0], # Too many levels of array
[Float4, (3,), 1, None, None, 0], # Mismatched shape size for tuple
[Float4, (3, 3), 1, None, None, 0], # Mismatched shape size for tuple array
[Matrix2d, (3, 3), 1, None, None, 0], # Mismatched shape size for matrix
[Matrix2d, (2, 3, 3), 1, None, None, 0], # Mismatched shape size for matrix array
]
for parent_dtype, parent_shape, child_index, child_dtype, child_shape, child_offset in test_data:
if child_dtype is None:
with self.assertRaises(ValueError):
parent_wrapper = og.DataWrapper(0, parent_dtype, parent_shape, og.Device.cuda)
_ = parent_wrapper[child_index]
else:
parent_wrapper = og.DataWrapper(0, parent_dtype, parent_shape, og.Device.cuda)
child_wrapper = parent_wrapper[child_index]
self.assertEqual(child_wrapper.dtype.tuple_count, child_dtype.tuple_count)
self.assertEqual(child_wrapper.dtype.base_type, child_dtype.base_type)
self.assertEqual(child_wrapper.shape, child_shape)
self.assertEqual(child_wrapper.memory, child_offset)
| 11,393 | Python | 48.53913 | 110 | 0.43202 |
omniverse-code/kit/exts/omni.graph/docs/testing.rst | .. _set_up_omnigraph_tests:
Set Up OmniGraph Tests
======================
Much of the testing for a node can be set up through the .ogn file's :ref:`test section<ogn_defining_automatic_tests>`,
however there are a number of situations that require more detailed setup or more flexible checking than the
automatically generated tests can provide. For such tests you will want to hook into Kit's testing system.
Some examples of these situations are when you need to check for attributes that are one-of a set of allowed results
rather than a fixed value, where you need to check node or attribute information that is more than just the current
value, where you need to call utility scripts to set up desired configurations, or when your results depend on some
external condition such as the graph state.
Described here are some best practices for writing such tests. This is only meant to describe setting up Python
regression tests that use the Kit extensions to the Python `unittest` modeule. It is not meant to describe setting up
C++ unit tests.
.. note::
For clarity a lot of recommended coding practices, like adding docstrings to all classes, functions, and modules,
or checking for unexpected exceptions in order to provide better error messages, are not followed. Please do use
them when you write your actual tests though.
Locating The Tests
------------------
The Kit extension system uses an automatic module recognition algorithm to detect directories in which test cases
may be found. In particular it looks for **.tests** submodules. So if your Python module is named `omni.graph.foo` it
will check the contents of the module `omni.graph.foo.tests`, if it exists, and attempt to find files containing
classes derived from `unittest.TestCase`, or the Kit version `omni.kit.test.AsyncTestCase`.
The usual way of structuring extensions provides a directory structure that looks like this:
.. code-block:: text
omni.graph.foo/
python/
tests/
test_some_stuff.py
The *tests/* subdirectory would be linked into the build using these lines in your *premake5.lua* file inside the
python project definition:
.. code-block:: lua
add_files("python/tests", "python/tests/*.py")
repo_build.prebuild_link {
{ "python/tests", ogn.python_tests_target_path },
}
This creates a link that creates a **.tests** submodule for your extension.
The files containing tests should all begin with the prefix *test_*.
Creating A Test Class
---------------------
OmniGraph tests have some shared setUp and tearDown operations so the easiest way to set up your test class is to
have it derive from the derived test case class that implements them:
.. code-block:: python
import omni.graph.core.tests as ogts
class TestsForMe(ogts.OmniGraphTestCase):
pass
This will ensure your tests are part of the Kit regression test system. The parent class will define some temporary
settings as required by OmniGraph, and will clear the scene when the test is done so as not to influence the results
of the test after it (barring any other side effects the test itself causes of course).
.. tip::
Although the name of the class is not significant it's helpful to prefix it with *Tests* to make it easy to identify.
Specialized SetUp And TearDown
++++++++++++++++++++++++++++++
If you have some other setUp or tearDown functions you wish to perform you do it in the usual Pythonic manner:
.. code:: python
import omni.graph.core.tests as ogts
class TestsForMe(ogts.OmniGraphTestCase):
async def setUp(self):
await super().setUp()
do_my_setup()
async def tearDown(self):
do_my_teardown()
await super().tearDown()
.. note::
The tests are async so both they and the setUp/tearDown will be "awaited" when running. This was done to facilitate
easier access to some of the Kit async functions, though normally you want to ensure your test steps run
sequentially.
Adding Tests
++++++++++++
Tests are added in the usual way for the Python `unittest` framework, by creating a function with the prefix *test_*.
As the tests are all awaited your functions should be async.
.. code:: python
import omni.graph.core.tests as ogts
class TestsForMe(ogts.OmniGraphTestCase):
async def setUp(self):
await super().setUp()
do_my_setup()
async def tearDown(self):
do_my_teardown()
await super().tearDown()
async def test1(self):
self.assertTrue(run_first_test())
async def test2(self):
self.assertTrue(run_second_test())
How you divide your test bodies is up to you. You'll want to balance the slower performance of repetitive setup
against the isolation of specific test conditions.
Your best friend in setting up test conditions is the :ref:`og.Controller<howto_omnigraph_controller>` class. It
provides a lot of what you will need for setting up and inspecting your graph, nodes, and attributes.
Here is a simple example that will create an add node with one constant input, and one input supplied from another
node that will test to make sure that results are correct over a set of inputs. It uses several concepts from the
controller to illustrate its use.
.. code-block:: python
import omni.graph.core as og
import omni.graph.core.tests as ogts
class TestsForMe(ogts.OmniGraphTestCase):
async def test_add(self):
keys = og.Controller.Keys
(graph, nodes, _, _) = og.Controller.edit("/TestGraph", {
keys.CREATE_NODES: [
("Add", "omni.graph.nodes.Add"),
("ConstInt", "omni.graph.nodes.ConstantInt"),
],
keys.CONNECT: ("ConstInt.inputs:value", "Add.inputs:a"),
keys.SET_VALUES: [("ConstInt.inputs:value", 3), ("Add.inputs:b", {"type": "int", "value": 1})]
})
# Get controllers attached to the attributes since they will be accessed in a loop
b_view = og.Controller(attribute=og.Controller.attribute("inputs:b", nodes[0]))
sum_view = og.Controller(attribute=og.Controller.attribute("outputs:sum", nodes[0]))
# Test configurations are pairs of (input_b_value, output_sum_expected)
test_configurations = [
({"type": "int", "value": 1}, 4),
({"type": "int", "value": -3}, 0),
({"type": "int", "value": 1000000}, 1000003),
]
for b_value, sum_expected in test_configurations:
b_view.set(b_value)
# Before checking computed values you must ensure the graph has evaluated
await og.Controller.evaluate(graph)
self.assertAlmostEqual(sum_expected, sum_view.get())
Expected Errors
+++++++++++++++
When writing tests, it can be desirable to test error conditions. However, this may cause errors to be
displayed to the console, which can cause tests to fail when running in batch mode.
One way to have the testing system ignore these errors is to prepend a additional text to the error line.
.. code-block:: python
# write to the console, skipping the newline to prepend the expected error message
print("[Ignore this error/warning] ", end ="")
self.assertFalse(self.function_that_causes_error())
Then, in your packages extensions.toml file, tell the test system to ignore error output when the prepended output
occurs.
.. code-block:: rst
[[test]]
stdoutFailPatterns.exclude = [
# Exclude messages which say they should be ignored
"*Ignore this error/warning*",
]
This allows for the test to specify which errors should be ignored without ignoring all errors with the same
output in the entire package, or by disabling all error checking from your test class.
Executing Your Tests
--------------------
Now that your tests are visible to Kit they will be automatically run by TeamCity. To run them yourself locally you
have two options.
Batch Running Tests
+++++++++++++++++++
All tests registered in the manner described above will be added to a batch file that runs
all tests in your extension. You can find this file at *$BUILD/tests-omni.graph.foo.{bat|sh}*. Executing this file
will run your tests in a minimal Kit configuration. (It basically loads your extension and all dependent extensions,
including the test manager.) Look up the documentation on ``omni.kit.test`` for more information on how the tests
can be configured.
Test Runner
+++++++++++
Kit's *Test Runner* window is a handy way to interactively run one or more of your tests at a finer granularity through
a UI. By default none of the tests are added to the window, however, so you must add a line like this to your
user configuration file, usually in **~/Documents/Kit/shared/user.toml**, to specify which tests it should load:
.. code-block:: toml
exts."omni.kit.test".includeTests = ["omni.graph.foo.*"]
Debugging Your Tests
--------------------
Whether you're tracking down a bug or engaging in test-driven-development eventually you will end up in a situation
where you need to debug your tests.
One of the best tools is to use the script editor and the UI in Kit to inspect and manipulate your test scene.
While the normal OmniGraph test case class deletes the scene at the end of the test you can make a temporary change
to instead use a variation of the test case that does not do that, so that you can examine the failing scene.
.. code-block:: python
:emphasize-lines: 3
import omni.graph.core.tests as ogts
class TestsForMe(ogts.OmniGraphTestCaseNoClear):
pass
Running Test Batch Files With Attached Debuggers
++++++++++++++++++++++++++++++++++++++++++++++++
You're probably familiar with the debugging extensions ``omni.kit.debug.python`` and ``omni.kit.debug.vscode``,
with which you can attach debuggers to running versions of Kit.
If you are running the test batch file, however, you have to ensure that these extensions are running as part of the
test environment. To do so you just need to add these flags to your invocation of the test ``.bat`` file:
.. code-block:: bash
$BUILD/tests-omni.graph.foo.bat --enable omni.kit.debug.vscode --enable omni.kit.debug.python
This will enable the extra extensions required to attach the debuggers while the test scripts are running. Of course
you still have to manually attach them from your IDE in the same way you usually do.
.. note::
As of this writing you might see two ``kit.exe`` processes when attaching a C++ debugger to a test script. The
safest thing to do is attach to both of them.
The .bat files also support the flag ``-d`` flag to wait for the debugger to attach before executing. If you're running
a debug cut this probably won't be necessary as the startup time is ample for attaching a debugger.
| 10,992 | reStructuredText | 40.018657 | 121 | 0.702966 |
omniverse-code/kit/exts/omni.graph/docs/runtimeInitialize.rst | .. _runtime_attribute_value_initialization_in_omnigraph_nodes:
Runtime Attribute Value Initialization In OmniGraph Nodes
=========================================================
Normally you will specify attribute default values in your .ogn files and the attributes will be given those values
when the node is created. Occasionally, you may wish to provide different default values for your attributes based
on some condition that can only be ascertained at runtime. This document describes the current best-practice for
achieving that goal, in both C++ and Python nodes.
As of this writing the database cannot be accessed during the node's *initialize()* method, so providing new values in
there will not work. (If in the future that changes this document will be updated to explain how to use it instead.)
In fact, the only time the data is guaranteed to be available to use or set is in the node's *compute()* method, so
that will be used to set up a delayed initialization of attribute values.
The general approach to this initialization will be to use a boolean state value in the node to determine whether the
attribute or attributes have been given their initial values or not when the *compute()* method is called. It's also
possible that the attribute would have been given a value directly so that also must be considered when managing the
boolean state value.
For these examples this node definition will be used:
.. code-block:: json
{
"RandomInt": {
"version": 1,
"description": "Holds an integer with a random integer number.",
"outputs": {
"number": {
"description": "The random integer",
"type": "int"
}
},
"state": {
"$comment": "This section exists solely to inform the scheduler that there is internal state information."
}
}
}
.. note::
For the Python node assume the addition of the line `"language": "python"`.
Initializing Values In C++ Nodes
--------------------------------
In the :ref:`internal state tutorial<ogn_tutorial_state>` you can see that the way to add state information to a C++
node is to make some class members. We'll add a boolean class member to tell us if the node is initialized or not,
and check it in the **compute()** method.
.. code-block:: cpp
#include <OgnRandomIntDatabase.h>
#include <cstdlib>
class OgnRandomInt
{
bool m_initialized{ false }; // State information the tells if the attribute value has been initialized yet
public:
static bool compute(OgnRandomIntDatabase& db)
{
auto& state = db.internalState<OgnRandomInt>();
if (! state.m_initialized)
{
db.outputs.number() = std::rand();
state.m_initialized = true;
}
// Normally you would have other things to do as part of the compute as well...
return true;
}
};
REGISTER_OGN_NODE()
If you know your attribute will never be set from the outside then that is sufficient, however usually there is no
guarantee that some script or UI has not set the attribute value. Fortunately the node can monitor that using the
**registerValueChangedCallback()** ABI function on the attribute. It can be set up in the node's **initialize()**
method.
Putting this in with the above code you get this:
.. code-block:: cpp
#include <OgnRandomIntDatabase.h>
#include <cstdlib>
class OgnRandomInt
{
bool m_initialized{ false }; // State information the tells if the attribute value has been initialized yet
static void attributeChanged(const AttributeObj& attr, const void*)
{
auto& state = OgnRandomIntDatabase::sInternalState<OgnRandomInt>(attr.iAttribute->getNode(attr));
state.m_initialized = true;
}
public:
static bool compute(OgnRandomIntDatabase& db)
{
auto& state = db.internalState<OgnRandomInt>();
if (! state.m_initialized)
{
db.outputs.number() = std::rand();
state.m_initialized = true;
}
// Normally you would have other things to do as part of the compute as well...
return true;
}
static void initialize(const GraphContextObj&, const NodeObj& nodeObj)
{
AttributeObj attrObj = nodeObj.iNode->getAttributeByToken(nodeObj, outputs::number.m_token);
attrObj.iAttribute->registerValueChangedCallback(attrObj, attributeChanged, true);
}
};
REGISTER_OGN_NODE()
Initializing Values In Python Nodes
-----------------------------------
In the :ref:`internal state tutorial<ogn_tutorial_state_py>` you can see that the way to add state information to a
Python node is to create a static **internal_state** method. We'll create a simple class with a boolean class member to
tell us if the node is initialized or not, and check it in the **compute()** method.
.. code-block:: python
from dataclasses import dataclass
from random import randint
class OgnRandomInt:
@dataclass
class State:
initialized: bool = False
@staticmethod
def internal_state() -> State:
return OgnRandomInt.State()
@staticmethod
def compute(db) -> bool:
if not db.internal_state.initialized:
db.outputs.number = randint(-0x7fffffff, 0x7fffffff)
db.internal_state.initialized = True
# Normally you would have other things to do as part of the compute as well...
return True
If you know your attribute will never be set from the outside then that is sufficient. Unfortunately the Python API
does not yet have a method of getting a callback when an attribute value has changed so for now this is all you can do.
| 5,974 | reStructuredText | 37.798701 | 122 | 0.652996 |
omniverse-code/kit/exts/omni.graph/docs/autonode.rst | .. _autonode_ref:
AutoNode - Autogenerating Nodes From Code
================================================================================
This is a description of the automated node generator for python code in OmniGraph.
It turns this:
.. code-block:: python
import omni.graph.core as og
@og.AutoFunc(pure=True)
def dot(vec1: og.Float3, vec2: og.Float3) -> float:
return vec1[0] * vec2[0] + vec1[1] * vec2[1] + vec1[2] * vec2[2]
Into this:
.. image:: images/dot.png
What it Does
--------------------------------------------------------------------------------
AutoNode allows developers to create OmniGraph nodes from any of the following:
* **Free functions** (see `AutoFunc`_)
* **Python classes and class instances** - AutoNode also scans classes and generates getters and setters (see `AutoClass`_ and `Passing Python Types in AutoNode`_ ).
* **CPython and Pybind types** - see `Annotations: Overriding CPython Types`_.
* **OmniGraph types** (see `Supported Types`_ )
* **Container types** (see `Bundles`_)
* **Events, Enums and other special types**.
This process will generate both the OGN description of the node and its attributes, and the implementation of the node compute function in Python.
How it Works
--------------------------------------------------------------------------------
AutoNode generates node signatures by extracting type annotations stored in functions and variables. In order for nodes to be generated, type annotations must be available to the decorator at initialization time. For most developers, this means using `type annotations <https://docs.python.org/3/library/typing.html>`_ for python 3, like in the example above.
Under the hood, annotation extraction is done with the python ``__annotations__`` ( `PEP 3107 <https://www.python.org/dev/peps/pep-3107/>`_ ) dictionary in every class.
.. note::
While the API will remain relatively stable, there is no current guarantee that the backend will not be changed. Some implementation details are captured in `Implementation Details`_, purely for reference.
API Details
--------------------------------------------------------------------------------
Decorators
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
``omni.graph.core`` currently exposes these autogeneration functions: ``AutoFunc()``, ``AutoClass()``. Both these functions can be used as decorators or as free function calls:
.. code-block:: python
import omni.graph.core as og
#this is convenient
@og.AutoFunc()
def say_hi() -> str:
return "hi, everybody!"
def say_hello() -> str:
return "Hello, World!"
# but this does virtually the same thing
og.AutoFunc()(say_hello)
``AutoFunc``
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
Here's an example of wrapping a free function:
.. code-block:: python
import omni.graph.core as og
@og.AutoFunc()
def one_up(input : int = 0) -> str:
"""this documentation will appear in the node's help"""
return f"one up! {input + 1}"
**Note:** The type annotations really matter. Without them, AutoNode can't define node inputs and outputs.
You can create multiple returns by making your return type a `typing.Tuple`:
.. code-block:: python
import omni.graph.core as og
from typing import Tuple
@og.AutoFunc()
def break_vector(input : og.Float3) -> Tuple[og.Float, og.Float, og.Float]
return (input[0], input[1], input[2])
``AutoClass``
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
This exposes entire classes to OGN. Here are the rules of evaluation:
* Private properties and methods (starting with ``_``) will not be exposed
* Public properties exposed will attempt to find a type annotation using ``__annotations__`` and will default to the inferred type. ``None`` types will be ignored.
* Public methods will be associated with the class type, and will not attempt to find a type for ``self``.
* Bound methods in classes (methods with an immutable ``__self__`` reference) will be stored for representation, but the actual method to be called will come from the specific instance that's being applied for this. For instance - if class ``A`` was decorated with ``AutoClass``, and it contained a method ``A.Method(self, arg: int)->str``, with ``__self__`` stored in the method ("bound method"), then when a class ``B`` with an overriding method gets called on this node, the node will search for inside ``B.Method`` and call it instead.
Here is a simple case of wrapping a class:
.. code-block:: python
import omni.graph.core as og
@og.AutoClass(module_name="AutoNodeDemo")
class TestClass:
#this will not generate getters and setters
_private_var = 42
#this will generate getters and setters, and will make them of type ``float``
public_var: float = 3.141
# initializers are private methods and will not be exposed by the decorator
def __init__(self):
pass
def public_method(self, exponent: float) -> float:
"""this method will be exposed into OmniGraph, along with its'
documentation here. The function signature is necessary on every
argument except for ``self``, which is implied."""
return self.public_var ** exponent
This results in the following menu and implementation:
.. image:: images/Autoclass01.png
.. image:: images/Autoclass02.png
Note that getters and setters take in a ``target`` variable. This allows users to pass in a reference to an existing class. See `Passing Python Types in AutoNode`_ for more details.
Decorator Parameters
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
``pure``
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
Boolean. Setting ``@og.AutoFunc(pure=True)`` will generate a method that can be used in a push or execute context, without an execution input or output. ``AutoFunc`` only.
For example, these two functions:
.. code-block:: python
import omni.graph.core as og
@og.AutoFunc(pure=True)
def dot(vec1: og.Float3, vec2: og.Float3) -> float:
return vec1[0] * vec2[0] + vec1[1] * vec2[1] + vec1[2] * vec2[2]
@og.AutoFunc()
def exec_dot(vec1: og.Float3, vec2: og.Float3) -> float:
return vec1[0] * vec2[0] + vec1[1] * vec2[1] + vec1[2] * vec2[2]
Will generate these nodes:
.. image:: images/pure.png
``module_name``
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
Specifies where the node will be registered. This affects UI menus and node spawning by name. For example, setting
.. code-block:: python
import omni.graph.core as og
import MyModule
@og.AutoFunc(module_name="test_module")
def add_one(input: int) -> int:
return input + 1
og.AutoClass(module_name="test_module")(MyModule.TestClass)
Will result in a UI displaying access to this node from ``test_module``
``ui_name``
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
Specifies the onscreen name of the function. ``AutoFunc`` only.
``annotation``
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
See `Annotations: Overriding CPython Types`_.
``tags``
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
Array of text tags to be added to the node.
``metadata``
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
Other metadata to pass through AutoNode, such as icon information.
Supported Types
--------------------------------------------------------------------------------
Currently, this is the list of types supported by AutoNode:
.. code-block:: python
import omni.graph.core as og
# Generic Vectors
[og.Vector3d, og.Vector3h, og.Vector3f]
# Scalar and Vector types
[og.Float, og.Float2, og.Float3, og.Float4]
[og.Half, og.Half2, og.Half3, og.Half4]
[og.Double, og.Double2, og.Double3, og.Double4]
[og.Int, og.Int2, og.Int3, og.Int4]
# Matrix Types
[og.Matrix2d, og.Matrix3d, og.Matrix4d]
# Vector Types with roles
[og.Normal3d, og.Normal3f, og.Normal3h]
[og.Point3d, og.Point3f, og.Point3h]
[og.Quatd, og.Quatf, og.Quath]
[og.TexCoord2d, og.TexCoord2f, og.TexCoord2h]
[og.TexCoord3d, og.TexCoord3f, og.TexCoord3h]
[og.Color3d, og.Color3f, og.Color3h, og.Color4d, og.Color4f, og.Color4h]
# Specialty Types
[og.Timecode, og.Uint, og.Uchar, og.Token]
# Underspecified, but accepted types
# str, int, float
.. note::
Not all `python typing <https://docs.python.org/3/library/typing.html>`_ types are supported.
.. _Bundles:
``Bundle`` Types : The Omniverse struct
+++++++++++++++++++++++++++++++++++++++
Since most of Omniverse's computations require concrete numerical types - matrices, vectors, numbers with known precision - it makes sense to have a data structure to pass them in together - and to make that data structure GPU-friendly. ``Bundle`` serves that purpose - it's a lightweight data structure which contains information about the types it holds.
``Bundle`` can be passed around between nodes in OmniGraph without special handling. Here is one example:
.. code-block:: python
import omni.graph.core as og
@og.AutoFunc(pure=True)
def pack(v: og.Float3, c: og.Color3f) -> og.Bundle:
bundle = og.Bundle("return", False)
bundle.create_attribute("vec", og.Float3).value = v
bundle.create_attribute("col", og.Color3f).value = c
return bundle
@og.AutoFunc(pure=True)
def unpack_vector(bundle: og.Bundle) -> og.Float3:
vec = bundle.attribute_by_name("vec")
if vec:
return vec.value
return [0,0,0]
Will yield this:
.. image:: images/Bundle01.png
Bundles aren't just useful as ways to easily pass data structures into the graph - they're also useful within python. Passing bundles between python methods is relatively cheap, and allows all users of the data to know the exact type and size it was used in. Furthermore, usage of bundles allows OmniGraph to move data to the GPU at will.
Passing Python Types in AutoNode
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
While OmniGraph can only understand and manipulated the types listed above, any python type can be passed through OmniGraph by AutoNode.
This is done by using a special type called ``objectId``, which is used by AutoNode to keep a reference (usually a hash, but that can change, see `Implementation Details`_) to the object being passed through OmniGraph.
Any type in a method I/O that isn't recognized by AutoNode as supported by OmniGraph is automatically handled by AutoNode like this:
1. When a method signature has a type not recognized by AutoNode, AutoNode generates an ``objectId`` signature for that type in the node's ``ogn`` descriptor.
2. When a method outputs a object whose type is represented by an ``objectId`` in the output, AutoNode stores the object in a *Temporary Object Store*, a special runtime collection of python objects resident in OmniGraph memory.
3. When an input ``objectId`` is received by a method, the method requests the object from the *Temporary Object Store*. The object store is "read once" - after a single read, the object is deleted from the store. Every subsequent call will result in an error.
Special Types
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
AutoNode adds special type handlers (see `Adding Type Handlers`_) to deal with how certain types are used in practice.
Enums
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
Type handlers which specialize enums are built for how enums are typically used: Switching on an Enum, like an event type.
The switch class has one exec input and one enum input, and exec outputs to match the number of enum members:
.. code-block:: python
from enum import Enum
@AutoClass()
class DogType(Enum):
SHIBA = 1
HUSKY = 2
SALUKI = 4
Results in:
.. image:: images/Enum.png
Events
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
TODO
Annotations: Overriding CPython Types
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Sometimes, importing modules created in CPython is essential. Those modules may not have a ``__annotations__`` property, so we can create it for them. Suppose the codeblocks above were defined in CPython and didn't contain annotations. Here we create a shim for them:
.. code-block:: python
import omni.graph.core as og
import MyModule
# Note that we don't need a decorator call, since the function is being passed as an argument
og.AutoFunc(annotation={
"input": int,
"return": str
})(MyModule.one_up)
Similarly, for classes:
.. code-block:: python
import omni.graph.core as og
import MyModule
# Note that members only get a type annotation, but functions get the entire annotation.
og.AutoClass( annotation={
"public_var" : float,
"public_method": {
"self": MyModule.TestClass,
"exponent": float,
"return": float}
})(MyModule.TestClass)
Customizing AutoNode
--------------------------------------------------------------------------------
Adding Type Handlers
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Types going through ``AutoClass`` are highly customizable. By default, when a class is scanned, it is run through a series of custom handlers, each of type ``AutoNodeDefinitionGenerator``. This class implements this interface:
.. code-block:: python
import omni.graph.core as og
# ================================================================================
class MyDefinitionGenerator(og.AutoNodeDefinitionGenerator):
"""Defines a property handler"""
# Fill this with the type you wish to scan
_name = "MyDefinition"
# --------------------------------------------------------------------------------
@classmethod
def generate_from_definitions(cls, new_type: type) -> Tuple[Iterable[og.AutoNodeDefinitionWrapper], Iterable[str]]:
'''This method scans the type new_type and outputs an AutoNodeDefinitionWrapper from it, representing the type,
as well as a list of members it wishes to hide from the rest of the node extraction process.
Args:
new_type: the type to analyze by attribute
Returns: a tuple of:
Iterable[AutoNodeDefinitionWrapper] - an iterable of AutoNodeDefinitionWrapper - every node wrapper that is
generated from this type.
Iterable[str] - an iterable of all members covered by this handler that other handlers should ignore.
'''
pass
The emitted ``AutoNodeDefinitionGenerator`` class has the following signature:
.. code-block:: python
import omni.graph.core as og
class MyNodeDefinitionWrapper(og.AutoNodeDefinitionWrapper):
"""Container for a single node representation consumed by the Ogn code generator.
Class is abstract and meant to be overridden. A sufficient implementation overrides these methods:
* get_ogn(self) -> Dict
* get_node_impl(self)
* get_unique_name(self) -> str
* get_module_name(self) -> str
"""
def __init__(self):
super().__init__()
# --------------------------------------------------------------------------------
def get_ogn(self) -> Dict:
"""Get the Ogn dictionary representation of the node interface.
Overrides the AutoNodeDefinitionWrapper function of the same name.
"""
return {}
# --------------------------------------------------------------------------------
def get_node_impl(self):
"""Returns the Ogn class implementing the node behavior. See the OmniGraph documentation on how to implement.
A sufficient implementation contains a staticmethod with the function: compute(db)
Overrides the AutoNodeDefinitionWrapper function of the same name.
"""
return None
# --------------------------------------------------------------------------------
def get_unique_name(self) -> str:
"""Get nodes unique name, to be saved as an accessor in the node database.
Overrides the AutoNodeDefinitionWrapper function of the same name.
Returns:
the nongled unique name
"""
return ""
# --------------------------------------------------------------------------------
def get_module_name(self) -> str:
"""Get the module this AutoNode method was defined in.
Overrides the AutoNodeDefinitionWrapper function of the same name.
Returns:
the module name
"""
return ""
For more information on node implementations requires for ``get_node_impl``, read :ref:`ogn_tutorial_complexData_py`.
Here is an example of creating an extension for ``enum`` types:
.. code-block:: python
from typing import Dict, OrderedDict, Tuple, Iterable
import omni.graph.core as og
# ================================================================================
class OgnEnumExecutionWrapper:
# We use the __init_subclass__ mechanism to execute operations on a type
def __init_subclass__(cls, target_class: type) -> None:
# __members__ are the property required for identifying an enum
cls.member_names = [name for name in target_class.__members__]
cls.value_to_name = {
getattr(target_class, name): name for name in target_class.__members__}
# --------------------------------------------------------------------------------
@classmethod
def compute(*args):
cls = args[0]
db = args[1]
# don't execute if there's no need
if not db.inputs.exec:
return True
input = db.inputs.enum
input_value = og.TypeRegistry.instance().refs.pop(input)
name = cls.value_to_name.get(input_value.value, None)
if name is not None:
out = getattr(db.outputs.attributes, name)
db.outputs.context_helper.set_attr_value(True, out)
return True
return False
# ================================================================================
class OgnEnumWrapper(og.AutoNodeDefinitionWrapper):
"""Wrapper around Enums"""
def __init__(
self,
target_class,
unique_name: str,
module_name: str,
*,
ui_name: str = None):
"""Generate a definition from a parsed enum
"""
self.target_class = target_class
self.unique_name = unique_name
self.ui_name = ui_name or target_class.__name__
self.module_name = module_name
# begin building the ogn descriptor
self.descriptor: Dict = {}
self.descriptor["uiName"] = ui_name
self.descriptor["version"] = 1
self.descriptor["language"] = "Python"
self.descriptor["description"] = f"Enum Wrapper for {self.ui_name}"
self.descriptor["inputs"] = OrderedDict({
"enum": {
"uiName": "Input",
"description": "Enum input",
"type": "uint64",
"default": 0,
"metadata": {
"python_type_desc" : self.unique_name }},
"exec": {
"uiName": "Exec",
"description": "Execution input",
"type": "execution",
"default": 0 }})
def signature(name):
return {
"description": f"Execute on {name}",
"type": "execution",
"default": 0 }
self.descriptor["outputs"] = OrderedDict({
name: signature(name) for name in self.target_class.__members__ })
# --------------------------------------------------------------------------------
def get_unique_name(self) -> str:
"""overloaded from AutoNodeDefinitionWrapper"""
return self.unique_name
# --------------------------------------------------------------------------------
def get_module_name(self) -> str:
"""overloaded from AutoNodeDefinitionWrapper"""
return self.module_name
# --------------------------------------------------------------------------------
def get_node_impl(self):
"""overloaded from AutoNodeDefinitionWrapper"""
class OgnEnumReturnType(
OgnEnumExecutionWrapper,
target_class=self.target_class):
pass
return OgnEnumReturnType
# --------------------------------------------------------------------------------
def get_ogn(self) -> Dict:
"""overloaded from AutoNodeDefinitionWrapper"""
d = {self.unique_name: self.descriptor}
return d
# ================================================================================
class EnumAutoNodeDefinitionGenerator(og.AutoNodeDefinitionGenerator):
_name = "Enum"
# --------------------------------------------------------------------------------
@classmethod
def generate_from_definitions(
cls,
target_type: type,
type_name_sanitized: str,
type_name_short: str,
module_name: str) -> Tuple[Iterable[og.AutoNodeDefinitionWrapper], Iterable[str]]:
members_covered = set()
returned_generators = set()
if hasattr(target_type, "__members__"):
ret = OgnEnumWrapper(
target_type,
unique_name=type_name_sanitized,
module_name=module_name,
ui_name=f"Switch on {type_name_short}")
members_covered.update(target_type.__members__)
returned_generators.add(ret)
return returned_generators, members_covered
# ================================================================================
# submit this to AutoNode
og.register_autonode_type_extension(og.EnumAutoNodeDefinitionGenerator)
Implementation Details
------------------------------
This information is presented for debugging purposes. *Do not rely on this information for your API*.
Name Mangling
++++++++++++++++++++++++++++++
To avoid name collisions between two nodes from different origins, OGN mangles names of functions. *If you are only using the UI to access your nodes, this shouldn't interest you*, but when accessing autogenerated nodes from code, the full node name is used.
Mangling is done according to these rules:
* Function specifiers have their ``.`` s replaced with ``__FUNC__`` as an infix, like: ``MyClass.Function -> MyClass__FUNC__Function``
* Property specifiers have their ``.`` s replaced with ``__PROP__`` as an infix, like: ``MyClass.Property -> MyClass__PROP__Property``
* Property getters and setters are suffixed as ``__GET`` and ``__SET``, like so: ``MyClass__PROP__Property__GET`` and ``MyClass__PROP__Property__SET``
* If any of those are nested inside another namespace will replace their separating dots with ``__NSP__``
Here is an example with conversions:
.. code-block:: python
import omni.graph.core as og
@og.AutoClass(module_name="test_module")
class TestClass:
class TestSubclass:
# TestClass__NSP__TestSubclass__PROP__public_var__GET
# TestClass__NSP__TestSubclass__PROP__public_var__SET
public_var: float = 3.141
# TestClass__FUNC__public_method
def public_method(self, exponent: float) -> float:
return self.public_var ** exponent
This is done in order to spawn the node with code, like so:
.. code-block:: python
import omni.graph.core as og
# This brings up `add_one` from the example above.
path_01 = '/Test/MyNodes/AddOne'
add_one = og.Controller.create_node(path_01, 'test_module.add_one')
# This brings up `TestClass.public_method` from the example above.
path_02 = '/Test/MyNodes/TestClassGetPublicMethod'
public_method = og.Controller.create_node(path_02, 'test_module.TestClass__FUNC__public_method')
path_03 = '/Test/MyNodes/TestClassGetPublicMethod'
public_var_getter = og.Controller.create_node(path_03, 'test_module.TestClass__NSP__TestSubclass__PROP__public_var__GET')
| 25,343 | reStructuredText | 37.516717 | 539 | 0.568402 |
omniverse-code/kit/exts/omni.graph/docs/running_one_script.rst | .. _run_omnigraph_python_script:
Running Minimal Kit With OmniGraph
==================================
The Kit application at its core is a basic framework from plugging in extensions with a common communication method.
We can take advantage of this to run a script that works with OmniGraph without pulling in the entire Kit overhead.
Running With Python Support
---------------------------
The most user-friendly approach to running a minimal version of Kit with OmniGraph is to make use of the `omni.graph`
extension, which adds Python bindings and scripts to the OmniGraph core.
Your extension must have a dependency on `omni.graph` using these lines in your `extension.toml` file:
.. code-block:: toml
[dependencies]
"omni.graph" = {}
Let's say your extension, `omni.my.extension`, has a single node type `MyNodeType` that when executed will take a
directory path name as input and will print out the number of files and total file size of every file in that
directory. This is a script that will set up and execute an OmniGraph that creates a node that will display that
information for the Omniverse Cache directory.
.. code-block:: Python
import carb
import omni.graph.core as og
import omni.usd
# This is needed to initialize the OmniGraph backing
omni.usd.get_context().new_stage()
# Get the cache directory to be examined
cache_directory = carb.tokens.get_tokens_interface().resolve("${omni_cache}")
# Create a graph with the node that will print out the cache directory contents
_ = og.Controller.edit("/CacheGraph", {
og.Controller.Keys.CREATE_NODES: ("MyNode", "omni.my.extension.MyNodeType"),
og.Controller.Keys.SET_VALUES: ("MyNode.inputs:directory", cache_directory)
})
# Evaluate the node to complete the operation
og.Controller.evaluate_sync()
If this script is saved in the file `showCache.py` then you run this from your Kit executable directory:
.. code-block:: sh
$ ./kit.exe --enable omni.my.extension --exec showCache.py
C:/Kit/cache contained 123 files with a total size of 456,789 bytes
.. note::
Running with only `omni.graph` enabled will work, but it is just a framework and has no nodes of its own to
execute. That is why you must enable your own extension. You might also want to enable other extensions such as
`omni.graph.nodes` or `omni.graph.action` if you want to access the standard set of OmniGraph nodes.
Running With Just The Core
--------------------------
If you have an extension that uses the C++ ABI to create and manipulate an OmniGraph you can run Kit with only
your extension enabled, executing a script that will trigger the code you wish to execute.
Your extension must have a dependency on `omni.graph.core` using these lines in your `extension.toml` file:
.. code-block:: toml
[dependencies]
"omni.graph.core" = {}
You can then run your own script `setUpOmniGraphAndEvaluate.py` that executes your C++ code to create and evaluate the
graph in a way similar to the above, but using the C++ ABI, with the same command line:
.. code-block:: sh
$ ./kit.exe --enable omni.my.extension --exec setUpOmniGraphAndEvaluate.py
| 3,199 | reStructuredText | 39.506329 | 118 | 0.723038 |
omniverse-code/kit/exts/omni.graph/docs/controller.rst | .. _omnigraph_controller_class:
OmniGraph Controller Class
==========================
.. _howto_omnigraph_controller:
The primary interface you can use for interacting with OmniGraph is the `Controller` class. It is in the main module
so you can access it like this:
.. code-block:: python
import omni.graph.core as og
keys = og.Controller.Keys
controller = og.Controller()
.. note::
For future examples these two lines will be assumed to be present.
Structure
---------
The `Controller` class is an amalgam of several other classes with specific subsets of functionality. It derives from
each of them, so that all of their functionality can be accessed through the one `Controller` class.
- **GraphController** handles operations that affect the structure of the graph
- **NodeController** handles operations that affect individual nodes
- **ObjectLookup** provides a generic set of interfaces for finding OmniGraph objects with a flexible set of inputs
- **DataView** lets you get and set attribute values
For the most part the controller functions can be accessed as static class members:
.. code-block:: python
og.Controller.edit("/World/MyGraph", {keys.CREATE_NODES: ("MyNode", "omni.graph.tutorials.SimpleData")})
og.Controller.edit("/World/MyGraph", {keys.SET_VALUES: ("/World/MyGraph/MyNode.inputs:a_bool", False)})
A second way to do it is to instantiate the controller so that the relative paths are all remembered:
.. code-block:: python
controller.edit("/World/MyGraph", {keys.CREATE_NODES: ("MyNode", "omni.graph.tutorials.SimpleData")})
controller.edit("/World/MyGraph", {keys.SET_VALUES: ("MyNode.inputs:a_bool", False)})
Or you can remember the return values of the first call yourself and reuse them:
.. code-block:: python
(graph, nodes, _, _) = og.Controller.edit("/World/MyGraph", {keys.CREATE_NODES: ("MyNode", "omni.graph.tutorials.SimpleData")})
og.Controller.edit(graph, {keys.SET_VALUES: (("inputs:a_bool", nodes[0]), False))
The exceptions are when using the :py:class:`omni.graph.core.DataView` functions, as that class requires an attribute
in order to perform its operations. For those you can pass an `Attribute` or `AttributeValue` identifier to construct
a controller that can handle those operations:
.. code-block:: python
controller = og.Controller(og.Controller.attribute("/World/MyGraph/MyNode.inputs:myInput"))
print(f"My attribute value is {controller.get()}")
.. literalinclude:: ../../../../source/extensions/omni.graph/python/_impl/controller.py
:language: python
:start-after: begin-controller-docs
:end-before: end-controller-docs
Controller Functions
--------------------
In addition to the functions inherited from the other classes the `Controller` has a couple of key functions itself.
There is a coroutine to evaluate one or more graphs:
.. code-block:: python
async def my_function():
await og.Controller.evaluate()
The :py:meth:`evaluate()<omni.graph.core.Controller.evaluate>` method takes an optional parameter
with a graph or list of graphs to be evaluated. By default it evaluates all graphs in the scene.
If you want to evaluate but are not in a coroutine then you can use the synchronous version `evaluate_sync()`
.. code-block:: python
def my_normal_function():
og.Controller.evaluate_sync()
The :py:meth:`evaluate_sync()<omni.graph.core.Controller.evaluate_sync>` method also takes an optional parameter
with a graph or list of graphs to be evaluated. By default it evaluates all graphs in the scene.
The workhorse of the controller class is the :py:meth:`edit()<omni.graph.core.Controller.edit>` method. It provides
simple access to a lot of the underlying functionality for manipulating the contents of OmniGraph.
It should be noted here that this method can be accessed as both a class method and an object method. The reason you
would create an instance of a `Controller` object is if you wish to preserve the internal mapping of node names to
instantiated node paths for future use.
For example, this code sequence could be used to create a node and then set a value on one of its attributes:
.. code-block:: python
og.Controller.edit("/World/PushGraph",
{
og.Controller.Keys.CREATE_NODES: ("NewNode", "omni.graph.nodes.Add"),
og.Controller.Keys.SET_VALUES: ("NewNode.inputs:a", {"type": "float", "value": 1.0})
}
)
In this example the extended version of value setting is used, where both the type and value are provided so that
the extended attribute type in `omni.graph.nodes.Add` can resolve its type.
ObjectLookup
------------
This class contains the functions you will probably use the most. It provides an extremely flexible method for looking
up OmniGraph objects from the information you have on hand. The specs it accepts as arguments can be seen in the
:py:class:`class documentation<omni.graph.core.ObjectLookup>`.
Here's a quick summary of the most useful methods on this class:
- :py:meth:`graph()<omni.graph.core.ObjectLookup.graph>` gets an **og.Graph** object
- :py:meth:`node()<omni.graph.core.ObjectLookup.node>` gets an **og.Node** object
- :py:meth:`attribute()<omni.graph.core.ObjectLookup.attribute>` gets an **og.Attribute** object
- :py:meth:`attribute_type()<omni.graph.core.ObjectLookup.attribute_type>` gets an **og.Type** object
- :py:meth:`node_type()<omni.graph.core.ObjectLookup.node_type>` gets an **og.NodeType** object
- :py:meth:`prim()<omni.graph.core.ObjectLookup.prim>` gets a **Usd.Prim** object
- :py:meth:`usd_attribute()<omni.graph.core.ObjectLookup.usd_attribute>` gets a **Usd.Attribute** object
- :py:meth:`variable()<omni.graph.core.ObjectLookup.variable>` gets a **og.IVariable** object
Other methods will be added as they become useful.
GraphController
---------------
This class contains the functions that manipulate the structure of the graph, including creating a graph. The
:py:class:`class documentation<omni.graph.core.GraphController>` describe the details of what it can do.
Here's a quick summary of the most useful methods in the class. All but the last of them can be accessed through
different keywords in the dictionary passed to :py:meth:`og.Controller.edit()<omni.graph.core.Controller.edit>`.
- :py:meth:`create_graph()<omni.graph.core.GraphController.create_graph>` creates a new **og.Graph**
- :py:meth:`create_node()<omni.graph.core.GraphController.create_node>` creates a new **og.Node**
- :py:meth:`create_prim()<omni.graph.core.GraphController.create_prim>` creates a new **Usd.Prim**
- :py:meth:`create_variable()<omni.graph.core.GraphController.create_variable>` creates a new **og.IVariable**
- :py:meth:`delete_node()<omni.graph.core.GraphController.delete_node>` deletes an existing **og.Node**
- :py:meth:`expose_prim()<omni.graph.core.GraphController.expose_prim>` makes a **Usd.Prim** visible to OmniGraph through a read node
- :py:meth:`connect()<omni.graph.core.GraphController.connect>` connects two **og.Attributes** together
- :py:meth:`disconnect()<omni.graph.core.GraphController.disconnect>` breaks an existing connection between two **og.Attributes**
- :py:meth:`disconnect_all()<omni.graph.core.GraphController.disconnect_all>` disconnects everything from an existing **og.Attribute**
- :py:meth:`set_variable_default_value()<omni.graph.core.GraphController.set_variable_default_value>` sets the default value of an **og.IVariable**
- :py:meth:`get_variable_default_value()<omni.graph.core.GraphController.get_variable_default_value>` gets the default value of an **og.IVariable**
NodeController
--------------
This class contains the functions that manipulate the contents of a node. It only has a few functions. The
:py:class:`class documentation<omni.graph.core.NodeController>` outlines its areas of control.
Here's a quick summary of the most useful methods in the class:
- :py:meth:`create_attribute()<omni.graph.core.NodeController.create_attribute>` creates a new dynamic **og.Attribute**
- :py:meth:`remove_attribute()<omni.graph.core.NodeController.remove_attribute>` removes an existing dynamic **og.Attribute**
- :py:meth:`safe_node_name()<omni.graph.core.NodeController.safe_node_name>` returns a node name based on an **og.NodeType** that is USD-safe
.. note::
A **dynamic** attribute in this context means an attribute that can be added to the node that does not exist in the
node's .ogn file.
DataView
--------
This class contains the functions to get and set attribute values. It has a flexible **__init__** function that can
optionally take an "attribute" parameter to specify either an **og.Attribute** or **og.AttributeData** to which the
data operations will apply. The :py:class:`class documentation<omni.graph.core.DataView>` shows the available
functionality.
Here's a quick summary of the most useful methods in the class:
- :py:meth:`get()<omni.graph.core.DataView.get>` gets the current value of the attribute
- :py:meth:`get_array_size()<omni.graph.core.DataView.get_array_size>` gets the number of elements in an array attribute
- :py:meth:`set()<omni.graph.core.DataView.set>` sets a new value on the attribute
All of these methods are set up to work either as class methods or as object methods. The difference is that when
called as a class method you have add an extra parameter at the beginning that is the attribute whose value is being
processed.
These two calls, for example, are equivalent:
.. code-block:: python
attribute = og.Controller.attribute("/World/PushGraph/Add:inputs:a")
# As a class method
value = og.DataView.get(attribute)
# or value = og.Controller.get(attribute)
# As an object method
value = og.DataView(attribute=attribute).get()
# or value = og.Controller(attribute=attribute).get()
| 9,827 | reStructuredText | 47.653465 | 147 | 0.741935 |
omniverse-code/kit/exts/omni.graph/docs/omni.graph.core.bindings.rst | omni.graph.core.bindings
========================
All of the OmniGraph ABI interfaces have Python bindings on top of them, as well as additional bindings that provide
convenient Pythonic access to some of the data.
See the full description in the :ref:`Python API<omnigraph_python_api>`
| 289 | reStructuredText | 35.249996 | 116 | 0.733564 |
omniverse-code/kit/exts/omni.graph/docs/commands.rst | OmniGraph Commands
==================
Like other extensions, the OmniGraph extensions expose undoable functionality through some basic commands. A lot
of the functionality of the commands can be accessed from the *og.Controller* object, described above.
OmniGraph has created a shortcut to allow more natural expression of command execution. The raw method of executing a
command is something like this:
.. code-block:: python
import omni.graph.core as og
graph = og.get_graph_by_path("/World/PushGraph")
omni.kit.commands.execute("CreateNode", graph=graph, node_path="/World/PushGraph/TestSingleton", node_type="omni.graph.examples.python.TestSingleton", create_usd=True)
The abbreviated method, using the constructed *cmds* object looks like this:
.. code-block:: python
import omni.graph.core as og
graph = og.get_graph_by_path("/World/PushGraph")
cmds.CreateNode(graph=graph, node_path="/World/PushGraph/TestSingleton", node_type="omni.graph.examples.python.TestSingleton", create_usd=True)
However for most operations you would use the controller class, which is a single line:
.. code-block:: python
import omni.graph.core as og
og.Controller.edit("/World/PushGraph", {
og.Controller.Keys.CREATE_NODES: ("TestSingleton", "omni.graph.examples.python.TestSingleton")
})
.. tip::
Running the Python command *help(omni.graph.core.cmds)* in the script editor will give you a description of
all available commands.
| 1,479 | reStructuredText | 38.999999 | 171 | 0.745098 |
omniverse-code/kit/exts/omni.graph/docs/CHANGELOG.md | # Changelog
All notable changes to this project will be documented in this file.
The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
## [Unreleased]
## [1.50.2] - 2023-02-14
### Fixed
- Made test file pattern account for node files not beginning with Ogn
## [1.50.1] - 2022-11-22
### Added
- Documentation for running a minimal Kit with OmniGraph
## [1.50.0] - 2022-11-15
### Changed
- Default simple dynamic attribute values to the CPU
## [1.49.0] - 2022-11-14
### Added
- instance_path argument added to IVariable.get, get_array and set methods to specify the instance of the variable
- node_type.get_path(), which returns the path to the prim associated with a node type
## [1.48.0] - 2022-11-09
### Added
- Support for redirecting dynamic attributes to the GPU
## [1.47.1] - 2022-10-18
### Fixed
- Corrected the path to the default category files
## [1.47.0] - 2022-09-28
### Changed
- Refactored controller classes to accept variable arguments in all methods and constructor
### Removed
- References to obsolete set of unsupported types
- Last remaining references to the obsolete ContextHelper
### Added
- Argument flattening utility
## [1.46.0] - 2022-09-27
### Added
- Collection of registration and deregistration timing for Python node types
## [1.45.2] - 2022-09-01
### Fixed
- Fixed the type name access in the node controller to handle bundles properly
## [1.45.1] - 2022-08-31
### Fixed
- Refactored out use of a deprecated class
## [1.45.0] - 2022-08-30
### Added
- Handling for allocation of memory and transfer of values for Python default values
## [1.44.0] - 2022-08-25
### Added
- Access to new setting that turns deprecations into errors
## [1.43.0] - 2022-08-17
### Added
- Cross-handling of array and non-array types when compatible
## [1.42.0] - 2022-08-12
### Changed
- og.AttributeData now raise exceptions for errors instead of printing
## [1.41.1] - 2022-08-09
### Fixed
- All of the lint errors reported on the Python files in this extension
## [1.41.0] - 2022-08-02
### Added
- Optimize attribute setting from python nodes - during runtime computation we skip commands (no need for undo)
## [1.40.0] - 2022-07-27
### Added
- IBundle2 remove_attributes_by_name, remove_child_bundles_by_name
## [1.39.0] - 2022-07-27
### Changed
- Added better __repr__ to Attribute and Node
## [1.38.1] - 2022-07-26
### Fixed
- Adjusted config to avoid obsolete commands module
- Added firewall protection to AutoFunc and AutoClass initialization so that they work in the script editor
## [1.38.0] - 2022-07-19
### Added
- IBundle2 interface API review
## [1.37.0] - 2022-07-12
### Added
- Python performance: database caching, prefetch and commit for batching of simple attribute reads/writes
## [1.36.0] - 2022-07-12
### Fixed
- Backward compatibility of the generated attribute descriptions.
## [1.35.0] - 2022-07-08
### Added
- omni.graph.core.Attribute.is_deprecated()
- omni.graph.core.Attribute.deprecation_message()
- omni.graph.core.Internal sub-module
- omni.graph.core.Internal._deprecateAttribute()
## [1.34.0] - 2022-07-07
### Changed
- Refactored imports from omni.graph.tools to get the new locations
- Moved node_generator/ into the _impl/ subdirectory
- Made dunder attribute names in AttributeDataValueHelper into single-underscore to avoid Python compatibility problem
### Added
- Test for public API consistency
## [1.33.0] - 2022-07-06
### Added
- Metadata support for IBundle2 interface
## [1.32.3] - 2022-07-04
### Fixed
- Py_GraphContext's __eq__ and __hash__ now use the underlying GraphContext object rather than the Python wrapper
## [1.32.2] - 2022-06-28
### Changed
- Made node type failure a more actionable error
- Bootstrap the nodeContextHandle to allow independent database creation
### Added
- Linked docs in the build area
## [1.32.1] - 2022-06-26
### Changed
- Made node type failure a more actionable error
## [1.32.0] - 2022-06-26
### Added
- Added test for clearing bundle contents
## [1.31.1] - 2022-06-21
### Changed
- Fixed error in graph_settings when loading non-schema prims
## [1.31.0] - 2022-06-17
### Added
- omni.graph.core.graph.get_evaluator_name()
## [1.30.1] - 2022-06-17
### Added
- Added ApplyOmniGraph and RemoveOmniGraph api commands
## [1.30.0] - 2022-06-13
### Added
- omni.graph.core.GraphEvaluationMode enum
- evaluation_mode argument added to omni.graph.core.Graph.create_graph_as_node
- evaluation_mode property added to omni.graph.core.Graph
- SetEvaluationModeCommand
- evaluation_mode parameter added to CreateGraphAsNodeCommand
- evaluation_mode option added to GraphController
## [1.29.0] - 2022-06-13
### Added
- Temporary binding function to prevent Python node initialization from overwriting values already set
## [1.28.0] - 2022-06-07
### Added
- Added CPU-GPU pointer support in data_view class and propagation of the state through python wrapper classes
## [1.27.0] - 2022-06-07
### Added
- Support for the generator settings to complement runtime settings
## [1.26.1] - 2022-06-04
### Fixed
- Nodes with invalid connections no longer break upgrades to OmniGraph schema
## [1.26.0] - 2022-05-06
### Fixed
- Handling of runtime attributes whose bundle uses CPU to GPU pointers
### Added
- Support for CPU to GPU data in the DataWrapper
## [1.25.0] - 2022-05-05
### Removed
- Python subscriptions to changes in settings, now handled in C++
## [1.24.1] - 2022-05-05
### Deprecated
- Deprecated OmniGraphHelper and ContextHelper for og.Controller
## [1.24.0] - 2022-04-29
### Fixed
- Fixed override method for IPythonNode type
### Removed
- Obsolete example files
### Added
- Explicit settings handler
### Changed
- Used explicit OmniGraph test handler base classes
## [1.24.0] - 2022-04-27
### Added
- *GraphController.set_variable_default_value*
- *GraphController.get_variable_default_value*
- *ObjectLookup.variable*
- *GraphContext.get_graph_target*
## [1.23.0] - 2022-04-25
### Added
- Added a test to confirm that all version references in omni.graph.* match
## [1.22.2] - 2022-04-20
### Fixed
- Undoing the deletion of a connection's src prim will now restore the connection on undo.
## [1.22.1] - 2022-04-18
### Changed
- og.Attribute will now raise an exception when methods are called when in an invalid state.
## [1.22.0] - 2022-04-11
### Fixed
- Moved Py_Node and Py_Graph callback lists to static storage where they won't
be destroyed prematurely.
- Callback objects now get destroyed when the extension is unloaded.
## [1.21.1] - 2022-04-05
### Fixed
- Added hash check to avoid overwriting ogn/tests/__init__.py when it hasn't changed
- Fix deprecated generator of ogn/tests/__init__.py to generate a safer, non-changing version
## [1.21.0] - 2022-03-31
### Added
- `IConstBundle2`, `IBundle2` and `IBundleFactory` interface python bindings.
- Unit tests for bundle interfaces
## [1.20.1] - 2022-03-24
### Fixed
- Fixed location of live-generation of USD files from .ogn
- Fixed contents of the generated tests/__init__.py file
### [1.20.0] - 2022-03-23
### Added
- *GraphEvent.CREATE_VARIABLE* and *GraphEvent.REMOVE_VARIABLE* event types
- *Graph.get_event_stream()*
## [1.19.0] - 2022-03-18
### Added
- Added command to set variable tooltip
## [1.18.0] - 2022-03-16
### Added
- support for *enableLegacyPrimConnection* setting to test utils
## [1.17.1] - 2022-03-14
### Fixed
- Corrected creation of implicit graphs that were not at the root path
- Added tests for such graphs and a graph in a layer
## [1.17.0] - 2022-03-11
### Added
- *Node.get_backing_bucket_id()*
- *GraphContext.write_bucket_to_backing()*
## [1.16.0] - 2022-03-01
### Added
- *expected_error.ExpectedError* (moved from omni.graph.test)
### Changed
- Updated OmniGraphTestCase and derived classes to use *test_case_class*
## [1.15.0] - 2022-02-16
### Added
- Added commands to create and remove variables
## [1.14.0] - 2022-02-11
### Added
- *Attribute.register_value_changed_callback*
- *Database.get_variable*
- *Database.set_variable*
- *Controller.keys.CREATE_VARIABLES*
- *GraphController.create_variable*
## [1.13.0] - 2022-02-10
### Added
- Added support for migration of old graphs to use schema prims
## [1.12.2] - 2022-02-07
### Changed
- Moved carb logging out of database.py and into Node::logComputeMessage.
- Fall back to old localized logging for Python nodes which don't yet
support the compute message logging ABI.
## [1.12.1] - 2022-02-04
### Fixed
- Compute counts weren't working for Python nodes
- Compute messages from Python nodes weren't visible in the graph editors
## [1.12.0] - 2022-01-28
### Added
- Support for WritePrim creation in *GraphController.expose_prims*
## [1.11.0] - 2022-01-29
### Changed
- Reflecting change of omni.graph.core from 2.11 -> 2.12
## [1.10.0] - 2022-01-27
### Added
- *ObjectLookup.usd_attribute*
## [1.9.0] - 2022-01-21
### Added
- *Node.log_compute_message*
- *Node.get_compute_messages*
- *Node.clear_old_compute_messages*
- *Graph.register_error_status_change_callback*
- *Graph.deregister_error_status_change_callback*
- *Severity* enum
## [1.8.0] - 2021-12-17
### Added
- Added *NodeType.get_all_categories_*
- Added *get_node_categories_interface*
- Created binding class *NodeCategories*
## [1.7.0] - 2021-12-15
### Added
- Added _NodeType::isValid_ and cast to bool
- Added _Controller_ class
- Added _GraphController_ class
## [1.6.0] - 2021-12-06
### Added
- og.NodeEvent.ATTRIBUTE_TYPE_RESOLVE
## [1.5.2] - 2021-12-03
### Added
- Node, Attribute, AttributeData, Graph, and Type objects are now hashable
in Python, meaning that they can be used in sets, as keys in dicts, etc.
### Fixed
- Comparing Node and Graph objects for equality in Python now compare the
actual objects referenced rather than the wrappers which hold the references
- Comparing Attribute and AttributeData objects to None in Python no longer
generates an exception.
## [1.5.0] - 2021-12-01
- Added functions to get extension versions for core and tools
- Added cascading Python node registration process, that auto-generates when out of date
- Added user cache location for live regeneration of nodes
## [1.4.0] - 2021-11-26
### Added
- Python Api `Graph.get_parent_graph`
### Fixed
- Fix failure when disconnecting a connection from a subgraph node to the parent graph node
## [1.3.2] - 2021-11-24
### Changed
- Generated python nodes will emit info instead of warning when inputs are unresolved
## [1.3.1] - 2021-11-22
### Changed
- Improved error messages from wrapped functions
## [1.3.0] - 2021-11-19
### Added
- __bool__ operators added to all returned OG Objects. So `if node:` is equivalent to `if node.is_valid():`
### Changed
- Bug fix in Graph getter methods
## [1.2.0] - 2021-11-10
### Added
- `og.get_node_by_path`
- `get_graph_by_path`, `get_node_by_path` now return None on failure
## [1.1.0] - 2021-10-17
### Added
- og.get_graph_by_path
## [1.0.0] - 2021-10-17
### Initial Version
- Started changelog with current version of omni.graph
| 11,068 | Markdown | 28.128947 | 118 | 0.714583 |
omniverse-code/kit/exts/omni.graph/docs/python_api.rst | .. _omnigraph_python_api:
OmniGraph Python API Documentation
**********************************
.. automodule:: omni.graph.core
:platform: Windows-x86_64, Linux-x86_64, Linux-aarch64
:members:
:undoc-members:
:imported-members:
| 246 | reStructuredText | 21.454544 | 58 | 0.601626 |
omniverse-code/kit/exts/omni.graph/docs/README.md | # OmniGraph [omni.graph]
This extension provides the Python bindings, script support, data files, and other non-core support for the OmniGraph
implementation extension `omni.graph.core`.
It behaves as an addition to that extension, so you will still use the Python import path `omni.graph.core` for
scripts in this directory.
| 328 | Markdown | 40.124995 | 117 | 0.795732 |
omniverse-code/kit/exts/omni.graph/docs/index.rst | .. _omnigraph_python_scripting:
OmniGraph Python Scripting
##########################
.. tabularcolumns:: |L|R|
.. csv-table::
:width: 100%
**Extension**: omni.graph,**Documentation Generated**: |today|
While the core part of OmniGraph is built in C++ there are Python bindings and scripts built on top of it to make
it easier to work with.
Importing
---------
The Python interface is exposed in a consistent way so that you can easily find any of the OmniGraph scripting
information. Any script can start with this simple import, in the spirit of how popular packages such as `numpy`
and `pandas` work:
.. code-block:: python
import omni.graph.core as og
Using this module you can access internal documentation through the usual Python mechanisms:
.. code-block:: python
help(og)
Bindings
--------
The first level of support is the :doc:`Python Bindings<omni.graph.core.bindings>` which provide a wrapper on top of the
C++ ABI of the OmniGraph core. These have been made available from the same import to make user of all OmniGraph
functionality consistent. When you are programming in Python you really don't need to be aware of the C++
underpinnings.
The bound functions have all of the same documentation available at runtime so they can be inspected in the same way
you would work with any regular Pythyon scripts. For the most part the bindings follow the C++ ABI closely, with the
minor exception of using the standard PEP8 naming conventions rather than the established C++ naming conventions.
For example a C++ ABI function `getAttributeType` will be named `get_attribute_type` in the Python binding. This was
primarily done to deemphasize the boundary between Python and C++ so that Python writers can stick with Python
conventions and C++ writers can stick with C++ conventions.
As the Python world doesn't have the C++ concept of an interface definition there is no separation between the
objects providing the functionality and the objects storing the implementation and data. For example in C++ you
would have an `AttributeObj` which contains a handle to the internal data and a reference to the `IAttribute`
interface definition. In Python you only have the `og.Attribute` object which encapsulates both.
You can see the online version of the Python documentation at :ref:`omnigraph_python_api`.
The One Thing You Need
----------------------
A lot of the imported submodules and functions available are used internally by generated code and you won't have
much occasion to use them. You can explore the internal documentation to see if any look useful to you. The naming
was intentionally made verbose so that it's easier to discover functionality.
.. _ogn_omnigraph_controller:
One class deserves special attention though, as it is quite useful for interacting with the OmniGraph.
.. code-block:: python
import omni.graph.core as og
controller = og.Controller()
The `Controller` class provides functionality for you to change the graph topology, or modify and inspect
values within the graph.
.. literalinclude:: ../python/_impl/controller.py
:language: python
:start-after: begin-controller-docs
:end-before: end-controller-docs
See the internal documentation at :py:class:`omni.graph.core.Controller` for details, or take a tour of how to use
the controller with :ref:`this how-to documentation<howto_omnigraph_controller>`
.. toctree::
:maxdepth: 1
:caption: Contents
OmniGraph Commands <commands>
How-To Guides<../../omni.graph.core/docs/how_to.rst>
running_one_script
Python API <python_api>
omni.graph.core.bindings
autonode
How versions are updated <../../omni.graph.core/docs/versioning>
controller
runtimeInitialize
testing
CHANGELOG
| 3,775 | reStructuredText | 37.141414 | 120 | 0.753113 |
omniverse-code/kit/exts/omni.graph/docs/Overview.md | # OmniGraph Python Scripting
```{csv-table}
**Extension**: omni.graph,**Documentation Generated**: {sub-ref}`today`
```
While the core part of OmniGraph is built in C++ there are Python bindings and scripts built on top of it to make
it easier to work with.
## Importing
The Python interface is exposed in a consistent way so that you can easily find any of the OmniGraph scripting
information. Any script can start with this simple import, in the spirit of how popular packages such as `numpy`
and `pandas` work:
```python
import omni.graph.core as og
```
Using this module you can access internal documentation through the usual Python mechanisms:
```python
help(og)
```
## Bindings
The first level of support is the [Python Bindings](omni.graph.core.bindings) which provide a wrapper on top of the
C++ ABI of the OmniGraph core. These have been made available from the same import to make user of all OmniGraph
functionality consistent. When you are programming in Python you really don't need to be aware of the C++
underpinnings.
The bound functions have all of the same documentation available at runtime so they can be inspected in the same way
you would work with any regular Pythyon scripts. For the most part the bindings follow the C++ ABI closely, with the
minor exception of using the standard PEP8 naming conventions rather than the established C++ naming conventions.
For example a C++ ABI function `getAttributeType` will be named `get_attribute_type` in the Python binding. This was
primarily done to deemphasize the boundary between Python and C++ so that Python writers can stick with Python
conventions and C++ writers can stick with C++ conventions.
As the Python world doesn't have the C++ concept of an interface definition there is no separation between the
objects providing the functionality and the objects storing the implementation and data. For example in C++ you
would have an `AttributeObj` which contains a handle to the internal data and a reference to the `IAttribute`
interface definition. In Python you only have the `og.Attribute` object which encapsulates both.
You can see the online version of the Python documentation at {doc}`API`.
## The One Thing You Need
A lot of the imported submodules and functions available are used internally by generated code and you won't have
much occasion to use them. You can explore the internal documentation to see if any look useful to you. The naming
was intentionally made verbose so that it's easier to discover functionality.
(ogn_omnigraph_controller)=
One class deserves special attention though, as it is quite useful for interacting with the OmniGraph.
```python
import omni.graph.core as og
controller = og.Controller()
```
The `Controller` class provides functionality for you to change the graph topology, or modify and inspect
values within the graph.
```{literalinclude} ../../../../source/extensions/omni.graph/python/_impl/controller.py
---
language: python
start-after: begin-controller-docs
end-before: end-controller-docs
---
```
See the internal documentation at {py:class}`omni.graph.core.Controller` for details, or take a tour of how to use
the controller with {ref}`this how-to documentation<howto_omnigraph_controller>`
- [](commands)
- [How to guides](../../omni.graph.core/latest/how_to.html)
- [](running_one_script)
- [](API)
- [](omni.graph.core.bindings)
- [](autonode)
- [How versions are updated](../../omni.graph.core/latest/versioning.html)
- [](controller)
- [](runtimeInitialize)
- [](testing)
- [](CHANGELOG)
| 3,548 | Markdown | 38.433333 | 116 | 0.768602 |
omniverse-code/kit/exts/omni.kit.actions.core/omni/kit/actions/core/_kit_actions_core.pyi | """pybind11 omni.kit.actions.core bindings"""
from __future__ import annotations
import omni.kit.actions.core._kit_actions_core
import typing
__all__ = [
"Action",
"IActionRegistry",
"acquire_action_registry",
"release_action_registry"
]
class Action():
"""
Abstract action base class.
"""
def __init__(self, extension_id: str, action_id: str, python_object: object, display_name: str = '', description: str = '', icon_url: str = '', tag: str = '') -> None:
"""
Create an action.
Args:
extension_id: The id of the source extension registering the action.
action_id: Id of the action, unique to the extension registering it.
python_object: The Python object called when the action is executed.
display_name: The name of the action for display purposes.
description: A brief description of what the action does.
icon_url: The URL of an image which represents the action.
tag: Arbitrary tag used to group sets of related actions.
Return:
The action that was created.
"""
def execute(self, *args, **kwargs) -> object:
"""
Execute the action.
Args:
*args: Variable length argument list which will be forwarded to execute.
**kwargs: Arbitrary keyword arguments that will be forwarded to execute.
Return:
The result of executing the action, converted to a Python object (could be None).
"""
def invalidate(self) -> None:
"""
Invalidate this action so that executing it will not do anything.
This can be called if it is no longer safe to execute the action,
and by default is called when deregistering an action (optional).
"""
@property
def description(self) -> str:
"""
Get the description of this action.
Return:
str: The description of this action.
:type: str
"""
@property
def display_name(self) -> str:
"""
Get the display name of this action.
Return:
str: The display name of this action.
:type: str
"""
@property
def extension_id(self) -> str:
"""
Get the id of the source extension which registered this action.
Return:
str: The id of the source extension which registered this action.
:type: str
"""
@property
def icon_url(self) -> str:
"""
Get the URL of the icon used to represent this action.
Return:
str: The URL of the icon used to represent this action.
:type: str
"""
@property
def id(self) -> str:
"""
Get the id of this action, unique to the extension that registered it.
Return:
str: The id of this action, unique to the extension that registered it.
:type: str
"""
@property
def parameters(self) -> dict:
"""
Get the parameters accepted by this action's execute function.
Return:
dict: The parameters accepted by this action's execute function.
:type: dict
"""
@property
def requires_parameters(self) -> bool:
"""
Query whether this action requires any parameters to be passed when executed?
Return:
bool: True if this action requires any parameters to be passed when executed, false otherwise.
:type: bool
"""
@property
def tag(self) -> str:
"""
Get the tag that this action is grouped with.
Return:
str: The tag that this action is grouped with.
:type: str
"""
pass
class IActionRegistry():
"""
Maintains a collection of all registered actions and allows any extension to discover them.
"""
@staticmethod
def deregister_action(*args, **kwargs) -> typing.Any:
"""
Deregister an action.
Args:
action: The action to deregister.
invalidate: Should the action be invalidated so executing does nothing?
Find and deregister an action.
Args:
extension_id: The id of the source extension that registered the action.
action_id: Id of the action, unique to the extension that registered it.
invalidate: Should the action be invalidated so executing does nothing?
Return:
The action if it exists and was deregistered, an empty object otherwise.
"""
def deregister_all_actions_for_extension(self, extension_id: str, invalidate: bool = True) -> None:
"""
"Deregister all actions that were registered by the specified extension.
Args:
extension_id: The id of the source extension that registered the actions.
iinvalidate: Should the actions be invalidated so executing does nothing?
"""
def execute_action(self, extension_id: str, action_id: str, *args, **kwargs) -> object:
"""
Find and execute an action.
Args:
extension_id: The id of the source extension that registered the action.
action_id: Id of the action, unique to the extension that registered it.
*args: Variable length argument list which will be forwarded to execute.
**kwargs: Arbitrary keyword arguments that will be forwarded to execute.
Return:
The result of executing the action, which is an arbitrary Python object
that could be None (will also return None if the action was not found).
"""
@staticmethod
def get_action(*args, **kwargs) -> typing.Any:
"""
Get an action.
Args:
extension_id: The id of the source extension that registered the action.
action_id: Id of the action, unique to the extension that registered it.
Return:
The action if it exists, an empty object otherwise.
"""
@staticmethod
def get_all_actions(*args, **kwargs) -> typing.Any:
"""
Get all registered actions.
Return:
All registered actions.
"""
@staticmethod
def get_all_actions_for_extension(*args, **kwargs) -> typing.Any:
"""
Get all actions that were registered by the specified extension.
Args:
extension_id: The id of the source extension that registered the actions.
Return:
All actions that were registered by the specified extension.
"""
@staticmethod
def register_action(*args, **kwargs) -> typing.Any:
"""
Register an action.
Args:
action: The action to register.
Create and register an action.
Args:
extension_id: The id of the source extension registering the action.
action_id: Id of the action, unique to the extension registering it.
python_object: The Python object called when the action is executed.
display_name: The name of the action for display purposes.
description: A brief description of what the action does.
icon_url: The URL of an image which represents the action.
tag: Arbitrary tag used to group sets of related actions.
Return:
The action if it was created and registered, an empty object otherwise.
"""
pass
def acquire_action_registry(plugin_name: str = None, library_path: str = None) -> IActionRegistry:
pass
def release_action_registry(arg0: IActionRegistry) -> None:
pass
| 8,190 | unknown | 32.161943 | 172 | 0.567521 |
omniverse-code/kit/exts/omni.kit.actions.core/omni/kit/actions/core/__init__.py | # Copyright (c) 2023, NVIDIA CORPORATION. All rights reserved.
#
# NVIDIA CORPORATION and its licensors retain all intellectual property
# and proprietary rights in and to this software, related documentation
# and any modifications thereto. Any use, reproduction, disclosure or
# distribution of this software and related documentation without an express
# license agreement from NVIDIA CORPORATION is strictly prohibited.
#
"""
Omni Kit Actions Core
---------------------
Omni Kit Actions Core is a framework for creating, registering, and discovering actions.
Here is an example of registering an action that creates a new file when it is executed:
.. code-block::
action_registry = omni.kit.actions.core.get_action_registry()
actions_tag = "File Actions"
action_registry.register_action(
extension_id,
"new",
omni.kit.window.file.new,
display_name="File->New",
description="Create a new USD stage.",
tag=actions_tag,
)
For more examples, please consult the Python and C++ Usage Example pages.
For Python API documentation, please consult the following subpages.
For C++ API documentation, please consult the API(C++) page.
"""
__all__ = ["Action", "IActionRegistry", "get_action_registry", "execute_action"]
from .actions import *
| 1,310 | Python | 31.774999 | 88 | 0.717557 |
omniverse-code/kit/exts/omni.kit.actions.core/omni/kit/actions/core/actions.py | # Copyright (c) 2023, NVIDIA CORPORATION. All rights reserved.
#
# NVIDIA CORPORATION and its licensors retain all intellectual property
# and proprietary rights in and to this software, related documentation
# and any modifications thereto. Any use, reproduction, disclosure or
# distribution of this software and related documentation without an express
# license agreement from NVIDIA CORPORATION is strictly prohibited.
#
import omni.ext
from ._kit_actions_core import *
# Put interface object publicly to use in our API.
_action_registry = None
# public API
def get_action_registry() -> IActionRegistry:
"""
Get the action registry.
Return:
ActionRegistry object which implements the IActionRegistry interface.
"""
return _action_registry
def execute_action(extension_id: str, action_id: str, *args, **kwargs):
"""
Find and execute an action.
Args:
extension_id: The id of the source extension that registered the action.
action_id: Id of the action, unique to the extension that registered it.
*args: Variable length argument list which will be forwarded to execute.
**kwargs: Arbitrary keyword arguments that will be forwarded to execute.
Return:
The result of executing the action, which is an arbitrary Python object
that could be None (will also return None if the action was not found).
"""
return get_action_registry().execute_action(extension_id, action_id, *args, **kwargs)
# Use extension entry points to acquire and release the interface.
class ActionsExtension(omni.ext.IExt):
def __init__(self):
super().__init__()
global _action_registry
_action_registry = acquire_action_registry()
def on_shutdown(self):
global _action_registry
release_action_registry(_action_registry)
_action_registry = None
| 1,884 | Python | 33.272727 | 89 | 0.710722 |
omniverse-code/kit/exts/omni.kit.actions.core/omni/kit/actions/core/tests/test_actions.py | # Copyright (c) 2023, NVIDIA CORPORATION. All rights reserved.
#
# NVIDIA CORPORATION and its licensors retain all intellectual property
# and proprietary rights in and to this software, related documentation
# and any modifications thereto. Any use, reproduction, disclosure or
# distribution of this software and related documentation without an express
# license agreement from NVIDIA CORPORATION is strictly prohibited.
#
import inspect
import omni.kit.test
import omni.kit.app
import omni.kit.actions.core
from ._kit_actions_core_tests import *
_last_args = None
_last_kwargs = None
_was_called = False
_action_tests = None
_print_execution_info = False
def setUpModule():
global _action_tests
_action_tests = acquire_action_tests()
_action_tests.print_test_action_execution_info = _print_execution_info
def tearDownModule():
global _action_tests
release_action_tests(_action_tests)
_action_tests = None
def test_callable_function(*args, **kwargs):
global _last_args, _last_kwargs, _was_called, _print_execution_info
_last_args = args
_last_kwargs = kwargs
_was_called = True
if _print_execution_info:
print(f"Executed test callable function with args: {args} and kwargs: {kwargs}")
return list(_last_args)
def test_execute_callable_function_action_with_args(test_context, *args, **kwargs):
global _last_args, _last_kwargs, _was_called
_last_args = None
_last_kwargs = None
_was_called = False
result = test_context.test_callable_function_action.execute(*args, **kwargs)
test_context.assertTrue(_was_called)
test_context.assertListEqual(result, list(args))
test_context.assertListEqual(list(_last_args), list(args))
test_context.assertDictEqual(_last_kwargs, kwargs)
class TestCallableClass:
def __call__(self, *args, **kwargs):
global _print_execution_info
self.last_args = args
self.last_kwargs = kwargs
self.was_called = True
if _print_execution_info:
print(f"Executed test callable object with args: {args} and kwargs: {kwargs}")
return list(self.last_args)
def test_execute_callable_object_action_with_args(test_context, *args, **kwargs):
test_context.test_callable_object.last_args = None
test_context.test_callable_object.last_kwargs = None
test_context.test_callable_object.was_called = False
result = test_context.test_callable_object_action.execute(*args, **kwargs)
test_context.assertTrue(test_context.test_callable_object.was_called)
test_context.assertListEqual(result, list(args))
test_context.assertListEqual(list(test_context.test_callable_object.last_args), list(args))
test_context.assertDictEqual(test_context.test_callable_object.last_kwargs, kwargs)
def test_execute_lambda_action_with_args(test_context, *args, **kwargs):
result = test_context.test_lambda_action.execute(*args, **kwargs)
test_context.assertTrue(result)
def test_execute_cpp_action_with_args(test_context, *args, **kwargs):
test_context.test_cpp_action.reset_execution_count()
test_context.assertEqual(test_context.test_cpp_action.execution_count, 0)
result = test_context.test_cpp_action.execute(*args, **kwargs)
test_context.assertTrue(result)
test_context.assertEqual(test_context.test_cpp_action.execution_count, 1)
test_context.assertTrue(test_context.test_cpp_action.was_executed_with_args(*args, **kwargs))
test_context.test_cpp_action.reset_execution_count()
test_context.assertEqual(test_context.test_cpp_action.execution_count, 0)
class TestActions(omni.kit.test.AsyncTestCase):
async def setUp(self):
global _action_tests
# Cache the action tests and action registry interfaces.
self.extension_id = "omni.kit.actions.core_tests"
self.action_tests = _action_tests
self.action_registry = omni.kit.actions.core.get_action_registry()
# Register a test action that invokes a Python function.
self.test_callable_function_action = self.action_registry.register_action(
self.extension_id,
"test_callable_function",
test_callable_function,
display_name="Test Callable Function Action",
description="An action which invokes a callable Python function.",
tag="TestTag",
)
# Register a test action that invokes a Python object.
self.test_callable_object = TestCallableClass()
self.test_callable_object_action = self.action_registry.register_action(
self.extension_id,
"test_callable_object",
self.test_callable_object,
display_name="Test Callable Object Action",
description="An action which invokes a callable Python object.",
)
# Create and register a test action that invokes a C++ lambda.
self.test_lambda_action = self.action_tests.create_test_lambda_action(
self.extension_id, "test_lambda_action", "Test Lambda Action", "A lambda action which was created in C++."
)
self.action_registry.register_action(self.test_lambda_action)
# Create a test action in C++.
self.test_cpp_action = self.action_tests.create_test_cpp_action(
self.extension_id, "test_cpp_action", "Test Cpp Action", "An action which was created in C++."
)
self.action_registry.register_action(self.test_cpp_action)
async def tearDown(self):
# Deregister all the test actions.
self.action_registry.deregister_action(self.test_cpp_action)
self.action_registry.deregister_action(self.test_lambda_action)
self.action_registry.deregister_action(self.extension_id, "test_callable_object")
self.action_registry.deregister_action(self.extension_id, "test_callable_function")
# Destroy all the test actions.
self.test_cpp_action = None
self.test_lambda_action = None
self.test_callable_object = None
self.test_callable_object_action = None
self.test_callable_function_action = None
# Clear the action tests and action registry interfaces.
self.action_registry = None
self.action_tests = None
self.extension_id = None
async def test_find_registered_action(self):
action = self.action_registry.get_action(self.extension_id, "test_callable_function")
self.assertIsNotNone(action)
action = self.action_registry.get_action(self.extension_id, "test_callable_object")
self.assertIsNotNone(action)
action = self.action_registry.get_action(self.extension_id, "test_lambda_action")
self.assertIsNotNone(action)
action = self.action_registry.get_action(self.extension_id, "test_cpp_action")
self.assertIsNotNone(action)
async def test_find_unregistered_action(self):
action = self.action_registry.get_action(self.extension_id, "some_unregistered_action")
self.assertIsNone(action)
async def test_access_action_fields(self):
action = self.action_registry.get_action(self.extension_id, "test_callable_function")
self.assertEqual(action.id, "test_callable_function")
self.assertEqual(action.extension_id, self.extension_id)
self.assertEqual(action.display_name, "Test Callable Function Action")
self.assertEqual(action.description, "An action which invokes a callable Python function.")
self.assertEqual(action.icon_url, "")
self.assertEqual(action.tag, "TestTag")
async def test_get_all_actions(self):
# If any of the asserts below fail, the 'actions' list object doesn't seem to get cleaned up properly,
# resulting in a crash instead of a failed test. To protect against this we'll cache all the things we
# need to assert are valid and clear the 'actions' list object before performing any of the asserts.
actions = self.action_registry.get_all_actions()
found_registered_action_0 = (
not (next((action for action in actions if action.id == "test_callable_function"), None)) is None
)
found_registered_action_1 = (
not (next((action for action in actions if action.id == "test_callable_object"), None)) is None
)
found_registered_action_2 = (
not (next((action for action in actions if action.id == "test_lambda_action"), None)) is None
)
found_registered_action_3 = (
not (next((action for action in actions if action.id == "test_cpp_action"), None)) is None
)
found_unregistered_action = (
not (next((action for action in actions if action.id == "some_unregistered_action"), None)) is None
)
actions_length = len(actions)
actions.clear()
self.assertTrue(found_registered_action_0)
self.assertTrue(found_registered_action_1)
self.assertTrue(found_registered_action_2)
self.assertTrue(found_registered_action_3)
self.assertFalse(found_unregistered_action)
# Ideally we would assert that the number of actions found is what we expect,
# but the kit app itself registers some actions and we don't want to have to
# keep updating this test to account for those, so we won't assert for this.
# self.assertEqual(actions_length, 4)
async def test_get_all_actions_registered_by_extension(self):
# If any of the asserts below fail, the 'actions' list object doesn't seem to get cleaned up properly,
# resulting in a crash instead of a failed test. To protect against this we'll cache all the things we
# need to assert are valid and clear the 'actions' list object before performing any of the asserts.
self.action_registry.register_action("some_other_extension_id", "test_action_registered_by_another_extension", test_callable_function)
actions = self.action_registry.get_all_actions_for_extension(self.extension_id)
found_registered_action_0 = (
not (next((action for action in actions if action.id == "test_callable_function"), None)) is None
)
found_registered_action_1 = (
not (next((action for action in actions if action.id == "test_callable_object"), None)) is None
)
found_registered_action_2 = (
not (next((action for action in actions if action.id == "test_lambda_action"), None)) is None
)
found_registered_action_3 = (
not (next((action for action in actions if action.id == "test_cpp_action"), None)) is None
)
found_unregistered_action = (
not (next((action for action in actions if action.id == "some_unregistered_action"), None)) is None
)
found_action_registered_by_another_extension = (
not (next((action for action in actions if action.id == "test_action_registered_by_another_extension"), None)) is None
)
actions.clear()
self.assertTrue(found_registered_action_0)
self.assertTrue(found_registered_action_1)
self.assertTrue(found_registered_action_2)
self.assertTrue(found_registered_action_3)
self.assertFalse(found_unregistered_action)
self.assertFalse(found_action_registered_by_another_extension)
actions = self.action_registry.get_all_actions_for_extension("some_other_extension_id")
found_registered_action_0 = (
not (next((action for action in actions if action.id == "test_callable_function"), None)) is None
)
found_registered_action_1 = (
not (next((action for action in actions if action.id == "test_callable_object"), None)) is None
)
found_registered_action_2 = (
not (next((action for action in actions if action.id == "test_lambda_action"), None)) is None
)
found_registered_action_3 = (
not (next((action for action in actions if action.id == "test_cpp_action"), None)) is None
)
found_unregistered_action = (
not (next((action for action in actions if action.id == "some_unregistered_action"), None)) is None
)
found_action_registered_by_another_extension = (
not (next((action for action in actions if action.id == "test_action_registered_by_another_extension"), None)) is None
)
actions.clear()
self.assertFalse(found_registered_action_0)
self.assertFalse(found_registered_action_1)
self.assertFalse(found_registered_action_2)
self.assertFalse(found_registered_action_3)
self.assertFalse(found_unregistered_action)
self.assertTrue(found_action_registered_by_another_extension)
self.action_registry.deregister_action("some_other_extension_id", "test_action_registered_by_another_extension")
async def test_create_actions_on_registeration(self):
self.action_registry.register_action(self.extension_id, "test_python_action_created_on_registration", test_callable_function)
action = self.action_registry.get_action(self.extension_id, "test_python_action_created_on_registration")
self.assertIsNotNone(action)
self.action_tests.create_test_action_on_registrartion(self.extension_id, "test_cpp_action_created_on_registration")
action = self.action_registry.get_action(self.extension_id, "test_cpp_action_created_on_registration")
self.assertIsNotNone(action)
self.action_registry.deregister_action(self.extension_id, "test_cpp_action_created_on_registration")
action = self.action_registry.get_action(self.extension_id, "test_cpp_action_created_on_registration")
self.assertIsNone(action)
self.action_registry.deregister_action(self.extension_id, "test_python_action_created_on_registration")
action = self.action_registry.get_action(self.extension_id, "test_python_action_created_on_registration")
self.assertIsNone(action)
async def test_get_parameters(self):
def test_function():
self.assertFalse(True) # Should never be called
test_action = omni.kit.actions.core.Action(self.extension_id, "test_action", test_function)
self.assertDictEqual(test_action.parameters, dict(inspect.signature(test_function).parameters))
def test_function(arg0):
self.assertFalse(True) # Should never be called
test_action = omni.kit.actions.core.Action(self.extension_id, "test_action", test_function)
self.assertDictEqual(test_action.parameters, dict(inspect.signature(test_function).parameters))
def test_function(arg0, arg1):
self.assertFalse(True) # Should never be called
test_action = omni.kit.actions.core.Action(self.extension_id, "test_action", test_function)
self.assertDictEqual(test_action.parameters, dict(inspect.signature(test_function).parameters))
def test_function(arg0, arg1, arg2):
self.assertFalse(True) # Should never be called
test_action = omni.kit.actions.core.Action(self.extension_id, "test_action", test_function)
self.assertDictEqual(test_action.parameters, dict(inspect.signature(test_function).parameters))
def test_function(*args, **kwargs):
self.assertFalse(True) # Should never be called
test_action = omni.kit.actions.core.Action(self.extension_id, "test_action", test_function)
self.assertDictEqual(test_action.parameters, dict(inspect.signature(test_function).parameters))
def test_function(arg0, *args, **kwargs):
self.assertFalse(True) # Should never be called
test_action = omni.kit.actions.core.Action(self.extension_id, "test_action", test_function)
self.assertDictEqual(test_action.parameters, dict(inspect.signature(test_function).parameters))
async def test_requires_parameters(self):
def test_function():
self.assertFalse(True) # Should never be called
test_action = omni.kit.actions.core.Action(self.extension_id, "test_action", test_function)
self.assertFalse(test_action.requires_parameters)
def test_function(arg0):
self.assertFalse(True) # Should never be called
test_action = omni.kit.actions.core.Action(self.extension_id, "test_action", test_function)
self.assertTrue(test_action.requires_parameters)
def test_function(arg0=False):
self.assertFalse(True) # Should never be called
test_action = omni.kit.actions.core.Action(self.extension_id, "test_action", test_function)
self.assertFalse(test_action.requires_parameters)
def test_function(arg0, arg1=False):
self.assertFalse(True) # Should never be called
test_action = omni.kit.actions.core.Action(self.extension_id, "test_action", test_function)
self.assertTrue(test_action.requires_parameters)
def test_function(arg0=True, arg1=False):
self.assertFalse(True) # Should never be called
test_action = omni.kit.actions.core.Action(self.extension_id, "test_action", test_function)
self.assertFalse(test_action.requires_parameters)
def test_function(arg0="Nine", arg1=-9, arg2=False):
self.assertFalse(True) # Should never be called
test_action = omni.kit.actions.core.Action(self.extension_id, "test_action", test_function)
self.assertFalse(test_action.requires_parameters)
def test_function(*args, **kwargs):
self.assertFalse(True) # Should never be called
test_action = omni.kit.actions.core.Action(self.extension_id, "test_action", test_function)
self.assertFalse(test_action.requires_parameters)
def test_function(arg0, *args, **kwargs):
self.assertFalse(True) # Should never be called
test_action = omni.kit.actions.core.Action(self.extension_id, "test_action", test_function)
self.assertTrue(test_action.requires_parameters)
def test_function(arg0="Nine", *args, **kwargs):
self.assertFalse(True) # Should never be called
test_action = omni.kit.actions.core.Action(self.extension_id, "test_action", test_function)
self.assertFalse(test_action.requires_parameters)
async def test_execute_callable_function_action(self):
global _last_args, _last_kwargs, _was_called
_last_args = None
_last_kwargs = None
_was_called = False
result = self.test_callable_function_action.execute()
self.assertTrue(_was_called)
self.assertFalse(result)
self.assertFalse(_last_args)
self.assertFalse(_last_kwargs)
async def test_execute_callable_object_action(self):
self.test_callable_object.last_args = None
self.test_callable_object.last_kwargs = None
self.test_callable_object.was_called = False
result = self.test_callable_object_action.execute()
self.assertTrue(self.test_callable_object.was_called)
self.assertFalse(result)
self.assertFalse(self.test_callable_object.last_args)
self.assertFalse(self.test_callable_object.last_kwargs)
async def test_execute_lambda_action(self):
result = self.test_lambda_action.execute()
self.assertTrue(result)
async def test_execute_cpp_action(self):
self.test_cpp_action.reset_execution_count()
self.assertEqual(self.test_cpp_action.execution_count, 0)
result = self.test_cpp_action.execute()
self.assertTrue(result)
self.assertEqual(self.test_cpp_action.execution_count, 1)
result = self.test_cpp_action.execute()
self.assertTrue(result)
self.assertEqual(self.test_cpp_action.execution_count, 2)
result = self.test_cpp_action.execute()
self.assertTrue(result)
self.assertEqual(self.test_cpp_action.execution_count, 3)
self.test_cpp_action.reset_execution_count()
self.assertEqual(self.test_cpp_action.execution_count, 0)
async def test_execute_action_using_id(self):
global _last_args, _last_kwargs, _was_called
_last_args = None
_last_kwargs = None
_was_called = False
result = omni.kit.actions.core.execute_action(self.extension_id, "test_callable_function")
self.assertTrue(_was_called)
self.assertFalse(result)
self.assertFalse(_last_args)
self.assertFalse(_last_kwargs)
self.test_callable_object.last_args = None
self.test_callable_object.last_kwargs = None
self.test_callable_object.was_called = False
result = omni.kit.actions.core.execute_action(self.extension_id, "test_callable_object", True, 9, "Nine")
self.assertTrue(self.test_callable_object.was_called)
self.assertListEqual(result, [True, 9, "Nine"])
self.assertListEqual(list(self.test_callable_object.last_args), [True, 9, "Nine"])
self.assertFalse(self.test_callable_object.last_kwargs)
async def test_find_and_execute_python_action_from_cpp(self):
self.test_callable_object.last_args = None
self.test_callable_object.last_kwargs = None
self.test_callable_object.was_called = False
result = self.action_tests.find_and_execute_test_action_from_cpp(self.extension_id, "test_callable_object")
self.assertTrue(self.test_callable_object.was_called)
self.assertFalse(result)
self.assertFalse(self.test_callable_object.last_args)
self.assertFalse(self.test_callable_object.last_kwargs)
async def test_find_and_execute_cpp_action_from_cpp(self):
self.test_cpp_action.reset_execution_count()
self.assertEqual(self.test_cpp_action.execution_count, 0)
result = self.action_tests.find_and_execute_test_action_from_cpp(self.extension_id, "test_cpp_action")
self.assertTrue(result)
self.assertEqual(self.test_cpp_action.execution_count, 1)
self.test_cpp_action.reset_execution_count()
self.assertEqual(self.test_cpp_action.execution_count, 0)
async def test_find_and_execute_cpp_action_from_python(self):
self.test_cpp_action.reset_execution_count()
self.assertEqual(self.test_cpp_action.execution_count, 0)
action = self.action_registry.get_action(self.extension_id, "test_cpp_action")
self.assertIsNotNone(action)
result = action.execute()
self.assertTrue(result)
self.assertEqual(self.test_cpp_action.execution_count, 1)
self.test_cpp_action.reset_execution_count()
self.assertEqual(self.test_cpp_action.execution_count, 0)
async def test_execute_action_with_return_value(self):
test_action = omni.kit.actions.core.Action(self.extension_id, "test_action", lambda x: x * x)
result = test_action.execute(9)
self.assertEqual(result, 81)
result = self.action_tests.execute_square_value_action_from_cpp(8)
self.assertEqual(result, 64)
async def test_invalidate_python_action(self):
test_action = omni.kit.actions.core.Action(self.extension_id, "test_action", lambda x: x * x)
result = test_action.execute(9)
self.assertEqual(result, 81)
test_action.invalidate()
result = test_action.execute(9)
self.assertIsNone(result)
async def test_invalidate_lambda_action(self):
test_action = self.action_tests.create_test_lambda_action(self.extension_id, "test_action", "", "")
result = test_action.execute()
self.assertTrue(result)
test_action.invalidate()
result = test_action.execute()
self.assertIsNone(result)
async def test_execute_actions_with_bool(self):
test_execute_callable_function_action_with_args(self, True)
test_execute_callable_object_action_with_args(self, True)
test_execute_lambda_action_with_args(self, True)
test_execute_cpp_action_with_args(self, True)
def test_function(arg):
self.assertTrue(arg)
test_action = omni.kit.actions.core.Action(self.extension_id, "test_action", test_function)
test_action.execute(True)
self.action_tests.execute_test_action_from_cpp_with_bool(test_action, True)
async def test_execute_actions_with_int(self):
test_execute_callable_function_action_with_args(self, 9)
test_execute_callable_object_action_with_args(self, 9)
test_execute_lambda_action_with_args(self, 9)
test_execute_cpp_action_with_args(self, 9)
def test_function(arg):
self.assertEqual(arg, 9)
test_action = omni.kit.actions.core.Action(self.extension_id, "test_action", test_function)
test_action.execute(9)
self.action_tests.execute_test_action_from_cpp_with_int(test_action, 9)
async def test_execute_actions_with_string(self):
test_execute_callable_function_action_with_args(self, "Nine")
test_execute_callable_object_action_with_args(self, "Nine")
test_execute_lambda_action_with_args(self, "Nine")
test_execute_cpp_action_with_args(self, "Nine")
def test_function(arg):
self.assertEqual(arg, "Nine")
test_action = omni.kit.actions.core.Action(self.extension_id, "test_action", test_function)
test_action.execute("Nine")
self.action_tests.execute_test_action_from_cpp_with_string(test_action, "Nine")
async def test_execute_actions_with_multiple_args(self):
test_execute_callable_function_action_with_args(self, "Nine", 9, True)
test_execute_callable_object_action_with_args(self, "Nine", 9, True)
test_execute_lambda_action_with_args(self, "Nine", 9, True)
test_execute_cpp_action_with_args(self, "Nine", 9, True)
def test_function(arg0, arg1, arg2):
self.assertEqual(arg0, "Nine")
self.assertEqual(arg1, 9)
self.assertTrue(arg2)
test_action = omni.kit.actions.core.Action(self.extension_id, "test_action", test_function)
test_action.execute("Nine", 9, True)
self.action_tests.execute_test_action_from_cpp_with_multiple_args(test_action, "Nine", 9, True)
async def test_execute_actions_with_nested_args(self):
test_nested_args = (False, 99, "Ninety-Nine")
test_execute_callable_function_action_with_args(self, "Nine", test_nested_args, 9, True)
test_execute_callable_object_action_with_args(self, "Nine", test_nested_args, 9, True)
test_execute_lambda_action_with_args(self, "Nine", test_nested_args, 9, True)
test_execute_cpp_action_with_args(self, "Nine", test_nested_args, 9, True)
def test_function(arg0, arg1, arg2, arg3):
self.assertEqual(arg0, "Nine")
self.assertListEqual(list(arg1), list(test_nested_args))
self.assertEqual(arg2, 9)
self.assertTrue(arg3)
test_action = omni.kit.actions.core.Action(self.extension_id, "test_action", test_function)
test_action.execute("Nine", test_nested_args, 9, True)
async def test_execute_actions_with_keyword_args(self):
test_execute_callable_function_action_with_args(self, kwarg0="Nine", kwarg1=9, kwarg2=True)
test_execute_callable_object_action_with_args(self, kwarg0="Nine", kwarg1=9, kwarg2=True)
test_execute_lambda_action_with_args(self, kwarg0="Nine", kwarg1=9, kwarg2=True)
test_execute_cpp_action_with_args(self, kwarg0="Nine", kwarg1=9, kwarg2=True)
def test_function(kwarg0="", kwarg1=0, kwarg2=False):
self.assertEqual(kwarg0, "Nine")
self.assertEqual(kwarg1, 9)
self.assertTrue(kwarg2)
test_action = omni.kit.actions.core.Action(self.extension_id, "test_action", test_function)
test_action.execute(kwarg0="Nine", kwarg1=9, kwarg2=True)
test_action.execute(kwarg2=True, kwarg1=9, kwarg0="Nine")
self.action_tests.execute_test_action_from_cpp_with_variable_args(
test_action, kwarg0="Nine", kwarg1=9, kwarg2=True
)
async def test_execute_actions_with_mixed_args(self):
test_execute_callable_function_action_with_args(
self, "Nine", 9, True, kwarg0=False, kwarg1=99, kwarg2="Ninety-Nine"
)
test_execute_callable_object_action_with_args(
self, "Nine", 9, True, kwarg0=False, kwarg1=99, kwarg2="Ninety-Nine"
)
test_execute_lambda_action_with_args(self, "Nine", 9, True, kwarg0=False, kwarg1=99, kwarg2="Ninety-Nine")
test_execute_cpp_action_with_args(self, "Nine", 9, True, kwarg0=False, kwarg1=99, kwarg2="Ninety-Nine")
def test_function(arg0, arg1, arg2, kwarg0=True, kwarg1=0, kwarg2=""):
self.assertEqual(arg0, "Nine")
self.assertEqual(arg1, 9)
self.assertTrue(arg2)
self.assertFalse(kwarg0)
self.assertEqual(kwarg1, 99)
self.assertEqual(kwarg2, "Ninety-Nine")
test_action = omni.kit.actions.core.Action(self.extension_id, "test_action", test_function)
test_action.execute("Nine", 9, True, kwarg0=False, kwarg1=99, kwarg2="Ninety-Nine")
test_action.execute("Nine", 9, True, kwarg2="Ninety-Nine", kwarg1=99, kwarg0=False)
self.action_tests.execute_test_action_from_cpp_with_variable_args(
test_action, "Nine", 9, True, kwarg0=False, kwarg1=99, kwarg2="Ninety-Nine"
)
| 29,503 | Python | 46.055821 | 142 | 0.67644 |
omniverse-code/kit/exts/omni.kit.actions.core/omni/kit/actions/core/tests/__init__.py | # Copyright (c) 2023, NVIDIA CORPORATION. All rights reserved.
#
# NVIDIA CORPORATION and its licensors retain all intellectual property
# and proprietary rights in and to this software, related documentation
# and any modifications thereto. Any use, reproduction, disclosure or
# distribution of this software and related documentation without an express
# license agreement from NVIDIA CORPORATION is strictly prohibited.
#
from .test_actions import *
| 456 | Python | 44.699996 | 76 | 0.804825 |
omniverse-code/kit/exts/omni.kit.actions.core/docs/index.rst | omni.kit.actions.core
###################################
.. toctree::
:maxdepth: 1
CHANGELOG
User Guide
===================================
.. toctree::
:maxdepth: 1
USAGE_PYTHON
USAGE_CPP
API Reference
===================================
.. automodule:: omni.kit.actions.core
:platform: Windows-x86_64, Linux-x86_64
:members:
:undoc-members:
:imported-members:
:show-inheritance:
| 424 | reStructuredText | 14.74074 | 43 | 0.485849 |
omniverse-code/kit/exts/omni.kit.menu.utils/omni/kit/menu/utils/__init__.py | from .scripts import *
| 23 | Python | 10.999995 | 22 | 0.73913 |
omniverse-code/kit/exts/omni.kit.menu.utils/omni/kit/menu/utils/scripts/debug_window.py | import asyncio
import functools
import carb
import carb.settings
import omni.ext
import json
from omni import ui
from omni.ui import color as cl
class MenuUtilsDebugExtension(omni.ext.IExt):
def on_startup(self):
manager = omni.kit.app.get_app().get_extension_manager()
self._extension_name = omni.ext.get_extension_name(manager.get_extension_id_by_module(__name__))
self._hooks = []
self._debug_window = None
self._hooks.append(
manager.subscribe_to_extension_enable(
on_enable_fn=lambda _: self._register_actions(),
ext_name="omni.kit.actions.core",
hook_name="omni.kit.menu.utils debug omni.kit.actions.core listener",
)
)
self._hooks.append(
manager.subscribe_to_extension_enable(
on_enable_fn=lambda _: self._register_hotkeys(),
ext_name="omni.kit.hotkeys.core",
hook_name="omni.kit.menu.utils debug omni.kit.hotkeys.core listener",
)
)
def on_shutdown(self):
omni.kit.actions.core.get_action_registry().deregister_action(self._extension_name, "show_menu_debug_debug_window")
if self._debug_window:
del self._debug_window
self._debug_window = None
try:
from omni.kit.hotkeys.core import get_hotkey_registry
hotkey_registry = get_hotkey_registry()
hotkey_registry.deregister_hotkey(self._registered_hotkey)
except (ModuleNotFoundError, AttributeError):
pass
def _register_actions(self):
import omni.kit.actions.core
omni.kit.actions.core.get_action_registry().register_action(
self._extension_name,
"show_menu_debug_debug_window", lambda: self.show_menu_debug_debug_window(),
display_name="Show Menu Debug Window",
description="Show Menu Debug Window",
tag = "Menu Debug Actions"
)
def _register_hotkeys(self):
import omni.kit.hotkeys.core
from omni.kit.hotkeys.core import KeyCombination, get_hotkey_registry
hotkey_combo = KeyCombination(carb.input.KeyboardInput.M, modifiers=carb.input.KEYBOARD_MODIFIER_FLAG_CONTROL + carb.input.KEYBOARD_MODIFIER_FLAG_ALT + carb.input.KEYBOARD_MODIFIER_FLAG_SHIFT)
hotkey_registry = get_hotkey_registry()
self._registered_hotkey = hotkey_registry.register_hotkey(self._extension_name, hotkey_combo, self._extension_name, "show_menu_debug_debug_window")
def show_menu_debug_debug_window(self):
CollapsableFrame_style = {
"CollapsableFrame": {
"background_color": 0xFF343432,
"secondary_color": 0xFF343432,
"color": 0xFFAAAAAA,
"border_radius": 4.0,
"border_color": 0x0,
"border_width": 0,
"font_size": 14,
"padding": 0,
},
"HStack::header": {"margin": 5},
"CollapsableFrame:hovered": {"secondary_color": 0xFF3A3A3A},
"CollapsableFrame:pressed": {"secondary_color": 0xFF343432},
}
def show_dict_data(legend, value):
if value:
ui.Button(f"Save {legend}", clicked_fn=lambda b=None: save_dict(legend, value), height=24)
else:
ui.Button(f"Save {legend}", clicked_fn=lambda b=None: save_dict(legend, value), height=24, enabled=False)
async def refresh_debug_window(rebuild_menus):
await omni.kit.app.get_app().next_update_async()
self._debug_window.frame.clear()
await omni.kit.app.get_app().next_update_async()
await omni.kit.app.get_app().next_update_async()
del self._debug_window
self._debug_window = None
if rebuild_menus:
omni.kit.menu.utils.rebuild_menus()
await omni.kit.app.get_app().next_update_async()
await omni.kit.app.get_app().next_update_async()
self.show_menu_debug_debug_window()
def save_dict(legend, value):
from omni.kit.window.filepicker import FilePickerDialog
def on_click_save(dialog: FilePickerDialog, filename: str, dirname: str, value: dict):
dialog.hide()
dirname = dirname.strip()
if dirname and not dirname.endswith("/"):
dirname += "/"
fullpath = f"{dirname}{filename}"
def serialize(obj):
if hasattr(obj, "json_enc"):
return obj.json_enc()
elif hasattr(obj, "__dict__"):
return obj.__dict__
return {"unknown": f"{obj}"}
with open(fullpath, 'w') as file:
file.write(json.dumps(value, default=lambda obj: serialize(obj)))
dialog = FilePickerDialog(
f"Save {legend} as json",
apply_button_label="Save",
click_apply_handler=lambda filename, dirname: on_click_save(dialog, filename, dirname, value),
)
dialog.show()
self._debug_window = ui.Window("omni.kit.menu.utils debug", width=600)
with self._debug_window.frame:
with ui.VStack():
menu_instance = omni.kit.menu.utils.get_instance()
menu_creator = None
if menu_instance:
ui.Label(f"omni.kit.menu.utils - Alive", height=20)
menu_creator = menu_instance._menu_creator
else:
ui.Label(f"omni.kit.menu.utils - Shut Down", height=20)
legacy_mode = omni.kit.ui.using_legacy_mode()
ui.Label(f"omni.kit.ui.get_editor_menu() -> omni.kit.menu.utils: {not legacy_mode}", height=20)
if menu_creator:
ui.Label(f"omni.kit.menu.utils - Creator: {menu_creator.__class__.__name__}", height=20)
else:
ui.Label(f"omni.kit.menu.utils - Creator: Not Found", height=20)
ui.Spacer(height=8)
open_stat_frame = False
stat_frame = ui.CollapsableFrame(title="Debug Stats", collapsed=True, style=CollapsableFrame_style, height=12)
with stat_frame:
with ui.VStack():
debug_stats = omni.kit.menu.utils.get_debug_stats()
for stat in debug_stats.keys():
name = stat.replace("_", " ").title()
if stat == "extension_loaded_count":
if debug_stats[stat] != 1:
open_stat_frame = True
ui.Label(f" {name}: {debug_stats[stat]}", height=18, style={"color": cl.red if open_stat_frame else cl.white})
else:
ui.Label(f" {name}: {debug_stats[stat]}", height=18, style={"color": cl.white})
open_menu_frame = False
if menu_creator:
ui.Spacer(height=8)
if menu_creator.__class__.__name__ == "AppMenu":
menu_frame = ui.CollapsableFrame(title="ui.Menu", collapsed=True, style=CollapsableFrame_style, height=12)
with menu_frame:
with ui.VStack():
menu_chain = menu_creator._main_menus
if not menu_chain or not all(k in menu_chain for k in ["File", "Edit", "Window", "Help"]):
ui.Label(f" ERROR MISSING MENUS", height=20, style={"color": cl.red})
open_menu_frame = True
for key in menu_chain.keys():
if menu_chain[key].visible == False:
open_menu_frame = True
ui.Label(f" {key} visible:{menu_chain[key].visible}", height=20, style={"color": cl.white if menu_chain[key].visible else cl.red})
ui.Spacer(height=8)
menu_layout = omni.kit.menu.utils.get_menu_layout()
merged_menus = omni.kit.menu.utils.get_merged_menus()
show_dict_data("Menu Layout", menu_layout)
show_dict_data("Menus", merged_menus)
ui.Button("Refresh Window", clicked_fn=lambda: asyncio.ensure_future(refresh_debug_window(False)), height=24)
ui.Button("Rebuild Menus", clicked_fn=lambda: asyncio.ensure_future(refresh_debug_window(True)), height=24)
ui.Spacer(height=30)
if open_stat_frame:
stat_frame.collapsed = False
if open_menu_frame:
menu_frame.collapsed = False
| 9,026 | Python | 42.820388 | 200 | 0.536339 |
omniverse-code/kit/exts/omni.kit.menu.utils/omni/kit/menu/utils/scripts/builder_utils.py | import carb
import omni.kit.ui
from typing import Callable, Tuple, Union, List
from omni import ui
def get_menu_name(menu_entry):
if menu_entry.name_fn:
try:
return f"{menu_entry.name_fn()}"
except Exception as exc:
carb.log_warn(f"get_menu_name error:{str(exc)}")
return f"{menu_entry.name}"
def get_action_path(action_prefix: str, menu_entry_name: str):
if not menu_entry_name:
return action_prefix.replace(" ", "_").replace("/", "_").replace(".", "")
return f"{action_prefix}/{menu_entry_name}".replace(" ", "_").replace("/", "_").replace(".", "")
def has_delegate_func(delegate, func_name):
return bool(delegate and hasattr(delegate, func_name) and callable(getattr(delegate, func_name)))
def create_prebuild_entry(prebuilt_menus: dict, prefix_name: str, action_prefix: str):
if not action_prefix in prebuilt_menus:
# prefix_name cannot be "" as creating submenus with "" causes problems
prebuilt_menus[action_prefix] = {}
prebuilt_menus[action_prefix]["items"] = []
prebuilt_menus[action_prefix]["prefix_name"] = prefix_name if prefix_name else "Empty"
prebuilt_menus[action_prefix]["remapped"] = []
prebuilt_menus[action_prefix]["action_prefix"] = action_prefix
class PrebuiltItemOrder:
UNORDERED = 0x7FFFFFFF
LAYOUT_ORDERED = 0x00000000
LAYOUT_SUBMENU_SORTED = 0x00001000
LAYOUT_ITEM_SORTED = 0x00002000
class MenuAlignment:
DEFAULT = 0
RIGHT = 1
class LayoutSourceSearch:
EVERYWHERE = 0
LOCAL_ONLY = 1
class MenuItemDescription:
"""
name is name shown on menu. (if name is "" then a menu spacer is added. Can be combined with show_fn)
glyph is icon shown on menu
header is True/False to show seperator above item
hotkey hotkey for menu item
enabled enabled True/False is item enabled
ticked menu item is ticked when True
sub_menu is sub menu to this menu
name_fn is function to get menu name
show_fn funcion or list of functions used to decide if menu item is shown. All functions must return True to show
enable_fn funcion or list of functions used to decide if menu item is enabled. All functions must return True to be enabled
onclick_action action called when user clicks menu item
unclick_action action called when user releases click on menu item
onclick_fn function called when user clicks menu item (deprecated)
unclick_fn function called when user releases click on menu item (deprecated)
onclick_right_fn function called when user right clicks menu item (deprecated)
ticked_fn funcion or list of functions used to decide if menu item is ticked
appear_after is name of menu item to insert after. Used for appending menus, can be a list or string
user is user dictonary that is passed to menu
"""
MAX_DEPTH = 16
def __init__(
self,
name: str = "",
glyph: str = "",
header: str = None,
appear_after: Union[list, str] = "",
enabled: bool = True,
ticked: bool = False,
ticked_value: Union[bool, None] = None,
sub_menu=None,
hotkey: Tuple[int, int] = None,
name_fn: Callable = None,
show_fn: Callable = None,
enable_fn: Callable = None,
ticked_fn: Callable = None,
onclick_action: Tuple = None,
unclick_action: Tuple = None,
onclick_fn: Callable = None, # deprecated
unclick_fn: Callable = None, # deprecated
onclick_right_fn: Callable = None, # deprecated
original_svg_color: bool = False, # deprecated - only used for editor_menu
original_menu_item = None, # private for hotkey processing
user = {}
):
self._on_delete_funcs = []
self._on_hotkey_update_funcs = []
# don't allow unnamed submenus as causes Menu problems
if name == "" and sub_menu:
self.name = "SubMenu"
else:
self.name = name
self.glyph = glyph
self.header = header
self.appear_after = appear_after
self.ticked = True if ticked or ticked_value is not None or ticked_fn is not None else False
self.ticked_value = ticked_value
self.enabled = enabled
self.sub_menu = sub_menu
self.name_fn = name_fn
self.show_fn = show_fn
self.enable_fn = enable_fn
self.ticked_fn = ticked_fn
self.onclick_action = onclick_action
self.unclick_action = unclick_action
self.set_hotkey(hotkey)
self.original_menu_item = original_menu_item
self.user = user.copy()
# Deprecated
self.original_svg_color = original_svg_color
self.onclick_fn = onclick_fn
self.unclick_fn = unclick_fn
self.onclick_right_fn = onclick_right_fn
log_deprecated = bool((carb.settings.get_settings().get_as_string("/exts/omni.kit.menu.utils/logDeprecated") or "true") == "true")
if log_deprecated and not "shown_deprecated_warning" in self.user:
def deprecated_msg(fn_name, func):
carb.log_warn(f"Menu item \"{name}\" from {func.__module__} uses {fn_name}")
self.user["shown_deprecated_warning"] = True
if onclick_fn or unclick_fn or onclick_right_fn or original_svg_color:
carb.log_warn(f"********************* MenuItemDescription {name} *********************")
if onclick_fn:
deprecated_msg("onclick_fn", onclick_fn)
if unclick_fn:
deprecated_msg("unclick_fn", unclick_fn)
if onclick_right_fn:
deprecated_msg("onclick_right_fn", onclick_right_fn)
if original_svg_color:
deprecated_msg("original_svg_color", original_svg_color)
def add_on_delete_func(self, on_delete_fn: callable):
self._on_delete_funcs.append(on_delete_fn)
def remove_on_delete_func(self, on_delete_fn: callable):
try:
self._on_delete_funcs.remove(on_delete_fn)
except Exception as exc:
carb.log_warn(f"omni.kit.menu.utils remove_on_delete_func failed {str(exc)}")
def add_on_hotkey_update_func(self, hotkey_update_fn: callable):
self._on_hotkey_update_funcs.append(hotkey_update_fn)
def remove_on_hotkey_update_func(self, hotkey_update_fn: callable):
try:
self._on_hotkey_update_funcs.remove(hotkey_update_fn)
except Exception as exc:
carb.log_warn(f"omni.kit.menu.utils remove_on_hotkey_update_func failed {str(exc)}")
def set_hotkey(self, hotkey):
self.hotkey = None
self.hotkey_text = ""
if hotkey:
self.hotkey = hotkey
self.hotkey_text = self.get_action_mapping_desc().replace("Keyboard::", "")
for on_hotkey_update_fn in self._on_hotkey_update_funcs:
on_hotkey_update_fn(self)
def get_action_mapping_desc(self):
if isinstance(self.hotkey, carb.input.GamepadInput):
return carb.input.get_string_from_action_mapping_desc(self.hotkey)
return carb.input.get_string_from_action_mapping_desc(self.hotkey[1], self.hotkey[0])
def has_action(self):
return bool(self.onclick_fn or self.onclick_action or self.unclick_fn or self.unclick_action)
def __del__(self):
self.original_menu_item = None
for on_delete_fn in self._on_delete_funcs:
on_delete_fn(self)
del self._on_delete_funcs
del self._on_hotkey_update_funcs
def __repr__(self):
return f"<{self.__class__} name:{self.name} user:{self.user}>"
def __copy__(self):
# as hotkeys are removed on copyed item delete, hotkeys are accessed via original_menu_item as these are not deleted until the menu is removed
def get_original(item):
original = item.original_menu_item
if original:
while(original.original_menu_item and original.original_menu_item.original_menu_item):
original = original.original_menu_item
return original
return item
sub_menu = self.sub_menu
if sub_menu:
def copy_sub_menu(sub_menu, new_sub_menu, max_depth=MenuItemDescription.MAX_DEPTH):
if max_depth == 0:
carb.log_warn(f"Recursive sub_menu {sub_menu} aborting copy")
return
for sub_item in sub_menu:
item = MenuItemDescription(name=sub_item.name,
glyph=sub_item.glyph,
header=sub_item.header,
appear_after=sub_item.appear_after,
enabled=sub_item.enabled,
ticked=sub_item.ticked,
ticked_value=sub_item.ticked_value,
sub_menu=None,
hotkey=None,
name_fn=sub_item.name_fn,
show_fn=sub_item.show_fn,
enable_fn=sub_item.enable_fn,
ticked_fn=sub_item.ticked_fn,
onclick_action=sub_item.onclick_action,
unclick_action=sub_item.unclick_action,
onclick_fn=sub_item.onclick_fn,
unclick_fn=sub_item.unclick_fn,
onclick_right_fn=sub_item.onclick_right_fn,
original_svg_color=sub_item.original_svg_color,
original_menu_item=get_original(sub_item),
user=sub_item.user)
new_sub_menu.append(item)
if sub_item.sub_menu:
item.sub_menu = []
copy_sub_menu(sub_item.sub_menu, item.sub_menu, max_depth-1)
new_sub_menu = []
copy_sub_menu(sub_menu, new_sub_menu)
sub_menu = new_sub_menu
return MenuItemDescription(name=self.name,
glyph=self.glyph,
header=self.header,
appear_after=self.appear_after,
enabled=self.enabled,
ticked=self.ticked,
ticked_value=self.ticked_value,
sub_menu=sub_menu,
hotkey=None,
name_fn=self.name_fn,
show_fn=self.show_fn,
enable_fn=self.enable_fn,
ticked_fn=self.ticked_fn,
onclick_action=self.onclick_action,
unclick_action=self.unclick_action,
onclick_fn=self.onclick_fn,
unclick_fn=self.unclick_fn,
onclick_right_fn=self.onclick_right_fn,
original_svg_color=self.original_svg_color,
original_menu_item=get_original(self),
user=self.user)
def json_enc(self):
values = { "name": self.name,
"glyph": self.glyph,
"header": self.header,
"enabled": self.enabled,
"sub_menu": self.sub_menu,
"hotkey": self.hotkey,
"name_fn": self.name_fn,
"show_fn": self.show_fn,
"enable_fn": self.enable_fn,
"onclick_action": self.onclick_action,
"unclick_action": self.unclick_action,
"onclick_fn": self.onclick_fn,
"unclick_fn": self.unclick_fn,
"onclick_right_fn": self.onclick_right_fn,
"original_svg_color": self.original_svg_color,
"user": self.user}
if self.ticked:
values["ticked"] = self.ticked
values["ticked_value"] = self.ticked_value
values["ticked_fn"] = self.ticked_fn
if self.appear_after:
values["appear_after"] = self.appear_after
return {k: v for k, v in values.items() if v is not None}
# Make a dict like interface for MenuItemDescription so it can be used as an entry for omni.kit.context_menu
# overrides [] and get for read-only access
def __getitem__(self, key, default_value=None):
return getattr(self, key, default_value)
def __contains__(self, key):
return self.__getitem__(key) is not None
def get(self, key, default_value=None):
return self.__getitem__(key, default_value)
| 13,333 | Python | 43.744966 | 150 | 0.545489 |
omniverse-code/kit/exts/omni.kit.menu.utils/omni/kit/menu/utils/scripts/app_menu.py | import asyncio
import functools
import weakref
import carb
import omni.kit.ui
import omni.kit.app
from functools import partial
from enum import IntFlag, Enum
from omni import ui
from typing import Callable, Tuple, Any
from pathlib import Path
from .builder_utils import get_menu_name, get_action_path, create_prebuild_entry, has_delegate_func
from .builder_utils import MenuItemDescription, PrebuiltItemOrder, MenuAlignment
class MenuItemOrder:
FIRST = "@first"
LAST = "@last"
class MenuState(IntFlag):
Invalid = 0
Created = 1
class MenuActionControl(Enum):
NONE = "@MenuActionControl.NONE"
NODELAY = "@MenuActionControl.NODELAY"
class uiMenu(ui.Menu):
def __init__(self, *args, **kwargs):
self.glyph = None
self.submenu = False
self.menu_hotkey_text = None
self.menu_checkable = False
if "glyph" in kwargs:
self.glyph = kwargs["glyph"]
del kwargs["glyph"]
if "menu_checkable" in kwargs:
self.menu_checkable = kwargs["menu_checkable"]
del kwargs["menu_checkable"]
if "menu_hotkey_text" in kwargs:
self.menu_hotkey_text = kwargs["menu_hotkey_text"]
del kwargs["menu_hotkey_text"]
if "submenu" in kwargs:
self.submenu = kwargs["submenu"]
del kwargs["submenu"]
super().__init__(*args, **kwargs, spacing=2, menu_compatibility=False)
class uiMenuItem(ui.MenuItem):
def __init__(self, *args, **kwargs):
self.glyph = None
self.submenu = False
self.menu_hotkey_text = None
self.menu_checkable = False
if "glyph" in kwargs:
self.glyph = kwargs["glyph"]
del kwargs["glyph"]
if "menu_checkable" in kwargs:
self.menu_checkable = kwargs["menu_checkable"]
del kwargs["menu_checkable"]
if "menu_hotkey_text" in kwargs:
self.menu_hotkey_text = kwargs["menu_hotkey_text"]
del kwargs["menu_hotkey_text"]
super().__init__(*args, **kwargs, menu_compatibility=False)
class IconMenuDelegate(ui.MenuDelegate):
EXTENSION_FOLDER_PATH = Path()
ICON_PATH = EXTENSION_FOLDER_PATH.joinpath("data/icons")
ICON_SIZE = 14
TICK_SIZE = 14
TICK_SPACING = [3, 6]
MARGIN_SIZE = [4, 4]
ROOT_SPACING = 1
SUBMENU_PRE_SPACING = 5
SUBMENU_SPACING = 4
SUBMENU_ICON_SIZE = 10
ITEM_SPACING = 4
ICON_SPACING = 4
HOTKEY_SPACING = [8, 108]
COLOR_LABEL_ENABLED = 0xFFCCCCCC
COLOR_LABEL_DISABLED = 0xFF6F6F6F
COLOR_TICK_ENABLED = 0xFFCCCCCC
COLOR_TICK_DISABLED = 0xFF4F4F4F
COLOR_SEPARATOR = 0xFF6F6F6F
# doc compiler breaks if `omni.kit.app.get_app()` or `carb.settings.get_settings()` is called
try:
EXTENSION_FOLDER_PATH = Path(omni.kit.app.get_app().get_extension_manager().get_extension_path_by_module(__name__))
ICON_PATH = EXTENSION_FOLDER_PATH.joinpath("data/icons")
ICON_SIZE = carb.settings.get_settings().get("exts/omni.kit.menu.utils/icon_size")
TICK_SIZE = carb.settings.get_settings().get("exts/omni.kit.menu.utils/tick_size")
TICK_SPACING = carb.settings.get_settings().get("exts/omni.kit.menu.utils/tick_spacing")
MARGIN_SIZE = carb.settings.get_settings().get("exts/omni.kit.menu.utils/margin_size")
ROOT_SPACING = carb.settings.get_settings().get("exts/omni.kit.menu.utils/root_spacing")
SUBMENU_PRE_SPACING = carb.settings.get_settings().get("exts/omni.kit.menu.utils/submenu_pre_spacing")
SUBMENU_SPACING = carb.settings.get_settings().get("exts/omni.kit.menu.utils/submenu_spacing")
SUBMENU_ICON_SIZE = carb.settings.get_settings().get("exts/omni.kit.menu.utils/submenu_icon_size")
ITEM_SPACING = carb.settings.get_settings().get("exts/omni.kit.menu.utils/item_spacing")
ICON_SPACING = carb.settings.get_settings().get("exts/omni.kit.menu.utils/icon_spacing")
HOTKEY_SPACING = carb.settings.get_settings().get("exts/omni.kit.menu.utils/hotkey_spacing")
COLOR_LABEL_ENABLED = carb.settings.get_settings().get("exts/omni.kit.menu.utils/color_label_enabled")
COLOR_LABEL_DISABLED = carb.settings.get_settings().get("exts/omni.kit.menu.utils/color_label_disabled")
COLOR_TICK_ENABLED = carb.settings.get_settings().get("exts/omni.kit.menu.utils/color_tick_enabled")
COLOR_TICK_DISABLED = carb.settings.get_settings().get("exts/omni.kit.menu.utils/color_tick_disabled")
COLOR_SEPARATOR = carb.settings.get_settings().get("exts/omni.kit.menu.utils/color_separator")
except Exception as exc:
carb.log_warn(f"IconMenuDelegate: failed to get EXTENSION_FOLDER_PATH and defaults {exc}")
MENU_STYLE = {"Label::Enabled": {"margin_width": MARGIN_SIZE[0], "margin_height": MARGIN_SIZE[1], "color": COLOR_LABEL_ENABLED},
"Label::Disabled": {"margin_width": MARGIN_SIZE[0], "margin_height": MARGIN_SIZE[1], "color": COLOR_LABEL_DISABLED},
"Image::Icon": {"margin_width": 0, "margin_height": 0, "color": COLOR_LABEL_ENABLED},
"Image::SubMenu": {"image_url": f"{ICON_PATH}/subdir.svg", "margin_width": 0, "margin_height": 0, "color": COLOR_LABEL_ENABLED},
"Image::TickEnabled": {"image_url": f"{ICON_PATH}/checked.svg", "margin_width": 0, "margin_height": 0, "color": COLOR_TICK_ENABLED},
"Image::TickDisabled": {"image_url": f"{ICON_PATH}/checked.svg", "margin_width": 0, "margin_height": 0, "color": COLOR_TICK_DISABLED},
"Menu.Separator": {
"color": COLOR_SEPARATOR
},
}
def build_item(self, item: ui.Menu):
if isinstance(item, ui.Separator):
with ui.HStack(height=0, style=IconMenuDelegate.MENU_STYLE):
return super().build_item(item)
with ui.HStack(height=0, style=IconMenuDelegate.MENU_STYLE):
if not (isinstance(item, uiMenu) and not item.submenu):
ui.Spacer(width=IconMenuDelegate.ITEM_SPACING)
else:
ui.Spacer(width=IconMenuDelegate.ROOT_SPACING)
# build tick
if item.menu_checkable:
ui.Spacer(width=IconMenuDelegate.TICK_SPACING[0])
if item.checkable:
ui.Image("", width=IconMenuDelegate.TICK_SIZE, name="TickEnabled" if item.checked else "TickDisabled")
else:
ui.Spacer(width=IconMenuDelegate.TICK_SIZE)
ui.Spacer(width=IconMenuDelegate.TICK_SPACING[1])
# build glyph
if item.glyph:
glyph_path = item.glyph if "/" in item.glyph.replace("\\", "/") else carb.tokens.get_tokens_interface().resolve("${glyphs}/"+ item.glyph)
ui.Spacer(width=IconMenuDelegate.ICON_SPACING)
ui.Image(glyph_path, width=IconMenuDelegate.ICON_SIZE, name="Icon")
ui.Spacer(width=IconMenuDelegate.ICON_SPACING)
# build label
if isinstance(item, uiMenu):
ui.Label(f"{item.text}", height=IconMenuDelegate.ICON_SIZE, name="Enabled" if item.enabled else "Disabled")
ui.Spacer(width=IconMenuDelegate.ROOT_SPACING)
else:
ui.Label(f"{item.text} ", height=IconMenuDelegate.ICON_SIZE, name="Enabled" if item.enabled else "Disabled")
# build hotkey text
if item.hotkey_text:
ui.Spacer(width=IconMenuDelegate.HOTKEY_SPACING[0])
ui.Label(item.hotkey_text.title(), height=IconMenuDelegate.ICON_SIZE, name="Disabled", width=100)
elif item.menu_hotkey_text:
ui.Spacer(width=IconMenuDelegate.HOTKEY_SPACING[1])
# build subdir marker
if item.submenu:
ui.Spacer(width=IconMenuDelegate.SUBMENU_PRE_SPACING)
ui.Image("", width=IconMenuDelegate.SUBMENU_ICON_SIZE, name="SubMenu")
ui.Spacer(width=IconMenuDelegate.SUBMENU_SPACING)
class AppMenu():
def __init__(self, get_instance: callable):
from omni.kit.mainwindow import get_main_window
self._get_instance = get_instance
self._menu_hooks = []
self._active_menus = {}
self._main_menus = {}
self.set_right_padding(0)
self._dirty_menus = set()
self._stats = omni.kit.menu.utils.get_debug_stats()
if not "triggered_refresh" in self._stats:
self._stats["triggered_refresh"] = 0
# setup window
self._menu_bar = get_main_window().get_main_menu_bar()
self._menu_bar.visible = True
def destroy(self):
for action_path in self._active_menus:
self._active_menus[action_path] = None
del self._active_menus
self._active_menus = {}
self._main_menus = {}
self._menu_bar.clear()
self._menu_bar = None
def add_hook(self, callback: Callable):
self._menu_hooks.append(callback)
def remove_hook(self, callback: Callable):
try:
self._menu_hooks.remove(callback)
except Exception as exc:
carb.log_warn(f"omni.kit.menu.utils remove_hook failed {exc}")
def merge_menus(self, menu_keys: list, menu_defs: list, menu_order: list, delegates: dict={}):
merged_menu = {}
def order_sort(name):
if name in menu_order:
return menu_order[name]
return 0
def get_item_menu_index(menu: list, name: str):
for index, item in enumerate(menu):
if item.name == name:
return index
return -1
def process_part(name, part):
used = False
if isinstance(part.appear_after, list):
for after in part.appear_after:
if after == MenuItemOrder.FIRST:
merged_menu[name].insert(0, part)
used = True
break
elif after == MenuItemOrder.LAST:
merged_menu[name].append(part)
used = True
break
index = get_item_menu_index(merged_menu[name], after)
if index != -1:
merged_menu[name].insert(index + 1, part)
used = True
break
else:
index = get_item_menu_index(merged_menu[name], part.appear_after)
if index != -1:
merged_menu[name].insert(index + 1, part)
used = True
return used
def get_items(sorted_keys, use_appear_after):
appear_after_retries = []
for name in sorted_keys:
if not name in merged_menu:
merged_menu[name] = []
for parts in menu_defs[name]:
for part in parts:
if part.appear_after:
if use_appear_after:
used = process_part(name, part)
if not used:
appear_after_retries.append((name, part))
elif not use_appear_after:
merged_menu[name].append(part)
for name, part in appear_after_retries:
used = process_part(name, part)
if not used:
carb.log_verbose(f"Warning: menu item failed to find appear_after index {part.appear_after}")
merged_menu[name].append(part)
# order using menu_order
sorted_keys = list(menu_keys)
if menu_order:
sorted_keys.sort(key=order_sort)
# get menu non-appear_after items & appear_after items
get_items(sorted_keys, False)
get_items(sorted_keys, True)
for hook_fn in self._menu_hooks:
hook_fn(merged_menu)
# prebuild menus so layout can be applied before building
self._prebuilt_menus = {}
for name in merged_menu.keys():
self.prebuild_menu(merged_menu[name], name, get_action_path(name, None), delegates[name][0] if name in delegates else None)
prebuilt_menus = self._prebuilt_menus
self._prebuilt_menus = None
self.get_menu_layout().apply_layout(prebuilt_menus)
return prebuilt_menus
def prebuild_menu(self, menus, prefix_name, action_prefix, delegate):
try:
import copy
def prebuild_menu(entry, prefix_name, action_prefix):
item = copy.copy(entry)
item.user["prebuilt_order"] = PrebuiltItemOrder.UNORDERED
# add submenu items to list
create_prebuild_entry(self._prebuilt_menus, prefix_name, action_prefix)
# check if item already on list, to avoid duplicates
duplicate = False
if item.name != "":
for old_item in self._prebuilt_menus[action_prefix]["items"]:
if item.name == old_item.name:
duplicate = True
break
if not duplicate:
# prefix_name cannot be "" as creating submenus with "" causes problems
self._prebuilt_menus[action_prefix]["items"].append(item)
self._prebuilt_menus[action_prefix]["prefix_name"] = prefix_name if prefix_name else "Empty"
self._prebuilt_menus[action_prefix]["remapped"] = []
self._prebuilt_menus[action_prefix]["action_prefix"] = action_prefix
self._prebuilt_menus[action_prefix]["menu_alignment"] = MenuAlignment.DEFAULT
self._prebuilt_menus[action_prefix]["delegate"] = delegate
if has_delegate_func(delegate, "get_menu_alignment"):
self._prebuilt_menus[action_prefix]["menu_alignment"] = delegate.get_menu_alignment()
if item.sub_menu and entry.name:
sub_prefix = get_menu_name(entry)
sub_action = get_action_path(action_prefix, entry.name)
for sub_item in item.sub_menu:
prebuild_menu(sub_item, sub_prefix, sub_action)
self._prebuilt_menus[sub_action]["sub_menu"] = True
item.sub_menu = sub_action
for menu_entry in menus:
prebuild_menu(menu_entry, prefix_name, action_prefix)
except Exception as e:
carb.log_error(f"Error {e} creating menu {menu_entry}")
import traceback, sys
traceback.print_exc(file=sys.stdout)
def get_menu_layout(self):
instance = self._get_instance()
if instance:
return instance.get_menu_layout()
return None
def get_fn_result(self, menu_entry: MenuItemDescription, name: str, default: bool=True):
fn = getattr(menu_entry, name)
if not fn:
return default
if isinstance(fn, list):
for fn_item in fn:
if fn_item and not fn_item():
return False
else:
if fn and not fn():
return False
return default
def get_menu_data(self):
instance = self._get_instance()
if instance:
return instance.get_menu_data()
return None, None, None
def set_right_padding(self, padding):
self._right_padding = padding
def create_menu(self):
menu_defs, menu_order, delegates = self.get_menu_data()
self._menu_bar.clear()
self._active_menus = {}
self._main_menus = {}
self._visible_menus = {}
self._last_item = {}
menus = self.merge_menus(menu_defs.keys(), menu_defs, menu_order, delegates)
right_menus = []
with self._menu_bar:
for name in menus.keys():
if not "sub_menu" in menus[name]:
if menus[name]["menu_alignment"] == MenuAlignment.RIGHT:
right_menus.append(name)
else:
self._build_menu(menus[name], menus, True)
if right_menus:
ui.Spacer().identifier = "right_aligned_menus"
for name in right_menus:
self._build_menu(menus[name], menus, True)
ui.Spacer(width=self._right_padding).identifier = "right_padding"
for key in self._main_menus.keys():
if key not in self._visible_menus:
self._main_menus[key].visible = False
if key in self._last_item:
if isinstance(self._last_item[key], ui.Separator):
self._last_item[key].visible = False
self._last_item = None
self._visible_menus = None
return menus
def refresh_menu_items(self, name: str):
self._dirty_menus.add(name)
def _submenu_is_shown(self, action_prefix: str, visible: bool, delegate: Any, refresh :bool):
if action_prefix in self._main_menus:
self._main_menus[action_prefix].visible = visible
if has_delegate_func(delegate, "update_menu_item"):
delegate.update_menu_item(self._main_menus[action_prefix], refresh)
# update to use new prebuild/layouts
def _refresh_menu(self, prebuilt_menus, prebuilt_menus_root, visible_override=None):
menus = prebuilt_menus["items"]
prefix_name = prebuilt_menus["prefix_name"]
action_prefix = prebuilt_menus["action_prefix"]
delegate = prebuilt_menus["delegate"] if "delegate" in prebuilt_menus else None
visible_count = 0
for menu_entry in sorted(menus, key=lambda a: a.user["prebuilt_order"]):
try:
menu_name = get_menu_name(menu_entry)
action_path = (get_action_path(action_prefix, menu_entry.name))
enabled = menu_entry.enabled
value = menu_entry.ticked_value
visible = True
if menu_entry.enable_fn:
enabled = self.get_fn_result(menu_entry, "enable_fn")
if menu_entry.ticked_fn:
value = self.get_fn_result(menu_entry, "ticked_fn")
if menu_entry.show_fn:
visible = self.get_fn_result(menu_entry, "show_fn")
# handle sub_menu before action_path/active_menus can skip it
if menu_entry.sub_menu and menu_entry.sub_menu in prebuilt_menus_root:
visible = self._refresh_menu(prebuilt_menus_root[menu_entry.sub_menu], prebuilt_menus_root, self.get_fn_result(menu_entry, "show_fn", None))
# update visibility
if visible_override is not None:
visible = visible_override
visible_count += 1 if visible else 0
self._submenu_is_shown(menu_entry.sub_menu, visible, delegate, True)
continue
if not action_path in self._active_menus:
continue
item = self._active_menus[action_path]
item.enabled = enabled
item.checked = value
item.visible = visible
if has_delegate_func(delegate, "update_menu_item"):
delegate.update_menu_item(item, True)
visible_count += 1 if item.visible else 0
except Exception as e:
carb.log_error(f"Error {e} refreshing menu {menu_entry}")
import traceback, sys
traceback.print_exc(file=sys.stdout)
return bool(visible_count > 0)
def _build_menu(self, prebuilt_menus, prebuilt_menus_root, is_root_menu, visible_override=None, menu_checkable=False, menu_hotkey_text=False, glyph=None) -> int:
def on_triggered():
if self._dirty_menus:
self._stats["triggered_refresh"] += 1
menu_defs, menu_order, menu_delegates = self.get_menu_data()
menus = self.merge_menus(menu_defs.keys(), menu_defs, menu_order)
for name in self._dirty_menus:
action_path = get_action_path(name, None)
if action_path in menus:
self._refresh_menu(menus[action_path], menus)
for remapped in menus[action_path]["remapped"]:
self._refresh_menu(menus[remapped], menus)
self._dirty_menus.clear()
def prep_menu(main_menu, prefix_name: str, action_prefix: str, visible: bool, delegate: callable, glyph: str, menu_checkable: bool, menu_hotkey_text: bool):
if not action_prefix in main_menu:
main_menu[action_prefix] = uiMenu(prefix_name, visible=visible, delegate=delegate, glyph=glyph, menu_checkable=menu_checkable, menu_hotkey_text=menu_hotkey_text, submenu=not is_root_menu)
if is_root_menu:
main_menu[action_prefix].set_triggered_fn(on_triggered)
menus = prebuilt_menus["items"]
prefix_name = prebuilt_menus["prefix_name"]
action_prefix = prebuilt_menus["action_prefix"]
delegate = prebuilt_menus["delegate"] if "delegate" in prebuilt_menus else None
visible_count = 0
icon_delegate = IconMenuDelegate()
# this menu item is built with menu_checkable passed via caller
prep_menu(self._main_menus, prefix_name, action_prefix, True if visible_override is None else visible_override, delegate if delegate else icon_delegate, glyph, menu_checkable, menu_hotkey_text)
# get delegate for icons
menu_hotkey_text = False
menu_checkable = False
for menu_entry in sorted(menus, key=lambda a: a.user["prebuilt_order"]):
if menu_entry.ticked:
menu_checkable = True
if menu_entry.original_menu_item and menu_entry.original_menu_item.hotkey:
menu_hotkey_text = True
with self._main_menus[action_prefix]:
for menu_entry in sorted(menus, key=lambda a: a.user["prebuilt_order"]):
try:
item = None
menu_name = get_menu_name(menu_entry)
action_path = (get_action_path(action_prefix, menu_entry.name))
on_lmb_click = None
if menu_entry.onclick_action and menu_entry.unclick_action:
def on_hotkey_action(onclick_action, unclick_action):
self._execute_action(onclick_action)
self._execute_action(unclick_action)
on_lmb_click = lambda oca=menu_entry.onclick_action, uca=menu_entry.unclick_action: on_hotkey_action(oca, uca)
elif menu_entry.onclick_action:
on_lmb_click = lambda oca=menu_entry.onclick_action: self._execute_action(oca)
elif menu_entry.onclick_fn and menu_entry.unclick_fn:
def on_hotkey_click():
menu_entry.onclick_fn()
menu_entry.unclick_fn()
on_lmb_click = on_hotkey_click
else:
on_lmb_click = menu_entry.onclick_fn
hotkey = None
if menu_entry.original_menu_item:
hotkey = menu_entry.original_menu_item.hotkey
enabled = menu_entry.enabled
ticked = menu_entry.ticked
value = menu_entry.ticked_value
visible = True
if menu_entry.enable_fn:
enabled = self.get_fn_result(menu_entry, "enable_fn")
if menu_entry.ticked_fn:
value = self.get_fn_result(menu_entry, "ticked_fn")
if menu_entry.show_fn:
visible = self.get_fn_result(menu_entry, "show_fn")
if menu_entry.name and menu_entry.sub_menu:
if menu_entry.sub_menu in prebuilt_menus_root:
self._visible_menus[action_prefix] = visible
visible = self._build_menu(prebuilt_menus_root[menu_entry.sub_menu], prebuilt_menus_root, False, self.get_fn_result(menu_entry, "show_fn", None), menu_checkable, menu_hotkey_text, menu_entry.glyph)
if visible_override is not None:
visible = visible_override
visible_count += 1 if visible else 0
self._submenu_is_shown(menu_entry.sub_menu, visible, delegate, False)
continue
elif menu_entry.header != None:
if action_prefix in self._last_item:
if isinstance(self._last_item[action_prefix], ui.Separator):
# last thing was a Separator, change the text to new value
self._last_item[action_prefix].text = menu_entry.header
else:
item = ui.Separator(menu_entry.header)
else:
item = ui.Separator(menu_entry.header)
elif menu_entry.name == "":
if action_prefix in self._last_item:
if action_prefix in self._last_item and not isinstance(self._last_item[action_prefix], ui.Separator):
item = ui.Separator()
else:
item = ui.Separator()
else:
item = uiMenuItem(menu_name, triggered_fn=on_lmb_click if on_lmb_click else None, checkable=ticked, checked=value, enabled=enabled, visible=visible, style=menu_entry.user.get("user_style", {}), delegate=icon_delegate, glyph=menu_entry.glyph, menu_checkable=menu_checkable, menu_hotkey_text=menu_hotkey_text)
if has_delegate_func(delegate, "update_menu_item"):
delegate.update_menu_item(item, False)
self._active_menus[action_path] = item
if hotkey:
item.hotkey_text = " " + menu_entry.original_menu_item.hotkey_text
setup_hotkey = True
try:
import omni.kit.hotkeys.core
# Always setup hotkey because hotkey may changed
setup_hotkey = True
except ImportError:
if hasattr(menu_entry.original_menu_item, "_action_setting_sub_id"):
setup_hotkey = False
if setup_hotkey:
hotkey_text = self._setup_hotkey(menu_entry.original_menu_item, action_path)
if hotkey_text is not None:
item.hotkey_text = hotkey_text
if item:
self._last_item[action_prefix] = item
self._visible_menus[action_prefix] = visible
visible_count += 1 if visible else 0
except Exception as e:
carb.log_error(f"Error {e} creating menu {menu_entry}")
import traceback, sys
traceback.print_exc(file=sys.stdout)
return bool(visible_count > 0)
def _execute_action(self, action: Tuple):
if not action:
return
async_delay = True
# check for MenuActionControl in action & remove
actioncontrol_list = [e for e in MenuActionControl]
if any(a in action for a in actioncontrol_list):
if MenuActionControl.NODELAY in action:
async_delay = False
action = tuple([item for item in action if item not in actioncontrol_list])
try:
import omni.kit.actions.core
import omni.kit.app
if async_delay:
async def execute_action(action):
await omni.kit.app.get_app().next_update_async()
omni.kit.actions.core.execute_action(*action)
# omni.ui can sometimes crash is menu callback does ui calls.
# To avoid this, use async function with frame delay
asyncio.ensure_future(execute_action(action))
else:
omni.kit.actions.core.execute_action(*action)
except ModuleNotFoundError:
carb.log_warn(f"menu_action: error omni.kit.actions.core not loaded")
except Exception as exc:
carb.log_warn(f"menu_action: error {exc}")
def _setup_hotkey(self, menu_entry: MenuItemDescription, action_path: str) -> str:
def action_trigger(on_action_pressed_fn, on_action_release_fn, evt, *_):
if evt.flags & carb.input.BUTTON_FLAG_PRESSED:
if on_action_pressed_fn:
on_action_pressed_fn()
elif on_action_release_fn:
on_action_release_fn()
if not menu_entry.hotkey:
return None
self._clear_hotkey(menu_entry)
self._unregister_hotkey(menu_entry)
import omni.appwindow
appwindow = omni.appwindow.get_default_app_window()
input = carb.input.acquire_input_interface()
settings = carb.settings.get_settings()
action_mapping_set_path = appwindow.get_action_mapping_set_path()
action_mapping_set = input.get_action_mapping_set_by_path(action_mapping_set_path)
input_string = menu_entry.get_action_mapping_desc()
menu_entry._action_setting_input_path = action_mapping_set_path + "/" + action_path + "/0"
settings.set_default_string(menu_entry._action_setting_input_path, input_string)
if menu_entry.onclick_action:
try:
from omni.kit.hotkeys.core import get_hotkey_registry
if not get_hotkey_registry():
raise ImportError
current_action_triggger = None
self._register_hotkey(menu_entry)
menu_entry.add_on_hotkey_update_func(lambda me, a=action_path: self._setup_hotkey(me, a))
if hasattr(menu_entry, "_pressed_hotkey"):
return menu_entry._pressed_hotkey.key_text if menu_entry._pressed_hotkey else ""
elif hasattr(menu_entry, "_released_hotkey"):
return menu_entry._released_hotkey.key_text if menu_entry._released_hotkey else ""
else:
return None
except ImportError:
current_action_triggger = functools.partial(action_trigger, lambda oca=menu_entry.onclick_action: self._execute_action(oca), lambda uca=menu_entry.unclick_action: self._execute_action(uca))
else:
current_action_triggger = functools.partial(action_trigger, menu_entry.onclick_fn, menu_entry.unclick_fn)
if current_action_triggger:
menu_entry._action_setting_sub_id = input.subscribe_to_action_events(action_mapping_set, action_path, current_action_triggger)
menu_entry.add_on_delete_func(self._clear_hotkey)
menu_entry.add_on_hotkey_update_func(lambda me, a=action_path: self._setup_hotkey(me, a))
# menu needs to refresh when self._action_setting_input_path changes
def hotkey_changed(changed_item: carb.dictionary.Item, change_event_type: carb.settings.ChangeEventType, weak_entry: weakref, action_path: str):
import carb.input
def set_hotkey_text(action_path, hotkey_text, active_menu_text):
menu_entry.hotkey_text = hotkey_text
if action_path in self._active_menus:
self._active_menus[action_path].hotkey_text = active_menu_text
menu_entry = weak_entry()
if not menu_entry:
return
# "changed_item" was DESTROYED, so remove hotkey
if change_event_type == carb.settings.ChangeEventType.DESTROYED:
set_hotkey_text(action_path, "", "")
return
hotkey_mapping = changed_item.get_dict()
if isinstance(hotkey_mapping, str):
set_hotkey_text(action_path, hotkey_mapping.replace("Keyboard::", ""), " " + menu_entry.hotkey_text)
else:
set_hotkey_text(action_path, "", "")
menu_entry._action_setting_changed_sub = settings.subscribe_to_node_change_events(menu_entry._action_setting_input_path, lambda ci, ev, m=weakref.ref(menu_entry), a=action_path: hotkey_changed(ci, ev, m, a))
return None
def _clear_hotkey(self, menu_entry):
if hasattr(menu_entry, "_action_setting_sub_id"):
try:
input = carb.input.acquire_input_interface()
input.unsubscribe_to_action_events(menu_entry._action_setting_sub_id)
del menu_entry._action_setting_sub_id
settings = carb.settings.get_settings()
settings.unsubscribe_to_change_events(menu_entry._action_setting_changed_sub)
del menu_entry._action_setting_changed_sub
del menu_entry._action_setting_input_path
except:
pass
def _register_hotkey(self, menu_entry: MenuItemDescription):
try:
from omni.kit.hotkeys.core import get_hotkey_registry, KeyCombination
hotkey_registry = get_hotkey_registry()
if not hotkey_registry:
raise ImportError
HOTKEY_EXT_ID = "omni.kit.menu.utils"
if menu_entry.onclick_action:
key = KeyCombination(menu_entry.hotkey[1], modifiers=menu_entry.hotkey[0])
menu_entry._pressed_hotkey = hotkey_registry.register_hotkey(HOTKEY_EXT_ID, key, menu_entry.onclick_action[0], menu_entry.onclick_action[1])
if menu_entry.unclick_action:
key = KeyCombination(menu_entry.hotkey[1], modifiers=menu_entry.hotkey[0], trigger_press=False)
menu_entry._released_hotkey = hotkey_registry.register_hotkey(HOTKEY_EXT_ID, key, menu_entry.unclick_action[0], menu_entry.unclick_action[1])
menu_entry.add_on_delete_func(self._unregister_hotkey)
except ImportError:
pass
def _unregister_hotkey(self, menu_entry: MenuItemDescription):
try:
from omni.kit.hotkeys.core import get_hotkey_registry
hotkey_registry = get_hotkey_registry()
if hotkey_registry:
if hasattr(menu_entry, "_pressed_hotkey"):
if menu_entry._pressed_hotkey:
hotkey_registry.deregister_hotkey(menu_entry._pressed_hotkey)
if hasattr(menu_entry, "_released_hotkey"):
if menu_entry._released_hotkey:
hotkey_registry.deregister_hotkey(menu_entry._released_hotkey)
if hasattr(menu_entry, "__hotkey_changed_event_sub"):
menu_entry.__hotkey_changed_event_sub = None
except ImportError:
pass
| 35,928 | Python | 46.399736 | 331 | 0.563933 |
omniverse-code/kit/exts/omni.kit.menu.utils/omni/kit/menu/utils/scripts/__init__.py | from .utils import *
from .debug_window import *
| 49 | Python | 15.666661 | 27 | 0.734694 |
omniverse-code/kit/exts/omni.kit.menu.utils/omni/kit/menu/utils/scripts/utils.py | import asyncio
import functools
import carb
import carb.settings
import omni.ext
import omni.kit.app
from functools import partial
from typing import Callable, Tuple, Union, List
from .actions import add_action_to_menu, ActionMenuSubscription
from .layout import MenuLayout
from .builder_utils import MenuItemDescription, PrebuiltItemOrder, MenuAlignment, LayoutSourceSearch
from .app_menu import MenuItemOrder, MenuState, MenuActionControl, IconMenuDelegate
_extension_instance = None
class MenuUtilsExtension(omni.ext.IExt):
def __init__(self):
super().__init__()
self._menu_defs = {}
self._menu_delegates = {}
self._menu_order = {}
self._master_menu = {}
self._ready_state = MenuState.Invalid
self._menus_to_refresh = set()
self._refresh_task = None
# debug stats
self._stats = {}
self._stats["add_menu_items"] = 0
self._stats["remove_menu_items"] = 0
self._stats["add_hook"] = 0
self._stats["remove_hook"] = 0
self._stats["add_layout"] = 0
self._stats["remove_layout"] = 0
self._stats["refresh_menu_items"] = 0
self._stats["refresh_menu_items_skipped"] = 0
self._stats["rebuild_menus"] = 0
self._stats["rebuild_menus_skipped"] = 0
def on_startup(self, ext_id):
global _extension_instance
_extension_instance = self
LOADED_EXTENSION_COUNT_MENU = "/exts/omni.kit.menu.utils/loaded_extension_count"
settings = carb.settings.get_settings()
settings.set_default_int(LOADED_EXTENSION_COUNT_MENU, 0)
loaded_extension_count = settings.get(LOADED_EXTENSION_COUNT_MENU) + 1
settings.set(LOADED_EXTENSION_COUNT_MENU, loaded_extension_count)
self._menu_creator = None
self._menu_layout = MenuLayout()
self._hooks = []
self._stats["extension_loaded_count"] = loaded_extension_count
ext_manager = omni.kit.app.get_app_interface().get_extension_manager()
# Hook to extension enable/disable
# to setup hotkey with different ways with omni.kit.hotkeys.core enabled/disabled
hooks = ext_manager.get_hooks()
self.__extension_enabled_hook = hooks.create_extension_state_change_hook(
self.__on_ext_changed, omni.ext.ExtensionStateChangeType.AFTER_EXTENSION_ENABLE
)
self.__extension_disabled_hook = hooks.create_extension_state_change_hook(
self.__on_ext_changed, omni.ext.ExtensionStateChangeType.AFTER_EXTENSION_DISABLE
)
mainwindow_loaded = next(
(
ext
for ext in ext_manager.get_extensions()
if ext["id"].startswith("omni.kit.mainwindow") and ext["enabled"]
),
None,
)
settings = carb.settings.get_settings()
if settings.get("/exts/omni.kit.menu.utils/forceEditorMenu") is not None:
carb.log_error(f"omni.kit.menu.utils forceEditorMenu is no longer supported")
if mainwindow_loaded:
from .app_menu import AppMenu
self._menu_creator = AppMenu(lambda: _extension_instance)
else:
carb.log_info(f"omni.kit.mainwindow is not loaded. Menus are disabled")
# if mainwindow loads later, need to refresh menu_creator
manager = omni.kit.app.get_app().get_extension_manager()
self._hooks.append(
manager.subscribe_to_extension_enable(
on_enable_fn=lambda _: self._mainwindow_loaded(),
on_disable_fn=None,
ext_name="omni.kit.mainwindow",
hook_name="omni.kit.menu.utils omni.kit.mainwindow listener",
)
)
# set app started trigger. refresh_menu_items & rebuild_menus won't do anything until self._ready_state is MenuState.Created
self._app_ready_sub = (
omni.kit.app.get_app()
.get_startup_event_stream()
.create_subscription_to_pop_by_type(
omni.kit.app.EVENT_APP_READY, self._build_menus_after_loading, name="omni.kit.menu.utils app started trigger"
)
)
def __on_ext_changed(self, ext_id: str, *_):
if ext_id.startswith("omni.kit.hotkeys.core"):
self.rebuild_menus()
def _mainwindow_loaded(self):
from .app_menu import AppMenu
self._menu_creator = AppMenu(lambda: _extension_instance)
self.rebuild_menus()
carb.log_info(f"omni.kit.mainwindow is now loaded. Menus are enabled")
def _build_menus_after_loading(self, event):
self._ready_state = MenuState.Created
self._menu_layout.menus_created()
self.rebuild_menus()
def on_shutdown(self):
global _extension_instance
_extension_instance = None
self.__extension_enabled_hook = None
self.__extension_disabled_hook = None
if self._menu_creator:
self._menu_creator.destroy()
del self._menu_creator
self._menu_creator = None
if self._menu_layout:
self._menu_layout.destroy()
del self._menu_layout
self._menu_layout = None
self._menus_to_refresh = None
self._refresh_task = None
self._menu_defs = None
self._menu_delegates = None
self._menu_order = None
self._hooks = None
def add_menu_items(self, menu: list, name: str, menu_index: int, rebuild_menus: bool, delegate = None) -> list:
if not menu and delegate:
menu = [MenuItemDescription(name="placeholder", show_fn=lambda: False)]
if menu and not isinstance(menu[0], MenuItemDescription):
carb.log_error(f"add_menu_items: menu {menu} is not a MenuItemDescription")
return None
self._stats["add_menu_items"] += 1
if not name in self._menu_defs:
self._menu_defs[name] = []
self._menu_defs[name].append(menu)
if name in self._menu_delegates:
_delegate, count = self._menu_delegates[name]
if delegate != _delegate:
carb.log_warn(f"add_menu_items: menu {menu} cannot change delegate")
self._menu_delegates[name] = (_delegate, count + 1)
elif delegate:
self._menu_delegates[name] = (delegate, 1)
if menu_index != 0 and name not in self._menu_order:
self._menu_order[name] = menu_index
if rebuild_menus:
self.rebuild_menus()
return menu
def set_default_menu_proirity(self, name: str, menu_index: int):
if menu_index == 0:
return
for index in self._menu_order:
if self._menu_order[index] == menu_index:
return
self._menu_order[name] = menu_index
def remove_menu_items(self, menu: list, name: str, rebuild_menus: bool):
self._stats["remove_menu_items"] += 1
try:
if name in self._menu_defs:
self._menu_defs[name].remove(menu)
if name in self._menu_delegates:
delegate, count = self._menu_delegates[name]
if count == 1:
del self._menu_delegates[name]
else:
self._menu_delegates[name] = (delegate, count - 1)
if rebuild_menus:
self.rebuild_menus()
except Exception as exc:
carb.log_warn(f"omni.kit.menu.utils remove_menu_items \"{name}\" failed {exc}")
def add_hook(self, callback: Callable):
self._stats["add_hook"] += 1
if self._menu_creator:
self._menu_creator.add_hook(callback)
def remove_hook(self, callback: Callable):
self._stats["remove_hook"] += 1
try:
if self._menu_creator:
self._menu_creator.remove_hook(callback)
except Exception as exc:
carb.log_warn(f"omni.kit.menu.utils remove_hook failed {exc}")
def add_layout(self, layout: List[Union[MenuLayout.Menu, MenuLayout.SubMenu, MenuLayout.Item, MenuLayout.Seperator, MenuLayout.Group]]):
self._stats["add_layout"] += 1
self._menu_layout.add_layout(layout)
self.rebuild_menus()
def remove_layout(self, layout: List[Union[MenuLayout.Menu, MenuLayout.SubMenu, MenuLayout.Item, MenuLayout.Seperator, MenuLayout.Group]]):
self._stats["remove_layout"] += 1
self._menu_layout.remove_layout(layout)
self.rebuild_menus()
def get_merged_menus(self):
return self._menu_creator.merge_menus(self._menu_defs.keys(), self._menu_defs, self._menu_order)
def refresh_menu_items(self, name: str, immediately: bool = False):
if not self._ready_state & MenuState.Created:
self._stats["refresh_menu_items_skipped"] += 1
return
self._stats["refresh_menu_items"] += 1
if self._menu_creator:
self._menu_creator.refresh_menu_items(name)
def rebuild_menus(self):
if not self._ready_state & MenuState.Created:
self._stats["rebuild_menus_skipped"] += 1
return
self._stats["rebuild_menus"] += 1
if self._menu_creator:
self._menu_creator.create_menu()
def get_menu_layout(self):
return self._menu_layout
def get_menu_data(self):
return self._menu_defs, self._menu_order, self._menu_delegates
def get_instance():
return _extension_instance
def add_menu_items(menu: list, name: str, menu_index: int = 0, rebuild_menus: bool = True, delegate = None):
"""
add a list of menus items to menu.
menu is list of MenuItemDescription()
name is name to appear when menu is collapsed
menu_index is horizontal positioning
rebuild_menus is flag to call rebuild_menus when True
delegate ui.MenuDelegate delegate
"""
instance = get_instance()
if instance:
return get_instance().add_menu_items(menu, name, menu_index, rebuild_menus, delegate)
def remove_menu_items(menu: list, name: str, rebuild_menus: bool = True):
"""
remove a list of menus items to menu.
menu is list of MenuItemDescription()
name is name to appear when menu is collapsed
rebuild_menus is flag to call rebuild_menus when True
"""
instance = get_instance()
if instance:
instance.remove_menu_items(menu, name, rebuild_menus)
def refresh_menu_items(name: str, immediately = None):
"""
update menus enabled state
menu is list of MenuItemDescription()
name is name to appear when menu is collapsed
immediately is deprecated and not used
"""
instance = get_instance()
if instance:
carb.log_info(f"omni.kit.menu.utils.refresh_menu_items {name}")
if immediately != None:
carb.log_warn(f"refresh_menu_items immediately parameter is deprecated and not used")
instance.refresh_menu_items(name)
def add_hook(callback: Callable):
"""
add a menu modification callback hook
callback is function to be called when menus are re-generated
"""
instance = get_instance()
if instance:
instance.add_hook(callback)
def remove_hook(callback: Callable):
"""
remove a menu modification callback hook
callback is function to be called when menus are re-generated
"""
instance = get_instance()
if instance:
instance.remove_hook(callback)
def rebuild_menus():
"""
force menus to rebuild, triggering hooks
"""
instance = get_instance()
if instance:
carb.log_info(f"omni.kit.menu.utils.rebuild_menus")
instance.rebuild_menus()
def set_default_menu_proirity(name, menu_index):
"""
set default menu priority
"""
instance = get_instance()
if instance:
instance.set_default_menu_proirity(name, menu_index)
def add_layout(layout: List[Union[MenuLayout.Menu, MenuLayout.SubMenu, MenuLayout.Item, MenuLayout.Seperator, MenuLayout.Group]]):
"""
add a menu layout.
"""
instance = get_instance()
if instance:
instance.add_layout(layout)
def remove_layout(layout: List[Union[MenuLayout.Menu, MenuLayout.SubMenu, MenuLayout.Item, MenuLayout.Seperator, MenuLayout.Group]]):
"""
remove a menu layout.
"""
instance = get_instance()
if instance:
instance.remove_layout(layout)
def get_menu_layout():
"""
get menu layouts.
"""
instance = get_instance()
if instance:
return instance.get_menu_layout().get_layout()
def get_merged_menus() -> dict:
"""
get combined menus as dictionary
"""
instance = get_instance()
if instance:
return instance.get_merged_menus()
return None
def get_debug_stats() -> dict:
instance = get_instance()
if instance:
return instance._stats
return None
| 12,910 | Python | 32.710183 | 143 | 0.617041 |
omniverse-code/kit/exts/omni.kit.menu.utils/omni/kit/menu/utils/scripts/actions.py | """Actions Omniverse Kit API
Module to work with **Actions** in the Kit. It is built on top of ``carb.input`` system that features action mapping logic.
"""
import omni.kit.ui
import omni.appwindow
import carb.input
import carb.settings
from typing import Callable, Tuple
import functools
class ActionMenuSubscription:
"""
Action menu subscription wrapper to make it scoped (auto unsubscribe on del)
"""
def __init__(self, _on_del: Callable):
self._on_del = _on_del
self._mapped = True
def unsubscribe(self):
if self._mapped:
self._mapped = False
self._on_del()
def __del__(self):
self.unsubscribe()
def add_action_to_menu(
menu_path: str,
on_action: Callable,
action_name: str = None,
default_hotkey: Tuple[int, int] = None,
on_rmb_click: Callable = None,
) -> ActionMenuSubscription:
"""
Add action to menu path.
This function binds passed callable `on_action` function with :mod:`carb.input` action and a menu path together. If
`default_hotkey` is provided it is set into settings and appears on the menu.
Args:
menu_path: menu path. E.g. "File/Open".
on_action: function to be called as an action.
on_rmb_click: function to be called when right mouse button clicked.
action_name: action name. If not provided menu path is used as action, where all '/' are replaced with '-'.
default_hotkey(tuple(int, :class:`carb.input.KeyboardInput`)): modifier and key tuple to associate with given action.
Returns:
Subscription holder object. Action is removed when this object is destroyed.
"""
return omni.kit.ui.get_editor_menu().add_action_to_menu(menu_path, on_action, action_name, default_hotkey, on_rmb_click)
def unsubsribe():
input.unsubscribe_to_action_events(sub_id)
menu = omni.kit.ui.get_editor_menu()
if menu:
menu.set_action(menu_path, action_mapping_set_path, "")
return ActionMenuSubscription(unsubsribe)
| 2,051 | Python | 31.0625 | 125 | 0.665529 |
omniverse-code/kit/exts/omni.kit.menu.utils/omni/kit/menu/utils/scripts/layout.py | import os
import carb
import carb.settings
from typing import List, Union, Dict
from enum import Enum
from .builder_utils import get_action_path, create_prebuild_entry
from .builder_utils import MenuItemDescription, PrebuiltItemOrder, LayoutSourceSearch
class MenuLayout:
class MenuLayoutItem:
def __init__(self, name=None, source=None, source_search=LayoutSourceSearch.EVERYWHERE):
self.name = name
self.source = source
self.source_search = source_search
def __repr__(self):
if self.source:
return f"<{self.__class__} name:{self.name} source:{self.source}>"
return f"<{self.__class__} name:{self.name}>"
def json_enc(self):
sub_items = {}
values = {f"MenuLayout.{self.__class__.__name__}": sub_items}
for index in dir(self):
if not index.startswith("_"):
item = getattr(self, index)
if item is not None and not callable(item):
sub_items[index] = item
return values
class Menu(MenuLayoutItem):
def __init__(self, name, items=[], source=None, source_search=LayoutSourceSearch.EVERYWHERE, remove=False):
super().__init__(name, source, source_search)
self.items = items
self.remove = remove
class SubMenu(MenuLayoutItem):
def __init__(self, name, items=[], source=None, source_search=LayoutSourceSearch.EVERYWHERE, remove=False):
super().__init__(name, source, source_search)
self.items = items
self.remove = remove
class Item(MenuLayoutItem):
def __init__(self, name, source=None, source_search=LayoutSourceSearch.EVERYWHERE, remove=False):
super().__init__(name, source, source_search)
self.remove = remove
class Seperator(MenuLayoutItem):
def __init__(self, name=None, source=None, source_search=LayoutSourceSearch.EVERYWHERE):
super().__init__(name, source, source_search)
class Group(MenuLayoutItem):
def __init__(self, name, items=[], source=None, source_search=LayoutSourceSearch.EVERYWHERE):
super().__init__(name, source, source_search)
self.items = items
class Sort(MenuLayoutItem):
def __init__(self, name=None, source=None, source_search=LayoutSourceSearch.EVERYWHERE, exclude_items=[], sort_submenus=False):
super().__init__(name, source)
self.items = exclude_items
self.sort_submenus = sort_submenus
def __repr__(self):
return f"<{self.__class__} items:{self.items}>"
def __init__(self, debuglog = False):
self._layout_template = []
self._menus_created = False
self._debuglog = debuglog
def __del__(self):
self.destroy()
def destroy(self):
self._layout_template = None
def menus_created(self):
self._menus_created = True
def add_layout(self, layout: List[MenuLayoutItem]):
self._layout_template.append(layout.copy())
def remove_layout(self, layout: List[MenuLayoutItem]):
self._layout_template.remove(layout)
def get_layout(self):
return self._layout_template
def apply_layout(self, prebuilt_menus: dict):
if not self._menus_created:
return
menu_layout_lists = self.get_layout()
for menu_layout in menu_layout_lists:
MenuLayout.process_layout(prebuilt_menus, menu_layout, menu_name=None, submenu_name=None, parent_layout_offset=0, parent_layout_index=PrebuiltItemOrder.UNORDERED, debuglog=self._debuglog)
# static functions to prevent self leaks
@staticmethod
def find_menu_item(menu_items: List, menu_items_root: List, layout_item: MenuLayoutItem):
if layout_item.source:
if "/" in layout_item.source.replace("\\", "/"):
sub_name = get_action_path(os.path.dirname(layout_item.source), "")
sub_prefix = os.path.basename(layout_item.source)
if sub_name in menu_items_root:
menu_subitems = menu_items_root[sub_name]["items"]
for item in menu_subitems:
if item.name == sub_prefix:
return item, menu_subitems, sub_name
return None, None, None
for item in menu_items:
if item.name == layout_item.source:
return item, None, None
else:
for item in menu_items:
if item.name == layout_item.name:
return item, None, None
if layout_item.source_search == LayoutSourceSearch.EVERYWHERE:
# not in current menu, search them all....
for sub_name in menu_items_root.keys():
menu_subitems = menu_items_root[sub_name]["items"]
for item in menu_subitems:
if item.name == layout_item.name:
layout_item.source = f"{sub_name}/{layout_item.name}"
return item, menu_subitems, sub_name
return None, None, None
@staticmethod
def process_layout(prebuilt_menus: dict, menu_layout:List, menu_name: str, submenu_name: str, parent_layout_offset: int, parent_layout_index: int, debuglog: bool):
def item_in_menu(menus, menu_name):
for sub_item in menus:
if sub_item.name == menu_name:
return True
return False
def create_menu_entry(menu_name, submenu_name):
action_prefix = get_action_path(menu_name, submenu_name)
if not action_prefix in prebuilt_menus:
if menu_name in prebuilt_menus:
menu_subitems = prebuilt_menus[menu_name]["items"]
# if item not already in submenu, add it
if not item_in_menu(menu_subitems, submenu_name):
item = MenuItemDescription(submenu_name, sub_menu=action_prefix)
item.user["prebuilt_order"] = PrebuiltItemOrder.LAYOUT_ORDERED + parent_layout_offset + parent_layout_index
menu_subitems.append(item)
create_prebuild_entry(prebuilt_menus, submenu_name, action_prefix)
prebuilt_menus[action_prefix]["sub_menu"] = True
for layout_index, layout_item in enumerate(menu_layout):
# MenuLayout.Menu
if isinstance(layout_item, MenuLayout.Menu):
action_prefix = get_action_path(layout_item.name, None)
if layout_item.remove:
if action_prefix in prebuilt_menus:
del prebuilt_menus[action_prefix]
elif debuglog:
carb.log_warn(f"Warning: Layout item {layout_item} not found in prebuilt_menus")
else:
# menu doesn't exist, create one
if not action_prefix in prebuilt_menus:
carb.log_warn(f"Menu {layout_item.name} not found. Create with; (\"menu_index\" controls menu order)")
carb.log_warn(f" self._menu_placeholder = omni.kit.menu.utils.add_menu_items([MenuItemDescription(name=\"placeholder\", show_fn=lambda: False)], name=\"{layout_item.name}\", menu_index=90)")
continue
MenuLayout.process_layout(prebuilt_menus, layout_item.items, layout_item.name, submenu_name, 0, layout_index, debuglog)
# MenuLayout.SubMenu
elif isinstance(layout_item, MenuLayout.SubMenu):
if not menu_name:
carb.log_warn(f"Warning: Bad Layout item {layout_item}. Cannot have SubMenu without Menu as parent")
if layout_item.remove:
action_prefix = get_action_path(menu_name, layout_item.name)
if action_prefix in prebuilt_menus:
del prebuilt_menus[action_prefix]
menu_subitems = prebuilt_menus[menu_name]["items"]
for item in menu_subitems:
if item.sub_menu == layout_item.name:
menu_subitems.remove(item)
break
elif debuglog:
carb.log_warn(f"Warning: Layout item {layout_item} not found in prebuilt_menus")
else:
action_prefix = get_action_path(menu_name, None)
if action_prefix in prebuilt_menus:
menu_subitems = prebuilt_menus[action_prefix]["items"]
menu_subitem, source_menu, _ = MenuLayout.find_menu_item(menu_subitems, prebuilt_menus, layout_item)
if menu_subitem:
menu_subitem.user["prebuilt_order"] = PrebuiltItemOrder.LAYOUT_ORDERED + parent_layout_offset + layout_index
else:
# add submenu item
menu_subitem = MenuItemDescription(name=layout_item.name, sub_menu=get_action_path(menu_name, layout_item.name))
menu_subitems.append(menu_subitem)
menu_subitem.user["prebuilt_order"] = PrebuiltItemOrder.LAYOUT_ORDERED + parent_layout_offset + layout_index
if submenu_name:
action_prefix = get_action_path(menu_name, submenu_name)
MenuLayout.process_layout(prebuilt_menus, layout_item.items, action_prefix, layout_item.name, parent_layout_offset, layout_index + 1, debuglog)
else:
MenuLayout.process_layout(prebuilt_menus, layout_item.items, menu_name, layout_item.name, parent_layout_offset, layout_index, debuglog)
parent_layout_offset += len(layout_item.items) + 1
# MenuLayout.Item
elif isinstance(layout_item, MenuLayout.Item):
action_prefix = get_action_path(menu_name, submenu_name)
create_menu_entry(menu_name, submenu_name)
menu_subitems = prebuilt_menus[action_prefix]["items"]
menu_subitem, source_menu, orig_root_menu = MenuLayout.find_menu_item(menu_subitems, prebuilt_menus, layout_item)
if not submenu_name and orig_root_menu:
prebuilt_menus[orig_root_menu]["remapped"].append(action_prefix)
if menu_subitem:
menu_subitem.user["prebuilt_order"] = PrebuiltItemOrder.LAYOUT_ORDERED + parent_layout_offset + layout_index
if source_menu and source_menu != menu_subitems:
menu_subitems.append(menu_subitem)
source_menu.remove(menu_subitem)
if layout_item.source:
menu_subitem.name = layout_item.name
else:
if layout_item.remove:
menu_subitems.remove(menu_subitem)
elif layout_item.source:
menu_subitem.name = layout_item.name
elif debuglog:
carb.log_warn(f"Warning: Layout not found {layout_item}")
# MenuLayout.Seperator
elif isinstance(layout_item, MenuLayout.Seperator):
action_prefix = get_action_path(menu_name, submenu_name)
if action_prefix in prebuilt_menus:
menu_subitems = prebuilt_menus[action_prefix]["items"]
item = MenuItemDescription()
if layout_item.name:
item.header = layout_item.name
item.user["prebuilt_order"] = PrebuiltItemOrder.LAYOUT_ORDERED + parent_layout_offset + layout_index
menu_subitems.append(item)
# MenuLayout.Group
elif isinstance(layout_item, MenuLayout.Group):
action_prefix = get_action_path(menu_name, submenu_name)
create_menu_entry(menu_name, submenu_name)
menu_subitems = prebuilt_menus[action_prefix]["items"]
item = MenuItemDescription(header=layout_item.name)
item.user["prebuilt_order"] = PrebuiltItemOrder.LAYOUT_ORDERED + parent_layout_offset + layout_index
menu_subitems.append(item)
MenuLayout.process_layout(prebuilt_menus, layout_item.items, menu_name, submenu_name, parent_layout_offset + layout_index + 1, parent_layout_index, debuglog)
parent_layout_offset += len(layout_item.items) + 1
if layout_item.source:
menu_subitem, source_menu, _ = MenuLayout.find_menu_item(menu_subitems, prebuilt_menus, layout_item)
if source_menu and source_menu != menu_subitems:
if menu_subitem.sub_menu:
for item in prebuilt_menus[menu_subitem.sub_menu]["items"]:
item.user["prebuilt_order"] = PrebuiltItemOrder.LAYOUT_ORDERED + parent_layout_offset + layout_index
menu_subitems.append(item)
parent_layout_offset += 1
else:
menu_subitems.append(menu_subitem)
source_menu.remove(menu_subitem)
# MenuLayout.Sort
elif isinstance(layout_item, MenuLayout.Sort):
action_prefix = get_action_path(menu_name, submenu_name)
create_menu_entry(menu_name, submenu_name)
menu_subitems = prebuilt_menus[action_prefix]["items"]
sort_submenus = []
items = [i for i in menu_subitems if i.name != "" and not i.name in layout_item.items]
for index, item in enumerate(sorted(items, key=lambda a: a.name)):
item_offset = PrebuiltItemOrder.LAYOUT_SUBMENU_SORTED if item.sub_menu else PrebuiltItemOrder.LAYOUT_ITEM_SORTED
item.user["prebuilt_order"] = item_offset + parent_layout_offset + index
if layout_item.sort_submenus and item.sub_menu and not item.sub_menu in layout_item.items:
sort_submenus.append(item.sub_menu)
for sub_menu in sort_submenus:
item_list = prebuilt_menus[sub_menu]["items"]
# seperators must not move, just sort items inbetween
groups = []
last_seperator = 0
for index, item in enumerate(item_list):
if item.name == "":
if last_seperator != index:
groups.append((last_seperator, index))
last_seperator = index
if last_seperator:
groups.append((last_seperator, len(item_list)))
for gstart, gend in groups:
items = [i for i in item_list[gstart : gend] if not i.name in layout_item.items]
item_offset = items[0].user["prebuilt_order"]
items = items[1:]
for index, item in enumerate(sorted(items, key=lambda a: a.name)):
item.user["prebuilt_order"] = item_offset + index
if item.sub_menu and not item.sub_menu in layout_item.items:
sort_submenus.append(item.sub_menu)
else:
items = [i for i in item_list if not i.name in layout_item.items]
for index, item in enumerate(sorted(items, key=lambda a: a.name)):
item_offset = PrebuiltItemOrder.LAYOUT_SUBMENU_SORTED if item.sub_menu else PrebuiltItemOrder.LAYOUT_ITEM_SORTED
item.user["prebuilt_order"] = item_offset + parent_layout_offset + index
if item.sub_menu and not item.sub_menu in layout_item.items:
sort_submenus.append(item.sub_menu)
elif debuglog:
carb.log_warn(f"Warning: Unknown layout type {layout_item}")
| 16,446 | Python | 52.748366 | 215 | 0.557522 |
omniverse-code/kit/exts/omni.kit.menu.utils/omni/kit/menu/utils/tests/test_debug_menu.py | import os
import unittest
import pathlib
import carb
import carb.input
import omni.kit.test
import omni.ui as ui
from pathlib import Path
from omni.kit import ui_test
from omni.ui.tests.test_base import OmniUiTest
from omni.kit.test_suite.helpers import get_test_data_path
class TestDebugMenu(OmniUiTest):
async def setUp(self):
pass
async def tearDown(self):
pass
async def test_debug_menu(self):
DebugWindowName = "omni.kit.menu.utils debug"
# hotkey - show_menu_debug_window
await ui_test.emulate_keyboard_press(carb.input.KeyboardInput.M, carb.input.KEYBOARD_MODIFIER_FLAG_CONTROL + carb.input.KEYBOARD_MODIFIER_FLAG_ALT + carb.input.KEYBOARD_MODIFIER_FLAG_SHIFT)
await ui_test.human_delay(50)
golden_img_dir = pathlib.Path(get_test_data_path(__name__, "golden_img"))
await self.docked_test_window(
window=ui.Workspace.get_window(DebugWindowName),
width=450,
height=300)
await self.finalize_test(golden_img_dir=golden_img_dir, golden_img_name="test_debug_window.png")
await ui_test.human_delay(50)
ui.Workspace.show_window(DebugWindowName, False)
| 1,195 | Python | 30.473683 | 197 | 0.699582 |
omniverse-code/kit/exts/omni.kit.menu.utils/omni/kit/menu/utils/tests/test_menu_layouts.py | import os
import unittest
import carb
import omni.kit.test
import omni.ui as ui
from omni.kit import ui_test
from omni.kit.menu.utils import MenuItemDescription, MenuLayout, LayoutSourceSearch
from .utils import verify_menu_items, verify_menu_checked_items
class TestMenuLayoutUtils(omni.kit.test.AsyncTestCase):
async def setUp(self):
pass
async def tearDown(self):
pass
async def test_nested_submenu_layout(self):
menu_placeholder = [MenuItemDescription(name="placeholder", show_fn=lambda: False)]
menu_physics = [ MenuItemDescription(name="Physics", sub_menu=[
MenuItemDescription(name="Debug"),
MenuItemDescription(name="Settings"),
MenuItemDescription(name="Demo Scenes"),
MenuItemDescription(name="Test Runner"),
MenuItemDescription(name="Character Controller")]) ]
menu_blast = [ MenuItemDescription(name="Blast", sub_menu=[
MenuItemDescription(name="Settings"),
MenuItemDescription(name="Documentation", sub_menu=[
MenuItemDescription(name="Kit UI"),
MenuItemDescription(name="Programming"),
MenuItemDescription(name="USD Schemas")]) ])]
menu_flow = [ MenuItemDescription(name="Flow", sub_menu=[
MenuItemDescription(name="Presets"),
MenuItemDescription(name="Monitor")]) ]
# add menu
omni.kit.menu.utils.add_menu_items(menu_placeholder, "Window", 90)
omni.kit.menu.utils.add_menu_items(menu_physics, "Window")
omni.kit.menu.utils.add_menu_items(menu_blast, "Window")
omni.kit.menu.utils.add_menu_items(menu_flow, "Window")
await ui_test.human_delay()
# ----------------------------------------------------
# nested layout test
# ----------------------------------------------------
menu_layout = [
MenuLayout.Menu("Window", [
MenuLayout.SubMenu("Simulation", [
MenuLayout.Group("Flow", [
MenuLayout.Item("Presets", source="Window/Flow/Presets"),
MenuLayout.Item("Monitor", source="Window/Flow/Monitor"),
]),
MenuLayout.Group("Blast", [
MenuLayout.Item("Settings", source="Window/Blast/Settings"),
MenuLayout.SubMenu("Documentation", [
MenuLayout.Item("Kit UI", source="Window/Blast/Documentation/Kit UI"),
MenuLayout.Item("Programming", source="Window/Blast/Documentation/Programming"),
MenuLayout.Item("USD Schemas", source="Window/Blast/Documentation/USD Schemas"),
]),
]),
MenuLayout.Group("Physics", [
MenuLayout.Item("Demo Scenes"),
MenuLayout.Item("Settings", source="Window/Physics/Settings"),
MenuLayout.Item("Debug"),
MenuLayout.Item("Test Runner"),
MenuLayout.Item("Character Controller")
]),
]),
])
]
omni.kit.menu.utils.add_layout(menu_layout)
# verify layout
verify_menu_items(self, [(ui.Menu, "Window", True), (ui.Menu, "Simulation", True), (ui.MenuItem, "placeholder", False), (ui.Menu, "Physics", False), (ui.Menu, "Blast", False), (ui.Menu, "Flow", False), (ui.Separator, "Flow", True), (ui.MenuItem, "Presets", True), (ui.MenuItem, "Monitor", True), (ui.Separator, "Blast", True), (ui.MenuItem, "Settings", True), (ui.Menu, "Documentation", True), (ui.Separator, "Physics", True), (ui.MenuItem, "Demo Scenes", True), (ui.MenuItem, "Settings", True), (ui.MenuItem, "Debug", True), (ui.MenuItem, "Test Runner", True), (ui.MenuItem, "Character Controller", True), (ui.MenuItem, "Kit UI", True), (ui.MenuItem, "Programming", True), (ui.MenuItem, "USD Schemas", True), (ui.Menu, "Documentation", False)])
# remove layout
omni.kit.menu.utils.remove_layout(menu_layout)
self.assertTrue(omni.kit.menu.utils.get_menu_layout() == [])
# remove menu
omni.kit.menu.utils.remove_menu_items(menu_physics, "Window")
omni.kit.menu.utils.remove_menu_items(menu_blast, "Window")
omni.kit.menu.utils.remove_menu_items(menu_flow, "Window")
omni.kit.menu.utils.remove_menu_items(menu_placeholder, "Window")
self.assertTrue(omni.kit.menu.utils.get_merged_menus() == {})
async def test_remapped_layout_checkbox(self):
menu_placeholder = [MenuItemDescription(name="placeholder", show_fn=lambda: False)]
async def refresh_menus():
await ui_test.menu_click("Tools", human_delay_speed=4, show=True)
await ui_test.menu_click("More Tools", human_delay_speed=4, show=True)
await ui_test.menu_click("More Tools", human_delay_speed=4, show=False)
example_window_is_ticked = False
def get_example_window_is_ticked():
nonlocal example_window_is_ticked
return example_window_is_ticked
def toggle_example_window_is_ticked():
nonlocal example_window_is_ticked
example_window_is_ticked = not example_window_is_ticked
menu_entry1 = [ MenuItemDescription(name="Example Window", ticked=True, ticked_fn=get_example_window_is_ticked, onclick_fn=toggle_example_window_is_ticked) ]
menu_entry2 = [ MenuItemDescription(name="Best Window Ever", ticked=True, ticked_fn=get_example_window_is_ticked, onclick_fn=toggle_example_window_is_ticked) ]
# add menu
omni.kit.menu.utils.add_menu_items(menu_placeholder, "Tools")
omni.kit.menu.utils.add_menu_items(menu_placeholder, "More Tools")
omni.kit.menu.utils.add_menu_items(menu_entry1, "Window")
omni.kit.menu.utils.add_menu_items(menu_entry2, "Window")
await ui_test.human_delay()
# more the "Example Window" and "Best Window Ever" to differrent menus
menu_layout = [
MenuLayout.Menu("Tools", [
MenuLayout.Item("Stage Window", source="Window/Example Window")
]),
MenuLayout.Menu("More Tools", [
MenuLayout.Item("Another Stage Window", source="Window/Best Window Ever")
]),
MenuLayout.Menu("More Cheese", [
MenuLayout.Item("Not A Menu Item", source="No Menu/Worst Window Ever")
])
]
omni.kit.menu.utils.add_layout(menu_layout)
await ui_test.human_delay()
# update checked status (checked) - refreshing window should refresh "Tools" and "More Tools"
example_window_is_ticked = True
omni.kit.menu.utils.refresh_menu_items("Window")
# open menu as items are not refreshed on refresh_menu_items
await refresh_menus()
# verify
verify_menu_checked_items(self, [(ui.Menu, "Tools", True, False, False), (ui.Menu, "More Tools", True, False, False), (ui.Menu, "Window", False, False, False), (ui.MenuItem, "Stage Window", True, True, True), (ui.MenuItem, "Another Stage Window", True, True, True)])
# update checked status (unchecked) - refreshing window should refresh "Tools" and "More Tools"
example_window_is_ticked = False
omni.kit.menu.utils.refresh_menu_items("Window")
# open menu as items are not refreshed on refresh_menu_items
await refresh_menus()
# verify
verify_menu_checked_items(self, [(ui.Menu, "Tools", True, False, False), (ui.Menu, "More Tools", True, False, False), (ui.Menu, "Window", False, False, False), (ui.MenuItem, "Stage Window", True, True, False), (ui.MenuItem, "Another Stage Window", True, True, False)])
# remove layout
omni.kit.menu.utils.remove_layout(menu_layout)
self.assertTrue(omni.kit.menu.utils.get_menu_layout() == [])
# remove menu
omni.kit.menu.utils.remove_menu_items(menu_entry2, "Window")
omni.kit.menu.utils.remove_menu_items(menu_entry1, "Window")
omni.kit.menu.utils.remove_menu_items(menu_placeholder, "Tools")
omni.kit.menu.utils.remove_menu_items(menu_placeholder, "More Tools")
self.assertTrue(omni.kit.menu.utils.get_merged_menus() == {})
async def test_layout_local_source(self):
menu_placeholder = [MenuItemDescription(name="placeholder", show_fn=lambda: False)]
menu_physics = [ MenuItemDescription(name="Physics", sub_menu=[
MenuItemDescription(name="Debug"),
MenuItemDescription(name="Settings"),
MenuItemDescription(name="Demo Scenes"),
MenuItemDescription(name="Test Runner"),
MenuItemDescription(name="Character Controller")]) ]
menu_blast = [ MenuItemDescription(name="Blast", sub_menu=[
MenuItemDescription(name="Settings"),
MenuItemDescription(name="Documentation", sub_menu=[
MenuItemDescription(name="Kit UI"),
MenuItemDescription(name="Programming"),
MenuItemDescription(name="USD Schemas")]) ])]
menu_flow = [ MenuItemDescription(name="Flow", sub_menu=[
MenuItemDescription(name="Presets"),
MenuItemDescription(name="Monitor")]) ]
# add menu
omni.kit.menu.utils.add_menu_items(menu_placeholder, "Window", 90)
omni.kit.menu.utils.add_menu_items(menu_physics, "Window")
omni.kit.menu.utils.add_menu_items(menu_blast, "Window")
omni.kit.menu.utils.add_menu_items(menu_flow, "Window")
await ui_test.human_delay()
# ----------------------------------------------------
# nested layout test
# ----------------------------------------------------
menu_layout = [
MenuLayout.Menu("Window", [
MenuLayout.SubMenu("Simulation", [
MenuLayout.Group("Flow", [
MenuLayout.Item("Presets", source="Window/Flow/Presets"),
MenuLayout.Item("Monitor", source="Window/Flow/Monitor"),
]),
MenuLayout.Group("Blast", [
MenuLayout.Item("Settings", source="Window/Blast/Settings"),
MenuLayout.SubMenu("Documentation", [
MenuLayout.Item("Kit UI", source="Window/Blast/Documentation/Kit UI"),
MenuLayout.Item("Programming", source="Window/Blast/Documentation/Programming"),
MenuLayout.Item("USD Schemas", source="Window/Blast/Documentation/USD Schemas"),
]),
]),
MenuLayout.Group("Physics", [
MenuLayout.Item("Demo Scenes"),
MenuLayout.Item("Settings", source="Window/Physics/Settings"),
MenuLayout.Item("Debug"),
MenuLayout.Item("Test Runner"),
MenuLayout.Item("Character Controller")
]),
]),
# these should not be moved as they are local only
MenuLayout.Item("Demo Scenes", source_search=LayoutSourceSearch.LOCAL_ONLY),
MenuLayout.Item("Settings", source_search=LayoutSourceSearch.LOCAL_ONLY),
MenuLayout.Item("Debug", source_search=LayoutSourceSearch.LOCAL_ONLY),
MenuLayout.Item("Test Runner", source_search=LayoutSourceSearch.LOCAL_ONLY),
MenuLayout.Item("Character Controller", source_search=LayoutSourceSearch.LOCAL_ONLY),
])
]
omni.kit.menu.utils.add_layout(menu_layout)
# verify layout
verify_menu_items(self, [(ui.Menu, "Window", True), (ui.Menu, "Simulation", True), (ui.MenuItem, "placeholder", False), (ui.Menu, "Physics", False), (ui.Menu, "Blast", False), (ui.Menu, "Flow", False), (ui.Separator, "Flow", True), (ui.MenuItem, "Presets", True), (ui.MenuItem, "Monitor", True), (ui.Separator, "Blast", True), (ui.MenuItem, "Settings", True), (ui.Menu, "Documentation", True), (ui.Separator, "Physics", True), (ui.MenuItem, "Demo Scenes", True), (ui.MenuItem, "Settings", True), (ui.MenuItem, "Debug", True), (ui.MenuItem, "Test Runner", True), (ui.MenuItem, "Character Controller", True), (ui.MenuItem, "Kit UI", True), (ui.MenuItem, "Programming", True), (ui.MenuItem, "USD Schemas", True), (ui.Menu, "Documentation", False)])
# remove layout
omni.kit.menu.utils.remove_layout(menu_layout)
self.assertTrue(omni.kit.menu.utils.get_menu_layout() == [])
# remove menu
omni.kit.menu.utils.remove_menu_items(menu_physics, "Window")
omni.kit.menu.utils.remove_menu_items(menu_blast, "Window")
omni.kit.menu.utils.remove_menu_items(menu_flow, "Window")
omni.kit.menu.utils.remove_menu_items(menu_placeholder, "Window")
self.assertTrue(omni.kit.menu.utils.get_merged_menus() == {})
| 13,396 | Python | 55.766949 | 753 | 0.581293 |
omniverse-code/kit/exts/omni.kit.menu.utils/omni/kit/menu/utils/tests/test_right_menus.py | import os
import unittest
import carb
import omni.kit.test
import omni.ui as ui
from typing import Callable, Union
from omni.kit import ui_test
from omni.kit.menu.utils import MenuItemDescription, MenuAlignment
from .utils import verify_menu_items
class TestMenuRightAlignedUtils(omni.kit.test.AsyncTestCase):
async def setUp(self):
pass
async def tearDown(self):
pass
async def test_right_menu(self):
class MenuDelegate(ui.MenuDelegate):
def __init__(self, **kwargs):
super().__init__(**kwargs)
def build_item(self, item: ui.MenuHelper):
super().build_item(item)
def build_status(self, item: ui.MenuHelper):
super().build_status(item)
def build_title(self, item: ui.MenuHelper):
super().build_title(item)
def get_menu_alignment(self):
return MenuAlignment.RIGHT
class MenuDelegateHidden(MenuDelegate):
def update_menu_item(self, menu_item: Union[ui.Menu, ui.MenuItem], menu_refresh: bool):
if isinstance(menu_item, ui.MenuItem):
menu_item.visible = False
elif isinstance(menu_item, ui.Menu):
menu_item.visible = True
class MenuDelegateButton(MenuDelegate):
def build_item(self, item: ui.MenuHelper):
with ui.HStack(width=0):
with ui.VStack(content_clipping=1, width=0):
ui.Button("Button", style={"margin": 0}, clicked_fn=lambda: print("clicked"))
# ----------------------------------------------------
# left aligned menu
# ----------------------------------------------------
submenu_list3 = [ MenuItemDescription(name="SubMenu Item") ]
submenu_list2 = [ MenuItemDescription(name="SubMenu 2", sub_menu=submenu_list3) ]
submenu_list1 = [ MenuItemDescription(name="SubMenu 1", sub_menu=submenu_list2) ]
left_menu_list = [ MenuItemDescription(name="Root Item", sub_menu=submenu_list1) ]
# add menu
omni.kit.menu.utils.add_menu_items(left_menu_list, "SubMenu Test", 99)
verify_menu_items(self, [(ui.Menu, "SubMenu Test", True), (ui.Menu, "Root Item", True), (ui.Menu, "SubMenu 1", True), (ui.Menu, "SubMenu 2", True), (ui.MenuItem, "SubMenu Item", True)])
# refresh and verify
omni.kit.menu.utils.refresh_menu_items("SubMenu Test")
verify_menu_items(self, [(ui.Menu, "SubMenu Test", True), (ui.Menu, "Root Item", True), (ui.Menu, "SubMenu 1", True), (ui.Menu, "SubMenu 2", True), (ui.MenuItem, "SubMenu Item", True)])
# ----------------------------------------------------
# right aligned menu
# ----------------------------------------------------
right_menu_list = [ MenuItemDescription(name="SubMenu Item 1"), MenuItemDescription(name="SubMenu Item 2") ]
right_menu1 = omni.kit.menu.utils.add_menu_items(right_menu_list, "Right Menu Test 1", delegate=MenuDelegate())
right_menu2 = omni.kit.menu.utils.add_menu_items(right_menu_list, "Right Menu Test 2", delegate=MenuDelegate())
right_menu3 = omni.kit.menu.utils.add_menu_items([], name="Empty Menu", delegate=MenuDelegateHidden())
right_menu4 = omni.kit.menu.utils.add_menu_items([], name="Button Menu", delegate=MenuDelegateButton())
# verify
verify_menu_items(self, [(ui.Menu, "SubMenu Test", True), (ui.Spacer, True), (ui.Menu, "Right Menu Test 1", True), (ui.Menu, "Right Menu Test 2", True), (ui.Menu, "Empty Menu", True), (ui.Menu, "Button Menu", True), (ui.Spacer, True), (ui.Menu, "Root Item", True), (ui.Menu, "SubMenu 1", True), (ui.Menu, "SubMenu 2", True), (ui.MenuItem, "SubMenu Item", True), (ui.MenuItem, "SubMenu Item 1", True), (ui.MenuItem, "SubMenu Item 2", True), (ui.MenuItem, "SubMenu Item 1", True), (ui.MenuItem, "SubMenu Item 2", True), (ui.MenuItem, "placeholder", False), (ui.MenuItem, "placeholder", False)], True)
# refresh and verify
omni.kit.menu.utils.refresh_menu_items("Right Menu Test 1")
verify_menu_items(self, [(ui.Menu, "SubMenu Test", True), (ui.Spacer, True), (ui.Menu, "Right Menu Test 1", True), (ui.Menu, "Right Menu Test 2", True), (ui.Menu, "Empty Menu", True), (ui.Menu, "Button Menu", True), (ui.Spacer, True), (ui.Menu, "Root Item", True), (ui.Menu, "SubMenu 1", True), (ui.Menu, "SubMenu 2", True), (ui.MenuItem, "SubMenu Item", True), (ui.MenuItem, "SubMenu Item 1", True), (ui.MenuItem, "SubMenu Item 2", True), (ui.MenuItem, "SubMenu Item 1", True), (ui.MenuItem, "SubMenu Item 2", True), (ui.MenuItem, "placeholder", False), (ui.MenuItem, "placeholder", False)], True)
# remove menus
omni.kit.menu.utils.remove_menu_items(left_menu_list, "SubMenu Test")
omni.kit.menu.utils.remove_menu_items(right_menu1, "Right Menu Test 1")
omni.kit.menu.utils.remove_menu_items(right_menu2, "Right Menu Test 2")
omni.kit.menu.utils.remove_menu_items(right_menu3, "Empty Menu")
omni.kit.menu.utils.remove_menu_items(right_menu4, "Button Menu")
# verify menus removed
self.assertTrue(omni.kit.menu.utils.get_merged_menus() == {})
async def test_multi_delegate_menu(self):
class MenuDelegate(ui.MenuDelegate):
def __init__(self, **kwargs):
super().__init__(**kwargs)
def build_item(self, item: ui.MenuHelper):
super().build_item(item)
def build_status(self, item: ui.MenuHelper):
super().build_status(item)
def build_title(self, item: ui.MenuHelper):
super().build_title(item)
def get_menu_alignment(self):
return MenuAlignment.RIGHT
class MenuDelegateHidden(MenuDelegate):
def update_menu_item(self, menu_item: Union[ui.Menu, ui.MenuItem], menu_refresh: bool):
if isinstance(menu_item, ui.MenuItem):
menu_item.visible = False
elif isinstance(menu_item, ui.Menu):
menu_item.visible = True
class MenuDelegateButton(MenuDelegate):
def build_item(self, item: ui.MenuHelper):
with ui.HStack(width=0):
with ui.VStack(content_clipping=1, width=0):
ui.Button("Button", style={"margin": 0}, clicked_fn=lambda: print("clicked"))
# ----------------------------------------------------
# left aligned menu
# ----------------------------------------------------
submenu_list3 = [ MenuItemDescription(name="SubMenu Item") ]
submenu_list2 = [ MenuItemDescription(name="SubMenu 2", sub_menu=submenu_list3) ]
submenu_list1 = [ MenuItemDescription(name="SubMenu 1", sub_menu=submenu_list2) ]
left_menu_list = [ MenuItemDescription(name="Root Item", sub_menu=submenu_list1) ]
# add menu
omni.kit.menu.utils.add_menu_items(left_menu_list, "SubMenu Test", 99)
verify_menu_items(self, [(ui.Menu, "SubMenu Test", True), (ui.Menu, "Root Item", True), (ui.Menu, "SubMenu 1", True), (ui.Menu, "SubMenu 2", True), (ui.MenuItem, "SubMenu Item", True)])
# refresh and verify
omni.kit.menu.utils.refresh_menu_items("SubMenu Test")
verify_menu_items(self, [(ui.Menu, "SubMenu Test", True), (ui.Menu, "Root Item", True), (ui.Menu, "SubMenu 1", True), (ui.Menu, "SubMenu 2", True), (ui.MenuItem, "SubMenu Item", True)])
# ----------------------------------------------------
# right aligned menu
# ----------------------------------------------------
md = MenuDelegate()
right_menu_list = [ MenuItemDescription(name="SubMenu Item 1"), MenuItemDescription(name="SubMenu Item 2") ]
right_menu1 = omni.kit.menu.utils.add_menu_items(right_menu_list, "Right Menu Test", delegate=md)
right_menu2 = omni.kit.menu.utils.add_menu_items(right_menu_list, "Right Menu Test", delegate=md)
right_menu3 = omni.kit.menu.utils.add_menu_items([], name="Right Menu Test", delegate=MenuDelegateHidden())
right_menu4 = omni.kit.menu.utils.add_menu_items([], name="Right Menu Test", delegate=MenuDelegateButton())
# verify
verify_menu_items(self, [(ui.Menu, "SubMenu Test", True), (ui.Spacer, True), (ui.Menu, "Right Menu Test", True), (ui.Spacer, True), (ui.Menu, "Root Item", True), (ui.Menu, "SubMenu 1", True), (ui.Menu, "SubMenu 2", True), (ui.MenuItem, "SubMenu Item", True), (ui.MenuItem, "SubMenu Item 1", True), (ui.MenuItem, "SubMenu Item 2", True), (ui.MenuItem, "placeholder", False)], True)
# refresh and verify
omni.kit.menu.utils.refresh_menu_items("Right Menu Test")
verify_menu_items(self, [(ui.Menu, "SubMenu Test", True), (ui.Spacer, True), (ui.Menu, "Right Menu Test", True), (ui.Spacer, True), (ui.Menu, "Root Item", True), (ui.Menu, "SubMenu 1", True), (ui.Menu, "SubMenu 2", True), (ui.MenuItem, "SubMenu Item", True), (ui.MenuItem, "SubMenu Item 1", True), (ui.MenuItem, "SubMenu Item 2", True), (ui.MenuItem, "placeholder", False)], True)
# remove menus
omni.kit.menu.utils.remove_menu_items(left_menu_list, "SubMenu Test")
omni.kit.menu.utils.remove_menu_items(right_menu1, "Right Menu Test")
omni.kit.menu.utils.remove_menu_items(right_menu2, "Right Menu Test")
omni.kit.menu.utils.remove_menu_items(right_menu3, "Right Menu Test")
omni.kit.menu.utils.remove_menu_items(right_menu4, "Right Menu Test")
# verify menus removed
self.assertTrue(omni.kit.menu.utils.get_merged_menus() == {})
| 9,703 | Python | 61.606451 | 606 | 0.595589 |
omniverse-code/kit/exts/omni.kit.menu.utils/omni/kit/menu/utils/tests/__init__.py | from .test_menus import *
from .test_menu_layouts import *
from .test_action_mapping import *
from .test_right_menus import *
from .test_debug_menu import *
from .test_menu_icons import *
| 188 | Python | 25.999996 | 34 | 0.75 |
omniverse-code/kit/exts/omni.kit.menu.utils/omni/kit/menu/utils/tests/test_action_mapping.py | import os
import unittest
import carb
import omni.kit.test
from omni.kit import ui_test
from omni.kit.menu.utils import MenuItemDescription
class TestActionMappingMenuUtils(omni.kit.test.AsyncTestCase):
async def setUp(self):
self._menus = [
MenuItemDescription(
name="Test Hotkey Mapping",
glyph="none.svg",
hotkey=(
carb.input.KEYBOARD_MODIFIER_FLAG_CONTROL | carb.input.KEYBOARD_MODIFIER_FLAG_SHIFT,
carb.input.KeyboardInput.EQUAL,
),
)
]
omni.kit.menu.utils.add_menu_items( self._menus, "Test", 99)
async def tearDown(self):
omni.kit.menu.utils.remove_menu_items( self._menus, "Test")
pass
async def wait_for_update(self, usd_context=omni.usd.get_context(), wait_frames=10):
max_loops = 0
while max_loops < wait_frames:
_, files_loaded, total_files = usd_context.get_stage_loading_status()
await omni.kit.app.get_app().next_update_async()
if files_loaded or total_files:
continue
max_loops = max_loops + 1
async def test_action_mapping(self):
import re
mapping_path = "/app/inputBindings/global/Test_Test_Hotkey_Mapping"
menu_widget = ui_test.get_menubar()
widget = menu_widget.find_menu("Test Hotkey Mapping")
settings = carb.settings.get_settings()
await self.wait_for_update(wait_frames=10)
# verify initial value
menu_text = re.sub(r'[^\x00-\x7F]+','', widget.widget.text).replace(" ", "")
self.assertTrue(menu_text == "TestHotkeyMapping")
key_mapping = settings.get(mapping_path)
self.assertTrue(key_mapping == ['Shift + Ctrl + Keyboard::='])
hotkey_text = widget.widget.hotkey_text.replace(" ", "")
self.assertTrue(hotkey_text == "Shift+Ctrl+=")
# set to bad value..
settings.set(mapping_path, "Nothingness")
await self.wait_for_update(wait_frames=10)
hotkey_text = widget.widget.hotkey_text.replace(" ", "")
self.assertTrue(hotkey_text == "")
# set to bad value.. (this crashes kit)
# settings.set(mapping_path, ["Nothingness"])
# await self.wait_for_update(wait_frames=10)
# hotkey_text = widget.widget.hotkey_text.replace(" ", "")
# self.assertTrue(hotkey_text == "")
# set to good value..
settings.set(mapping_path, ["Shift + Ctrl + Keyboard::O"])
await self.wait_for_update(wait_frames=10)
hotkey_text = widget.widget.hotkey_text.replace(" ", "")
self.assertTrue(hotkey_text == "Shift+Ctrl+O")
# set to good value..
settings.set(mapping_path, ["Shift + Ctrl + Keyboard::="])
await self.wait_for_update(wait_frames=10)
hotkey_text = widget.widget.hotkey_text.replace(" ", "")
self.assertTrue(hotkey_text == "Shift+Ctrl+=")
| 3,006 | Python | 37.551282 | 104 | 0.594145 |
omniverse-code/kit/exts/omni.kit.menu.utils/omni/kit/menu/utils/tests/utils.py | import carb
import omni.ui as ui
from omni.kit import ui_test
def verify_menu_items(cls, verify_list, use_menu_spacers: bool=False):
menu_widget = ui_test.get_menubar()
menu_widgets = []
def show_debug():
debug_info = ""
for w in menu_widgets:
if isinstance(w.widget, (ui.Menu, ui.MenuItem, ui.Separator)):
debug_info += f"(ui.{w.widget.__class__.__name__}, \"{w.widget.text.strip()}\", {w.widget.visible}), "
elif isinstance(w.widget, ui.Spacer) and use_menu_spacers:
debug_info += f"(ui.{w.widget.__class__.__name__}, {w.widget.visible}), "
carb.log_warn(f"verify_menu_items [{debug_info[:-2]}] vs {verify_list}")
for w in menu_widget.find_all("**/"):
if isinstance(w.widget, (ui.Menu, ui.MenuItem, ui.Separator)):
menu_widgets.append(w)
elif isinstance(w.widget, ui.Spacer) and use_menu_spacers and w.widget.identifier in ["right_aligned_menus", "right_padding"]:
menu_widgets.append(w)
try:
cls.assertEqual(len(menu_widgets), len(verify_list))
for index, item in enumerate(verify_list):
widget = menu_widgets[index]
cls.assertTrue(isinstance(widget.widget, item[0]), f"menu type error {widget.widget} vs {item[0]}")
if isinstance(widget.widget, (ui.Menu, ui.MenuItem, ui.Separator)):
cls.assertEqual(widget.widget.text.strip(), item[1])
cls.assertEqual(widget.widget.visible, item[2])
elif isinstance(widget.widget, ui.Spacer) and use_menu_spacers and widget.widget.identifier in ["right_aligned_menus", "right_padding"]:
cls.assertEqual(widget.widget.visible, item[1])
except Exception as exc:
show_debug()
raise Exception(exc)
def verify_menu_checked_items(cls, verify_list):
menu_widget = ui_test.get_menubar()
menu_widgets = []
def show_debug():
debug_info = ""
for w in menu_widgets:
if isinstance(w.widget, (ui.Menu, ui.MenuItem)) and w.widget.text.strip() != "placeholder":
debug_info += f"(ui.{w.widget.__class__.__name__}, \"{w.widget.text.strip()}\", {w.widget.visible}, {w.widget.checkable}, {w.widget.checked}), "
carb.log_warn(f"verify_menu_items [{debug_info[:-2]}] vs {verify_list}")
for w in menu_widget.find_all("**/"):
if isinstance(w.widget, (ui.Menu, ui.MenuItem)) and w.widget.text.strip() != "placeholder":
menu_widgets.append(w)
try:
cls.assertEqual(len(menu_widgets), len(verify_list))
for index, item in enumerate(verify_list):
widget = menu_widgets[index]
cls.assertTrue(isinstance(widget.widget, item[0]), f"menu type error {widget.widget} vs {item[0]}")
cls.assertEqual(widget.widget.text.strip(), item[1])
cls.assertEqual(widget.widget.visible, item[2])
cls.assertEqual(widget.widget.checkable, item[3])
cls.assertEqual(widget.widget.checked, item[4])
except Exception as exc:
show_debug()
raise Exception(exc)
| 3,127 | Python | 44.999999 | 160 | 0.610169 |
omniverse-code/kit/exts/omni.kit.menu.utils/omni/kit/menu/utils/tests/test_menu_icons.py | from pathlib import Path
import unittest
import carb
import omni.kit.test
import omni.ui as ui
from omni.kit import ui_test
from omni.kit.menu.utils import MenuItemDescription, MenuLayout
from omni.ui.tests.test_base import OmniUiTest
from omni.kit.test_suite.helpers import get_test_data_path
class TestMenuIcon(OmniUiTest):
async def setUp(self):
pass
async def tearDown(self):
pass
async def test_menu_icon(self):
icon_path = Path(omni.kit.app.get_app().get_extension_manager().get_extension_path_by_module(__name__)).joinpath("data/tests/icons/audio_record.svg")
golden_img_dir = Path(get_test_data_path(__name__, "golden_img"))
submenu_list = [ MenuItemDescription(name="Menu Item", glyph=str(icon_path)) ]
menu_list = [ MenuItemDescription(name="Icon Menu Test", glyph=str(icon_path), sub_menu=submenu_list) ]
omni.kit.menu.utils.add_menu_items(menu_list, "Icon Test", 99)
omni.kit.menu.utils.rebuild_menus()
await ui_test.human_delay(50)
await ui_test.menu_click("Icon Test/Icon Menu Test", human_delay_speed=4)
await ui_test.human_delay(10)
await self.finalize_test(golden_img_dir=golden_img_dir, golden_img_name="test_menu_icon.png", hide_menu_bar=False)
await ui_test.human_delay(50)
omni.kit.menu.utils.remove_menu_items(menu_list, "Icon Test")
self.assertTrue(omni.kit.menu.utils.get_merged_menus() == {})
| 1,461 | Python | 38.513512 | 157 | 0.689938 |
omniverse-code/kit/exts/omni.kit.menu.utils/docs/index.rst | omni.kit.menu.utils
###########################
Menu Utils
.. toctree::
:maxdepth: 1
CHANGELOG
| 109 | reStructuredText | 6.333333 | 27 | 0.458716 |
omniverse-code/kit/exts/omni.kit.search_core/PACKAGE-LICENSES/omni.kit.search_core-LICENSE.md | Copyright (c) 2020, NVIDIA CORPORATION. All rights reserved.
NVIDIA CORPORATION and its licensors retain all intellectual property
and proprietary rights in and to this software, related documentation
and any modifications thereto. Any use, reproduction, disclosure or
distribution of this software and related documentation without an express
license agreement from NVIDIA CORPORATION is strictly prohibited. | 412 | Markdown | 57.999992 | 74 | 0.839806 |
omniverse-code/kit/exts/omni.kit.search_core/config/extension.toml | [package]
# Semantic Versioning is used: https://semver.org/
version = "1.0.2"
# Lists people or organizations that are considered the "authors" of the package.
authors = ["NVIDIA"]
# The title and description fields are primarly for displaying extension info in UI
title = "Search Core Classes"
description="The extension provides the base classes for search and registering search engines."
# Path (relative to the root) or content of readme markdown file for UI.
readme = "docs/README.md"
# URL of the extension source repository.
repository = ""
# Keywords for the extension
keywords = ["search", "filepicker", "content"]
# Location of change log file in target (final) folder of extension, relative to the root.
# More info on writing changelog: https://keepachangelog.com/en/1.0.0/
changelog="docs/CHANGELOG.md"
# Preview image. Folder named "data" automatically goes in git lfs (see .gitattributes file).
preview_image = "data/preview.png"
# Main python module this extension provides, it will be publicly available as "import omni.example.hello".
[[python.module]]
name = "omni.kit.search_core"
| 1,112 | TOML | 34.903225 | 107 | 0.754496 |
omniverse-code/kit/exts/omni.kit.search_core/omni/kit/search_core/__init__.py | # Copyright (c) 2018-2020, NVIDIA CORPORATION. All rights reserved.
#
# NVIDIA CORPORATION and its licensors retain all intellectual property
# and proprietary rights in and to this software, related documentation
# and any modifications thereto. Any use, reproduction, disclosure or
# distribution of this software and related documentation without an express
# license agreement from NVIDIA CORPORATION is strictly prohibited.
#
from .abstract_search_model import AbstractSearchItem
from .abstract_search_model import AbstractSearchModel
from .abstract_search_model import SearchLifetimeObject
from .search_engine_registry import SearchEngineRegistry
| 655 | Python | 49.461535 | 76 | 0.830534 |
omniverse-code/kit/exts/omni.kit.search_core/omni/kit/search_core/search_engine_registry.py | # Copyright (c) 2018-2020, NVIDIA CORPORATION. All rights reserved.
#
# NVIDIA CORPORATION and its licensors retain all intellectual property
# and proprietary rights in and to this software, related documentation
# and any modifications thereto. Any use, reproduction, disclosure or
# distribution of this software and related documentation without an express
# license agreement from NVIDIA CORPORATION is strictly prohibited.
#
from .singleton import Singleton
from omni.kit.widget.nucleus_info import get_instance as get_nucleus
@Singleton
class SearchEngineRegistry:
"""
Singleton that keeps all the search engines. It's used to put custom
search engine to the content browser.
"""
class _Event(set):
"""
A list of callable objects. Calling an instance of this will cause a
call to each item in the list in ascending order by index.
"""
def __call__(self, *args, **kwargs):
"""Called when the instance is “called” as a function"""
# Call all the saved functions
for f in self:
f(*args, **kwargs)
def __repr__(self):
"""
Called by the repr() built-in function to compute the “official”
string representation of an object.
"""
return f"Event({set.__repr__(self)})"
class _EventSubscription:
"""
Event subscription.
_Event has callback while this object exists.
"""
def __init__(self, event, fn):
"""
Save the function, the event, and add the function to the event.
"""
self._fn = fn
self._event = event
event.add(self._fn)
def __del__(self):
"""Called by GC."""
self._event.remove(self._fn)
class _EngineSubscription:
"""
Event subscription.
_Event has callback while this object exists.
"""
def __init__(self, name, model_type):
"""
Save name and type to the list.
"""
self._name = name
SearchEngineRegistry()._engines[self._name] = model_type
SearchEngineRegistry()._on_engines_changed()
def __del__(self):
"""Called by GC."""
del SearchEngineRegistry()._engines[self._name]
SearchEngineRegistry()._on_engines_changed()
def __init__(self):
self._engines = {}
self._on_engines_changed = self._Event()
def register_search_model(self, name, model_type):
"""
Add a new engine to the registry.
name: the name of the engine as it appears in the menu.
model_type: the type derived from AbstractSearchModel. Content
browser will create an object of this type when it needs
a new search.
"""
if name in self._engines:
# TODO: Warning
return
return self._EngineSubscription(name, model_type)
def get_search_names(self):
"""Returns all the search names"""
return list(sorted(self._engines.keys()))
def get_available_search_names(self, server: str):
"""Returns available search names in given server"""
search_names = list(sorted(self._engines.keys()))
available_search_names = []
for name in search_names:
if "Service" not in name or get_nucleus().is_service_available(name, server):
available_search_names.append(name)
return available_search_names
def get_search_model(self, name):
"""Returns the type of derived from AbstractSearchModel for the given name"""
return self._engines.get(name, None)
def subscribe_engines_changed(self, fn):
"""
Add the provided function to engines changed event subscription callbacks.
Return the object that will automatically unsubscribe when destroyed.
"""
return self._EventSubscription(self._on_engines_changed, fn)
| 4,059 | Python | 32.833333 | 89 | 0.598423 |
omniverse-code/kit/exts/omni.kit.search_core/omni/kit/search_core/abstract_search_model.py | # Copyright (c) 2018-2020, NVIDIA CORPORATION. All rights reserved.
#
# NVIDIA CORPORATION and its licensors retain all intellectual property
# and proprietary rights in and to this software, related documentation
# and any modifications thereto. Any use, reproduction, disclosure or
# distribution of this software and related documentation without an express
# license agreement from NVIDIA CORPORATION is strictly prohibited.
#
from datetime import datetime
import abc
class AbstractSearchItem:
"""AbstractSearchItem represents a single file in the file browser."""
@property
def path(self):
"""The full path that goes to usd when Drag and Drop"""
return ""
@property
def name(self):
"""The name as it appears in the widget"""
return ""
@property
def date(self):
# TODO: Grid View needs datatime, but Tree View needs a string. We need to make them the same.
return datetime.now()
@property
def size(self):
# TODO: Grid View needs int, but Tree View needs a string. We need to make them the same.
return 0
@property
def icon(self):
pass
@property
def is_folder(self):
pass
def __getitem__(self, key):
"""Access to methods by text for _RedirectModel"""
return getattr(self, key)
class SearchLifetimeObject(metaclass=abc.ABCMeta):
"""
SearchLifetimeObject encapsulates a callback to be called when a search is finished.
It is the responsibility of the implementers of AbstractSearchModel to get the object
argument and keep it alive until the search is completed if the search runs long.
"""
def __init__(self, callback):
self._callback = callback
def __del__(self):
self.destroy()
def destroy(self):
if self._callback:
self._callback()
self._callback = None
class AbstractSearchModel(metaclass=abc.ABCMeta):
"""
AbstractSearchModel represents the search results. It supports async
mode. If the search engine needs some time to process the request, it can
return an empty list and do a search in async mode. As soon as a result
is ready, the model should call `self._item_changed()`. It will make the
view reload the model. It's also possible to return the search result
with portions.
__init__ is usually called with the named arguments search_text and
current_dir, and optionally a search_lifetime object.
"""
class _Event(set):
"""
A list of callable objects. Calling an instance of this will cause a
call to each item in the list in ascending order by index.
"""
def __call__(self, *args, **kwargs):
"""Called when the instance is “called” as a function"""
# Call all the saved functions
for f in self:
f(*args, **kwargs)
def __repr__(self):
"""
Called by the repr() built-in function to compute the “official”
string representation of an object.
"""
return f"Event({set.__repr__(self)})"
class _EventSubscription:
"""
Event subscription.
_Event has callback while this object exists.
"""
def __init__(self, event, fn):
"""
Save the function, the event, and add the function to the event.
"""
self._fn = fn
self._event = event
event.add(self._fn)
def __del__(self):
"""Called by GC."""
self._event.remove(self._fn)
def __init__(self):
# TODO: begin_edit/end_edit
self.__on_item_changed = self._Event()
@property
@abc.abstractmethod
def items(self):
"""Should be implemented"""
pass
def destroy(self):
"""Called to cancel current search"""
pass
def _item_changed(self, item=None):
"""Call the event object that has the list of functions"""
self.__on_item_changed(item)
def subscribe_item_changed(self, fn):
"""
Return the object that will automatically unsubscribe when destroyed.
"""
return self._EventSubscription(self.__on_item_changed, fn)
| 4,281 | Python | 29.368794 | 102 | 0.619248 |
omniverse-code/kit/exts/omni.kit.search_core/omni/kit/search_core/singleton.py | # Copyright (c) 2018-2020, NVIDIA CORPORATION. All rights reserved.
#
# NVIDIA CORPORATION and its licensors retain all intellectual property
# and proprietary rights in and to this software, related documentation
# and any modifications thereto. Any use, reproduction, disclosure or
# distribution of this software and related documentation without an express
# license agreement from NVIDIA CORPORATION is strictly prohibited.
#
def Singleton(class_):
"""A singleton decorator"""
instances = {}
def getinstance(*args, **kwargs):
if class_ not in instances:
instances[class_] = class_(*args, **kwargs)
return instances[class_]
return getinstance
| 697 | Python | 32.238094 | 76 | 0.725968 |
omniverse-code/kit/exts/omni.kit.search_core/omni/kit/search_core/tests/__init__.py | # Copyright (c) 2021, NVIDIA CORPORATION. All rights reserved.
#
# NVIDIA CORPORATION and its licensors retain all intellectual property
# and proprietary rights in and to this software, related documentation
# and any modifications thereto. Any use, reproduction, disclosure or
# distribution of this software and related documentation without an express
# license agreement from NVIDIA CORPORATION is strictly prohibited.
#
from .search_core_test import TestSearchCore
| 473 | Python | 46.399995 | 76 | 0.811839 |
omniverse-code/kit/exts/omni.kit.search_core/omni/kit/search_core/tests/search_core_test.py | ## Copyright (c) 2021, NVIDIA CORPORATION. All rights reserved.
##
## NVIDIA CORPORATION and its licensors retain all intellectual property
## and proprietary rights in and to this software, related documentation
## and any modifications thereto. Any use, reproduction, disclosure or
## distribution of this software and related documentation without an express
## license agreement from NVIDIA CORPORATION is strictly prohibited.
##
from ..search_engine_registry import SearchEngineRegistry
from ..abstract_search_model import AbstractSearchItem
from ..abstract_search_model import AbstractSearchModel
import omni.kit.test
from unittest.mock import Mock
class TestSearchItem(AbstractSearchItem):
pass
class TestSearchModel(AbstractSearchModel):
running_search = None
def __init__(self, **kwargs):
super().__init__()
self.__items = [TestSearchItem()]
def destroy(self):
self.__items = []
@property
def items(self):
return self.__items
class TestSearchCore(omni.kit.test.AsyncTestCase):
async def test_registry(self):
test_name = "TEST_SEARCH"
self._subscription = SearchEngineRegistry().register_search_model(test_name, TestSearchModel)
self.assertIn(test_name, SearchEngineRegistry().get_search_names())
self.assertIn(test_name, SearchEngineRegistry().get_available_search_names("DummyServer"))
self.assertIs(TestSearchModel, SearchEngineRegistry().get_search_model(test_name))
self._subscription = None
self.assertNotIn(test_name, SearchEngineRegistry().get_search_names())
async def test_event_subscription(self):
mock_callback = Mock()
self._sub = SearchEngineRegistry().subscribe_engines_changed(mock_callback)
self._added_model = SearchEngineRegistry().register_search_model("dummy", TestSearchModel)
mock_callback.assert_called_once()
mock_callback.reset_mock()
self._added_model = None
mock_callback.assert_called_once()
async def test_item_changed_subscription(self):
mock_callback = Mock()
model = TestSearchModel()
self._sub = model.subscribe_item_changed(mock_callback)
model._item_changed()
mock_callback.assert_called_once()
| 2,280 | Python | 32.544117 | 101 | 0.709211 |
omniverse-code/kit/exts/omni.kit.search_core/docs/CHANGELOG.md | # Changelog
This document records all notable changes to ``omni.kit.search_core`` extension.
## [1.0.2] - 2022-11-10
### Removed
- Removed dependency on omni.kit.test
## [1.0.1] - 2022-03-07
### Added
- Added a search lifetime object that can be used for callbacks after search is done to indicate progress.
## [1.0.0] - 2020-10-05
### Added
- Initial model and registry
| 375 | Markdown | 22.499999 | 106 | 0.698667 |
omniverse-code/kit/exts/omni.kit.search_core/docs/README.md | # omni.kit.search_example
## Python Search Core
The example provides search model AbstractSearchModel and search registry
SearchEngineRegistry.
`AbstractSearchModel` represents the search results. It supports async mode. If
the search engine needs some time to process the request, it can return an
empty list and do a search in async mode. As soon as a result is ready, the
model should call `self._item_changed()`. It will make the view reload the
model. It's also possible to return the search result with portions.
`AbstractSearchModel.__init__` is usually called with the named arguments
search_text and current_dir.
`SearchEngineRegistry` keeps all the search engines. It's used to put custom
search engine to the content browser. It provides fast access to search
engines. Any extension that can use the objects derived from
`AbstractSearchModel` can use the search.
| 879 | Markdown | 40.90476 | 79 | 0.798635 |
omniverse-code/kit/exts/omni.graph.bundle.action/PACKAGE-LICENSES/omni.graph.bundle.action-LICENSE.md | Copyright (c) 2020, NVIDIA CORPORATION. All rights reserved.
NVIDIA CORPORATION and its licensors retain all intellectual property
and proprietary rights in and to this software, related documentation
and any modifications thereto. Any use, reproduction, disclosure or
distribution of this software and related documentation without an express
license agreement from NVIDIA CORPORATION is strictly prohibited. | 412 | Markdown | 57.999992 | 74 | 0.839806 |
omniverse-code/kit/exts/omni.graph.bundle.action/config/extension.toml | [package]
# Semantic Versioning is used: https://semver.org/
version = "1.3.0"
# Lists people or organizations that are considered the "authors" of the package.
authors = ["NVIDIA"]
# The title description fields are primarly for displaying extension info in UI
title = "Action Graph Bundle"
description="Load all extensions necessary for using OmniGraph action graphs"
category = "Graph"
feature = true
# URL of the extension source repository.
repository = ""
# Keywords for the extension
keywords = ["kit", "omnigraph", "action"]
# Preview image. Folder named "data" automatically goes in git lfs (see .gitattributes file).
preview_image = "data/preview.png"
# Icon is shown in Extensions window, it is recommended to be square, of size 256x256.
icon = "data/icon.svg"
# Location of change log file in target (final) folder of extension, relative to the root.
changelog="docs/CHANGELOG.md"
# Path (relative to the root) of the main documentation file.
readme = "docs/index.rst"
[dependencies]
"omni.graph" = {}
"omni.graph.action" = {}
"omni.graph.nodes" = {}
"omni.graph.ui" = {}
[[test]]
unreliable = true # OM-51994
waiver = "Empty extension that bundles other extensions"
args = [
"--/app/extensions/registryEnabled=1" # needs to be fixed and removed: OM-49578
]
[documentation]
pages = [
"docs/Overview.md",
"docs/CHANGELOG.md",
]
| 1,365 | TOML | 25.26923 | 93 | 0.721612 |
omniverse-code/kit/exts/omni.graph.bundle.action/docs/CHANGELOG.md | # Changelog
The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/).
## [1.3.0] - 2022-08-11
### Removed
- omni.graph.window.action dependency
## [1.2.0] - 2022-08-04
### Removed
- omni.graph.instancing dependency
## [1.1.1] - 2022-06-21
### Fixed
- Put docs in the README for the extension manager
## [1.1.0] - 2022-05-05
### Removed
- omni.graph.tutorials dependency
## [1.0.0] - 2021-11-18
### Changes
- Created with initial required set of extensions
| 486 | Markdown | 19.291666 | 80 | 0.668724 |
omniverse-code/kit/exts/omni.graph.bundle.action/docs/README.md | # OmniGraph Action Bundle [omni.graph.bundle.action]
Action Graphs are a subset of OmniGraph that control execution flow through event triggers.
Loading this bundled extension is a convenient way to load all of the extensions required for OmniGraph action graphs to run.
For visual editing of Action graphs, see `omni.graph.window.action`.
| 342 | Markdown | 47.999993 | 125 | 0.809942 |
omniverse-code/kit/exts/omni.graph.bundle.action/docs/index.rst | OmniGraph Action Graph Bundle
#############################
.. tabularcolumns:: |L|R|
.. csv-table::
:width: 100%
**Extension**: omni.graph.bundle.action,**Documentation Generated**: |today|
Action Graphs are a subset of OmniGraph that control execution flow through event triggers.
Loading this bundled extension is a convenient way to load all of the extensions required to use the OmniGraph
action graphs.
Extensions Loaded
=================
- omni.graph
- omni.graph.action
- omni.graph.nodes
- omni.graph.ui
- omni.graph.window.action
.. toctree::
:maxdepth: 1
CHANGELOG
| 596 | reStructuredText | 20.321428 | 110 | 0.682886 |
omniverse-code/kit/exts/omni.graph.bundle.action/docs/Overview.md | # OmniGraph Action Graph Bundle
```{csv-table}
**Extension**: omni.graph.bundle.action,**Documentation Generated**: {sub-ref}`today`
```
Action Graphs are a subset of OmniGraph that control execution flow through event triggers.
Loading this bundled extension is a convenient way to load all of the extensions required to use the OmniGraph
action graphs.
## Extensions Loaded
- omni.graph
- omni.graph.action
- omni.graph.nodes
- omni.graph.ui
- omni.graph.window.action | 474 | Markdown | 26.941175 | 110 | 0.767932 |
omniverse-code/kit/exts/omni.graph.test/PACKAGE-LICENSES/omni.graph.test-LICENSE.md | Copyright (c) 2020, NVIDIA CORPORATION. All rights reserved.
NVIDIA CORPORATION and its licensors retain all intellectual property
and proprietary rights in and to this software, related documentation
and any modifications thereto. Any use, reproduction, disclosure or
distribution of this software and related documentation without an express
license agreement from NVIDIA CORPORATION is strictly prohibited. | 412 | Markdown | 57.999992 | 74 | 0.839806 |
omniverse-code/kit/exts/omni.graph.test/config/extension.toml | [package]
version = "0.18.0"
title = "OmniGraph Regression Testing"
category = "Graph"
readme = "docs/README.md"
changelog = "docs/CHANGELOG.md"
description = "Contains test scripts and files used to test the OmniGraph extensions where the tests cannot live in a single extension."
repository = ""
keywords = ["kit", "omnigraph", "tests"]
# Main module for the Python interface
[[python.module]]
name = "omni.graph.test"
[[native.plugin]]
path = "bin/*.plugin"
recursive = false
# Watch the .ogn files for hot reloading (only works for Python files)
[fswatcher.patterns]
include = ["*.ogn", "*.py"]
exclude = ["Ogn*Database.py"]
# Python array data uses numpy as its format
[python.pipapi]
requirements = ["numpy"]
# Other extensions that need to load in order for this one to work
[dependencies]
"omni.graph" = {}
"omni.graph.tools" = {}
"omni.kit.pipapi" = {}
"omni.graph.examples.cpp" = {}
"omni.graph.examples.python" = {}
"omni.graph.nodes" = {}
"omni.graph.tutorials" = {}
"omni.graph.action" = {}
"omni.graph.scriptnode" = {}
"omni.inspect" = {}
"omni.usd" = {}
[[test]]
timeout = 600
stdoutFailPatterns.exclude = [
# Exclude carb.events leak that only shows up locally
"*[Error] [carb.events.plugin]*PooledAllocator*",
# Exclude messages which say they should be ignored
"*Ignore this error/warning*",
]
pythonTests.unreliable = [
# "*test_graph_load", # OM-53608
# "*test_hashability", # OM-53608
# "*test_rename_deformer", # OM-53608
"*test_import_time_sampled_data", # OM-58596
# "*test_import_time_samples", # OM-61324
"*test_reparent_graph", # OM-58852
"*test_simple_rename", # OM-58852
"*test_copy_on_write", # OM-58586
"*test_reparent_fabric", # OM-63175
]
[documentation]
pages = [
"docs/Overview.md",
"docs/CHANGELOG.md",
]
| 1,809 | TOML | 25.617647 | 136 | 0.671089 |
omniverse-code/kit/exts/omni.graph.test/omni/graph/test/__init__.py | """There is no public API to this module."""
__all__ = []
from ._impl.extension import _PublicExtension # noqa: F401
| 119 | Python | 22.999995 | 59 | 0.663866 |
omniverse-code/kit/exts/omni.graph.test/omni/graph/test/ogn/OgnTestDataModelDatabase.py | """Support for simplified access to data on nodes of type omni.graph.test.TestDataModel
Helper node that allows to test that core features of datamodel are working as expected (CoW, DataStealing, ...)
"""
import carb
import numpy
import carb
import omni.graph.core as og
import omni.graph.core._omni_graph_core as _og
import omni.graph.tools.ogn as ogn
class OgnTestDataModelDatabase(og.Database):
"""Helper class providing simplified access to data on nodes of type omni.graph.test.TestDataModel
Class Members:
node: Node being evaluated
Attribute Value Properties:
Inputs:
inputs.arrayShouldMatch
inputs.attrib
inputs.bundleArraysThatShouldDiffer
inputs.bundleShouldMatch
inputs.mutArray
inputs.mutBundle
inputs.mutateArray
inputs.refArray
inputs.refBundle
Outputs:
outputs.array
outputs.bundle
"""
# Imprint the generator and target ABI versions in the file for JIT generation
GENERATOR_VERSION = (1, 41, 3)
TARGET_VERSION = (2, 139, 12)
# This is an internal object that provides per-class storage of a per-node data dictionary
PER_NODE_DATA = {}
# This is an internal object that describes unchanging attributes in a generic way
# The values in this list are in no particular order, as a per-attribute tuple
# Name, Type, ExtendedTypeIndex, UiName, Description, Metadata,
# Is_Required, DefaultValue, Is_Deprecated, DeprecationMsg
# You should not need to access any of this data directly, use the defined database interfaces
INTERFACE = og.Database._get_interface([
('inputs:arrayShouldMatch', 'bool', 0, 'Array should match', 'Whether or not the input arrays should be the same one one', {ogn.MetadataKeys.DEFAULT: 'true'}, True, True, False, ''),
('inputs:attrib', 'token', 0, 'Attrib to mutate', 'Attribute to mutate in the bundle', {}, True, "", False, ''),
('inputs:bundleArraysThatShouldDiffer', 'int', 0, 'Number of != arrays in bundles', 'The number of arrays attribute in the input bundles that should differs', {ogn.MetadataKeys.DEFAULT: '0'}, True, 0, False, ''),
('inputs:bundleShouldMatch', 'bool', 0, 'Bundles should match', 'Whether or not the input bundles should be the same one', {ogn.MetadataKeys.DEFAULT: 'true'}, True, True, False, ''),
('inputs:mutArray', 'point3f[]', 0, 'In array', 'Array meant to be mutated', {}, True, [], False, ''),
('inputs:mutBundle', 'bundle', 0, 'In bundle', 'Bundle meant to be mutated (or not)', {}, True, None, False, ''),
('inputs:mutateArray', 'bool', 0, 'Mutate array', 'Whether or not to mutate the array or just passthrough', {ogn.MetadataKeys.DEFAULT: 'false'}, True, False, False, ''),
('inputs:refArray', 'point3f[]', 0, 'Ref array', 'A reference array used as a point of comparaison', {}, True, [], False, ''),
('inputs:refBundle', 'bundle', 0, 'Ref bundle', 'Reference Bundle used as a point of comparaison', {}, True, None, False, ''),
('outputs:array', 'point3f[]', 0, 'Output array', 'The outputed array', {}, True, None, False, ''),
('outputs:bundle', 'bundle', 0, 'Output bundle', 'The outputed bundle', {}, True, None, False, ''),
])
@classmethod
def _populate_role_data(cls):
"""Populate a role structure with the non-default roles on this node type"""
role_data = super()._populate_role_data()
role_data.inputs.mutArray = og.AttributeRole.POSITION
role_data.inputs.mutBundle = og.AttributeRole.BUNDLE
role_data.inputs.refArray = og.AttributeRole.POSITION
role_data.inputs.refBundle = og.AttributeRole.BUNDLE
role_data.outputs.array = og.AttributeRole.POSITION
role_data.outputs.bundle = og.AttributeRole.BUNDLE
return role_data
class ValuesForInputs(og.DynamicAttributeAccess):
LOCAL_PROPERTY_NAMES = { }
"""Helper class that creates natural hierarchical access to input attributes"""
def __init__(self, node: og.Node, attributes, dynamic_attributes: og.DynamicAttributeInterface):
"""Initialize simplified access for the attribute data"""
context = node.get_graph().get_default_graph_context()
super().__init__(context, node, attributes, dynamic_attributes)
self.__bundles = og.BundleContainer(context, node, attributes, [], read_only=True, gpu_ptr_kinds={})
self._batchedReadAttributes = []
self._batchedReadValues = []
@property
def arrayShouldMatch(self):
data_view = og.AttributeValueHelper(self._attributes.arrayShouldMatch)
return data_view.get()
@arrayShouldMatch.setter
def arrayShouldMatch(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.arrayShouldMatch)
data_view = og.AttributeValueHelper(self._attributes.arrayShouldMatch)
data_view.set(value)
@property
def attrib(self):
data_view = og.AttributeValueHelper(self._attributes.attrib)
return data_view.get()
@attrib.setter
def attrib(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.attrib)
data_view = og.AttributeValueHelper(self._attributes.attrib)
data_view.set(value)
@property
def bundleArraysThatShouldDiffer(self):
data_view = og.AttributeValueHelper(self._attributes.bundleArraysThatShouldDiffer)
return data_view.get()
@bundleArraysThatShouldDiffer.setter
def bundleArraysThatShouldDiffer(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.bundleArraysThatShouldDiffer)
data_view = og.AttributeValueHelper(self._attributes.bundleArraysThatShouldDiffer)
data_view.set(value)
@property
def bundleShouldMatch(self):
data_view = og.AttributeValueHelper(self._attributes.bundleShouldMatch)
return data_view.get()
@bundleShouldMatch.setter
def bundleShouldMatch(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.bundleShouldMatch)
data_view = og.AttributeValueHelper(self._attributes.bundleShouldMatch)
data_view.set(value)
@property
def mutArray(self):
data_view = og.AttributeValueHelper(self._attributes.mutArray)
return data_view.get()
@mutArray.setter
def mutArray(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.mutArray)
data_view = og.AttributeValueHelper(self._attributes.mutArray)
data_view.set(value)
self.mutArray_size = data_view.get_array_size()
@property
def mutBundle(self) -> og.BundleContents:
"""Get the bundle wrapper class for the attribute inputs.mutBundle"""
return self.__bundles.mutBundle
@property
def mutateArray(self):
data_view = og.AttributeValueHelper(self._attributes.mutateArray)
return data_view.get()
@mutateArray.setter
def mutateArray(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.mutateArray)
data_view = og.AttributeValueHelper(self._attributes.mutateArray)
data_view.set(value)
@property
def refArray(self):
data_view = og.AttributeValueHelper(self._attributes.refArray)
return data_view.get()
@refArray.setter
def refArray(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.refArray)
data_view = og.AttributeValueHelper(self._attributes.refArray)
data_view.set(value)
self.refArray_size = data_view.get_array_size()
@property
def refBundle(self) -> og.BundleContents:
"""Get the bundle wrapper class for the attribute inputs.refBundle"""
return self.__bundles.refBundle
def _prefetch(self):
readAttributes = self._batchedReadAttributes
newValues = _og._prefetch_input_attributes_data(readAttributes)
if len(readAttributes) == len(newValues):
self._batchedReadValues = newValues
class ValuesForOutputs(og.DynamicAttributeAccess):
LOCAL_PROPERTY_NAMES = { }
"""Helper class that creates natural hierarchical access to output attributes"""
def __init__(self, node: og.Node, attributes, dynamic_attributes: og.DynamicAttributeInterface):
"""Initialize simplified access for the attribute data"""
context = node.get_graph().get_default_graph_context()
super().__init__(context, node, attributes, dynamic_attributes)
self.__bundles = og.BundleContainer(context, node, attributes, [], read_only=False, gpu_ptr_kinds={})
self.array_size = None
self._batchedWriteValues = { }
@property
def array(self):
data_view = og.AttributeValueHelper(self._attributes.array)
return data_view.get(reserved_element_count=self.array_size)
@array.setter
def array(self, value):
data_view = og.AttributeValueHelper(self._attributes.array)
data_view.set(value)
self.array_size = data_view.get_array_size()
@property
def bundle(self) -> og.BundleContents:
"""Get the bundle wrapper class for the attribute outputs.bundle"""
return self.__bundles.bundle
@bundle.setter
def bundle(self, bundle: og.BundleContents):
"""Overwrite the bundle attribute outputs.bundle with a new bundle"""
if not isinstance(bundle, og.BundleContents):
carb.log_error("Only bundle attributes can be assigned to another bundle attribute")
self.__bundles.bundle.bundle = bundle
def _commit(self):
_og._commit_output_attributes_data(self._batchedWriteValues)
self._batchedWriteValues = { }
class ValuesForState(og.DynamicAttributeAccess):
"""Helper class that creates natural hierarchical access to state attributes"""
def __init__(self, node: og.Node, attributes, dynamic_attributes: og.DynamicAttributeInterface):
"""Initialize simplified access for the attribute data"""
context = node.get_graph().get_default_graph_context()
super().__init__(context, node, attributes, dynamic_attributes)
def __init__(self, node):
super().__init__(node)
dynamic_attributes = self.dynamic_attribute_data(node, og.AttributePortType.ATTRIBUTE_PORT_TYPE_INPUT)
self.inputs = OgnTestDataModelDatabase.ValuesForInputs(node, self.attributes.inputs, dynamic_attributes)
dynamic_attributes = self.dynamic_attribute_data(node, og.AttributePortType.ATTRIBUTE_PORT_TYPE_OUTPUT)
self.outputs = OgnTestDataModelDatabase.ValuesForOutputs(node, self.attributes.outputs, dynamic_attributes)
dynamic_attributes = self.dynamic_attribute_data(node, og.AttributePortType.ATTRIBUTE_PORT_TYPE_STATE)
self.state = OgnTestDataModelDatabase.ValuesForState(node, self.attributes.state, dynamic_attributes)
| 11,607 | Python | 46.966942 | 220 | 0.649091 |
omniverse-code/kit/exts/omni.graph.test/omni/graph/test/ogn/OgnTestGatherDatabase.py | """Support for simplified access to data on nodes of type omni.graph.test.TestGather
Test node to test out the effects of vectorization.
"""
import omni.graph.core as og
import omni.graph.core._omni_graph_core as _og
import omni.graph.tools.ogn as ogn
import carb
import numpy
class OgnTestGatherDatabase(og.Database):
"""Helper class providing simplified access to data on nodes of type omni.graph.test.TestGather
Class Members:
node: Node being evaluated
Attribute Value Properties:
Inputs:
inputs.base_name
inputs.num_instances
Outputs:
outputs.gathered_paths
outputs.rotations
"""
# This is an internal object that provides per-class storage of a per-node data dictionary
PER_NODE_DATA = {}
# This is an internal object that describes unchanging attributes in a generic way
# The values in this list are in no particular order, as a per-attribute tuple
# Name, Type, ExtendedTypeIndex, UiName, Description, Metadata,
# Is_Required, DefaultValue, Is_Deprecated, DeprecationMsg
# You should not need to access any of this data directly, use the defined database interfaces
INTERFACE = og.Database._get_interface([
('inputs:base_name', 'token', 0, None, 'The base name of the pattern to match', {ogn.MetadataKeys.DEFAULT: '""'}, True, '', False, ''),
('inputs:num_instances', 'int', 0, None, 'How many instances are involved', {ogn.MetadataKeys.DEFAULT: '1'}, True, 1, False, ''),
('outputs:gathered_paths', 'token[]', 0, None, 'The paths of the gathered objects', {ogn.MetadataKeys.DEFAULT: '[]'}, True, [], False, ''),
('outputs:rotations', 'double3[]', 0, None, 'The rotations of the gathered points', {ogn.MetadataKeys.DEFAULT: '[]'}, True, [], False, ''),
])
class ValuesForInputs(og.DynamicAttributeAccess):
LOCAL_PROPERTY_NAMES = {"base_name", "num_instances", "_setting_locked", "_batchedReadAttributes", "_batchedReadValues"}
"""Helper class that creates natural hierarchical access to input attributes"""
def __init__(self, node: og.Node, attributes, dynamic_attributes: og.DynamicAttributeInterface):
"""Initialize simplified access for the attribute data"""
context = node.get_graph().get_default_graph_context()
super().__init__(context, node, attributes, dynamic_attributes)
self._batchedReadAttributes = [self._attributes.base_name, self._attributes.num_instances]
self._batchedReadValues = ["", 1]
@property
def base_name(self):
return self._batchedReadValues[0]
@base_name.setter
def base_name(self, value):
self._batchedReadValues[0] = value
@property
def num_instances(self):
return self._batchedReadValues[1]
@num_instances.setter
def num_instances(self, value):
self._batchedReadValues[1] = value
def __getattr__(self, item: str):
if item in self.LOCAL_PROPERTY_NAMES:
return object.__getattribute__(self, item)
else:
return super().__getattr__(item)
def __setattr__(self, item: str, new_value):
if item in self.LOCAL_PROPERTY_NAMES:
object.__setattr__(self, item, new_value)
else:
super().__setattr__(item, new_value)
def _prefetch(self):
readAttributes = self._batchedReadAttributes
newValues = _og._prefetch_input_attributes_data(readAttributes)
if len(readAttributes) == len(newValues):
self._batchedReadValues = newValues
class ValuesForOutputs(og.DynamicAttributeAccess):
LOCAL_PROPERTY_NAMES = { }
"""Helper class that creates natural hierarchical access to output attributes"""
def __init__(self, node: og.Node, attributes, dynamic_attributes: og.DynamicAttributeInterface):
"""Initialize simplified access for the attribute data"""
context = node.get_graph().get_default_graph_context()
super().__init__(context, node, attributes, dynamic_attributes)
self.gathered_paths_size = 0
self.rotations_size = 0
self._batchedWriteValues = { }
@property
def gathered_paths(self):
data_view = og.AttributeValueHelper(self._attributes.gathered_paths)
return data_view.get(reserved_element_count=self.gathered_paths_size)
@gathered_paths.setter
def gathered_paths(self, value):
data_view = og.AttributeValueHelper(self._attributes.gathered_paths)
data_view.set(value)
self.gathered_paths_size = data_view.get_array_size()
@property
def rotations(self):
data_view = og.AttributeValueHelper(self._attributes.rotations)
return data_view.get(reserved_element_count=self.rotations_size)
@rotations.setter
def rotations(self, value):
data_view = og.AttributeValueHelper(self._attributes.rotations)
data_view.set(value)
self.rotations_size = data_view.get_array_size()
def _commit(self):
_og._commit_output_attributes_data(self._batchedWriteValues)
self._batchedWriteValues = { }
class ValuesForState(og.DynamicAttributeAccess):
"""Helper class that creates natural hierarchical access to state attributes"""
def __init__(self, node: og.Node, attributes, dynamic_attributes: og.DynamicAttributeInterface):
"""Initialize simplified access for the attribute data"""
context = node.get_graph().get_default_graph_context()
super().__init__(context, node, attributes, dynamic_attributes)
def __init__(self, node):
super().__init__(node)
dynamic_attributes = self.dynamic_attribute_data(node, og.AttributePortType.ATTRIBUTE_PORT_TYPE_INPUT)
self.inputs = OgnTestGatherDatabase.ValuesForInputs(node, self.attributes.inputs, dynamic_attributes)
dynamic_attributes = self.dynamic_attribute_data(node, og.AttributePortType.ATTRIBUTE_PORT_TYPE_OUTPUT)
self.outputs = OgnTestGatherDatabase.ValuesForOutputs(node, self.attributes.outputs, dynamic_attributes)
dynamic_attributes = self.dynamic_attribute_data(node, og.AttributePortType.ATTRIBUTE_PORT_TYPE_STATE)
self.state = OgnTestGatherDatabase.ValuesForState(node, self.attributes.state, dynamic_attributes)
| 6,560 | Python | 49.083969 | 147 | 0.653506 |
omniverse-code/kit/exts/omni.graph.test/omni/graph/test/ogn/OgnBundleProducerDatabase.py | """Support for simplified access to data on nodes of type omni.graph.test.BundleProducer
Node that produces output bundle for change tracking
"""
import carb
import carb
import omni.graph.core as og
import omni.graph.core._omni_graph_core as _og
import omni.graph.tools.ogn as ogn
class OgnBundleProducerDatabase(og.Database):
"""Helper class providing simplified access to data on nodes of type omni.graph.test.BundleProducer
Class Members:
node: Node being evaluated
Attribute Value Properties:
Outputs:
outputs.bundle
"""
# Imprint the generator and target ABI versions in the file for JIT generation
GENERATOR_VERSION = (1, 41, 3)
TARGET_VERSION = (2, 139, 12)
# This is an internal object that provides per-class storage of a per-node data dictionary
PER_NODE_DATA = {}
# This is an internal object that describes unchanging attributes in a generic way
# The values in this list are in no particular order, as a per-attribute tuple
# Name, Type, ExtendedTypeIndex, UiName, Description, Metadata,
# Is_Required, DefaultValue, Is_Deprecated, DeprecationMsg
# You should not need to access any of this data directly, use the defined database interfaces
INTERFACE = og.Database._get_interface([
('outputs:bundle', 'bundle', 0, None, 'Output Bundle', {}, True, None, False, ''),
])
@classmethod
def _populate_role_data(cls):
"""Populate a role structure with the non-default roles on this node type"""
role_data = super()._populate_role_data()
role_data.outputs.bundle = og.AttributeRole.BUNDLE
return role_data
class ValuesForInputs(og.DynamicAttributeAccess):
LOCAL_PROPERTY_NAMES = { }
"""Helper class that creates natural hierarchical access to input attributes"""
def __init__(self, node: og.Node, attributes, dynamic_attributes: og.DynamicAttributeInterface):
"""Initialize simplified access for the attribute data"""
context = node.get_graph().get_default_graph_context()
super().__init__(context, node, attributes, dynamic_attributes)
self._batchedReadAttributes = []
self._batchedReadValues = []
def _prefetch(self):
readAttributes = self._batchedReadAttributes
newValues = _og._prefetch_input_attributes_data(readAttributes)
if len(readAttributes) == len(newValues):
self._batchedReadValues = newValues
class ValuesForOutputs(og.DynamicAttributeAccess):
LOCAL_PROPERTY_NAMES = { }
"""Helper class that creates natural hierarchical access to output attributes"""
def __init__(self, node: og.Node, attributes, dynamic_attributes: og.DynamicAttributeInterface):
"""Initialize simplified access for the attribute data"""
context = node.get_graph().get_default_graph_context()
super().__init__(context, node, attributes, dynamic_attributes)
self.__bundles = og.BundleContainer(context, node, attributes, [], read_only=False, gpu_ptr_kinds={})
self._batchedWriteValues = { }
@property
def bundle(self) -> og.BundleContents:
"""Get the bundle wrapper class for the attribute outputs.bundle"""
return self.__bundles.bundle
@bundle.setter
def bundle(self, bundle: og.BundleContents):
"""Overwrite the bundle attribute outputs.bundle with a new bundle"""
if not isinstance(bundle, og.BundleContents):
carb.log_error("Only bundle attributes can be assigned to another bundle attribute")
self.__bundles.bundle.bundle = bundle
def _commit(self):
_og._commit_output_attributes_data(self._batchedWriteValues)
self._batchedWriteValues = { }
class ValuesForState(og.DynamicAttributeAccess):
"""Helper class that creates natural hierarchical access to state attributes"""
def __init__(self, node: og.Node, attributes, dynamic_attributes: og.DynamicAttributeInterface):
"""Initialize simplified access for the attribute data"""
context = node.get_graph().get_default_graph_context()
super().__init__(context, node, attributes, dynamic_attributes)
def __init__(self, node):
super().__init__(node)
dynamic_attributes = self.dynamic_attribute_data(node, og.AttributePortType.ATTRIBUTE_PORT_TYPE_INPUT)
self.inputs = OgnBundleProducerDatabase.ValuesForInputs(node, self.attributes.inputs, dynamic_attributes)
dynamic_attributes = self.dynamic_attribute_data(node, og.AttributePortType.ATTRIBUTE_PORT_TYPE_OUTPUT)
self.outputs = OgnBundleProducerDatabase.ValuesForOutputs(node, self.attributes.outputs, dynamic_attributes)
dynamic_attributes = self.dynamic_attribute_data(node, og.AttributePortType.ATTRIBUTE_PORT_TYPE_STATE)
self.state = OgnBundleProducerDatabase.ValuesForState(node, self.attributes.state, dynamic_attributes)
| 5,075 | Python | 46.886792 | 116 | 0.680985 |
omniverse-code/kit/exts/omni.graph.test/omni/graph/test/ogn/OgnBundleChildProducerPyDatabase.py | """Support for simplified access to data on nodes of type omni.graph.test.BundleChildProducerPy
Produces child bundle for bundle child consumer
"""
import carb
import sys
import traceback
import carb
import omni.graph.core as og
import omni.graph.core._omni_graph_core as _og
import omni.graph.tools.ogn as ogn
class OgnBundleChildProducerPyDatabase(og.Database):
"""Helper class providing simplified access to data on nodes of type omni.graph.test.BundleChildProducerPy
Class Members:
node: Node being evaluated
Attribute Value Properties:
Inputs:
inputs.bundle
Outputs:
outputs.bundle
outputs.numChildren
"""
# Imprint the generator and target ABI versions in the file for JIT generation
GENERATOR_VERSION = (1, 41, 3)
TARGET_VERSION = (2, 139, 12)
# This is an internal object that provides per-class storage of a per-node data dictionary
PER_NODE_DATA = {}
# This is an internal object that describes unchanging attributes in a generic way
# The values in this list are in no particular order, as a per-attribute tuple
# Name, Type, ExtendedTypeIndex, UiName, Description, Metadata,
# Is_Required, DefaultValue, Is_Deprecated, DeprecationMsg
# You should not need to access any of this data directly, use the defined database interfaces
INTERFACE = og.Database._get_interface([
('inputs:bundle', 'bundle', 0, None, 'Input Bundle', {}, True, None, False, ''),
('outputs:bundle', 'bundle', 0, None, 'Output Bundle', {}, True, None, False, ''),
('outputs:numChildren', 'int', 0, None, 'Number of children', {ogn.MetadataKeys.DEFAULT: '0'}, True, 0, False, ''),
])
@classmethod
def _populate_role_data(cls):
"""Populate a role structure with the non-default roles on this node type"""
role_data = super()._populate_role_data()
role_data.inputs.bundle = og.AttributeRole.BUNDLE
role_data.outputs.bundle = og.AttributeRole.BUNDLE
return role_data
class ValuesForInputs(og.DynamicAttributeAccess):
LOCAL_PROPERTY_NAMES = { }
"""Helper class that creates natural hierarchical access to input attributes"""
def __init__(self, node: og.Node, attributes, dynamic_attributes: og.DynamicAttributeInterface):
"""Initialize simplified access for the attribute data"""
context = node.get_graph().get_default_graph_context()
super().__init__(context, node, attributes, dynamic_attributes)
self.__bundles = og.BundleContainer(context, node, attributes, [], read_only=True, gpu_ptr_kinds={})
self._batchedReadAttributes = []
self._batchedReadValues = []
@property
def bundle(self) -> og.BundleContents:
"""Get the bundle wrapper class for the attribute inputs.bundle"""
return self.__bundles.bundle
def _prefetch(self):
readAttributes = self._batchedReadAttributes
newValues = _og._prefetch_input_attributes_data(readAttributes)
if len(readAttributes) == len(newValues):
self._batchedReadValues = newValues
class ValuesForOutputs(og.DynamicAttributeAccess):
LOCAL_PROPERTY_NAMES = {"numChildren", "_batchedWriteValues"}
"""Helper class that creates natural hierarchical access to output attributes"""
def __init__(self, node: og.Node, attributes, dynamic_attributes: og.DynamicAttributeInterface):
"""Initialize simplified access for the attribute data"""
context = node.get_graph().get_default_graph_context()
super().__init__(context, node, attributes, dynamic_attributes)
self.__bundles = og.BundleContainer(context, node, attributes, [], read_only=False, gpu_ptr_kinds={})
self._batchedWriteValues = { }
@property
def bundle(self) -> og.BundleContents:
"""Get the bundle wrapper class for the attribute outputs.bundle"""
return self.__bundles.bundle
@bundle.setter
def bundle(self, bundle: og.BundleContents):
"""Overwrite the bundle attribute outputs.bundle with a new bundle"""
if not isinstance(bundle, og.BundleContents):
carb.log_error("Only bundle attributes can be assigned to another bundle attribute")
self.__bundles.bundle.bundle = bundle
@property
def numChildren(self):
value = self._batchedWriteValues.get(self._attributes.numChildren)
if value:
return value
else:
data_view = og.AttributeValueHelper(self._attributes.numChildren)
return data_view.get()
@numChildren.setter
def numChildren(self, value):
self._batchedWriteValues[self._attributes.numChildren] = value
def __getattr__(self, item: str):
if item in self.LOCAL_PROPERTY_NAMES:
return object.__getattribute__(self, item)
else:
return super().__getattr__(item)
def __setattr__(self, item: str, new_value):
if item in self.LOCAL_PROPERTY_NAMES:
object.__setattr__(self, item, new_value)
else:
super().__setattr__(item, new_value)
def _commit(self):
_og._commit_output_attributes_data(self._batchedWriteValues)
self._batchedWriteValues = { }
class ValuesForState(og.DynamicAttributeAccess):
"""Helper class that creates natural hierarchical access to state attributes"""
def __init__(self, node: og.Node, attributes, dynamic_attributes: og.DynamicAttributeInterface):
"""Initialize simplified access for the attribute data"""
context = node.get_graph().get_default_graph_context()
super().__init__(context, node, attributes, dynamic_attributes)
def __init__(self, node):
super().__init__(node)
dynamic_attributes = self.dynamic_attribute_data(node, og.AttributePortType.ATTRIBUTE_PORT_TYPE_INPUT)
self.inputs = OgnBundleChildProducerPyDatabase.ValuesForInputs(node, self.attributes.inputs, dynamic_attributes)
dynamic_attributes = self.dynamic_attribute_data(node, og.AttributePortType.ATTRIBUTE_PORT_TYPE_OUTPUT)
self.outputs = OgnBundleChildProducerPyDatabase.ValuesForOutputs(node, self.attributes.outputs, dynamic_attributes)
dynamic_attributes = self.dynamic_attribute_data(node, og.AttributePortType.ATTRIBUTE_PORT_TYPE_STATE)
self.state = OgnBundleChildProducerPyDatabase.ValuesForState(node, self.attributes.state, dynamic_attributes)
class abi:
"""Class defining the ABI interface for the node type"""
@staticmethod
def get_node_type():
get_node_type_function = getattr(OgnBundleChildProducerPyDatabase.NODE_TYPE_CLASS, 'get_node_type', None)
if callable(get_node_type_function):
return get_node_type_function()
return 'omni.graph.test.BundleChildProducerPy'
@staticmethod
def compute(context, node):
def database_valid():
if not db.inputs.bundle.valid:
db.log_warning('Required bundle inputs.bundle is invalid or not connected, compute skipped')
return False
if not db.outputs.bundle.valid:
db.log_error('Required bundle outputs.bundle is invalid, compute skipped')
return False
return True
try:
per_node_data = OgnBundleChildProducerPyDatabase.PER_NODE_DATA[node.node_id()]
db = per_node_data.get('_db')
if db is None:
db = OgnBundleChildProducerPyDatabase(node)
per_node_data['_db'] = db
if not database_valid():
per_node_data['_db'] = None
return False
except:
db = OgnBundleChildProducerPyDatabase(node)
try:
compute_function = getattr(OgnBundleChildProducerPyDatabase.NODE_TYPE_CLASS, 'compute', None)
if callable(compute_function) and compute_function.__code__.co_argcount > 1:
return compute_function(context, node)
db.inputs._prefetch()
db.inputs._setting_locked = True
with og.in_compute():
return OgnBundleChildProducerPyDatabase.NODE_TYPE_CLASS.compute(db)
except Exception as error:
stack_trace = "".join(traceback.format_tb(sys.exc_info()[2].tb_next))
db.log_error(f'Assertion raised in compute - {error}\n{stack_trace}', add_context=False)
finally:
db.inputs._setting_locked = False
db.outputs._commit()
return False
@staticmethod
def initialize(context, node):
OgnBundleChildProducerPyDatabase._initialize_per_node_data(node)
initialize_function = getattr(OgnBundleChildProducerPyDatabase.NODE_TYPE_CLASS, 'initialize', None)
if callable(initialize_function):
initialize_function(context, node)
per_node_data = OgnBundleChildProducerPyDatabase.PER_NODE_DATA[node.node_id()]
def on_connection_or_disconnection(*args):
per_node_data['_db'] = None
node.register_on_connected_callback(on_connection_or_disconnection)
node.register_on_disconnected_callback(on_connection_or_disconnection)
@staticmethod
def release(node):
release_function = getattr(OgnBundleChildProducerPyDatabase.NODE_TYPE_CLASS, 'release', None)
if callable(release_function):
release_function(node)
OgnBundleChildProducerPyDatabase._release_per_node_data(node)
@staticmethod
def release_instance(node, target):
OgnBundleChildProducerPyDatabase._release_per_node_instance_data(node, target)
@staticmethod
def update_node_version(context, node, old_version, new_version):
update_node_version_function = getattr(OgnBundleChildProducerPyDatabase.NODE_TYPE_CLASS, 'update_node_version', None)
if callable(update_node_version_function):
return update_node_version_function(context, node, old_version, new_version)
return False
@staticmethod
def initialize_type(node_type):
initialize_type_function = getattr(OgnBundleChildProducerPyDatabase.NODE_TYPE_CLASS, 'initialize_type', None)
needs_initializing = True
if callable(initialize_type_function):
needs_initializing = initialize_type_function(node_type)
if needs_initializing:
node_type.set_metadata(ogn.MetadataKeys.EXTENSION, "omni.graph.test")
node_type.set_metadata(ogn.MetadataKeys.UI_NAME, "Test Node: Bundle Child Producer")
node_type.set_metadata(ogn.MetadataKeys.CATEGORIES, "internal:test")
node_type.set_metadata(ogn.MetadataKeys.DESCRIPTION, "Produces child bundle for bundle child consumer")
node_type.set_metadata(ogn.MetadataKeys.EXCLUSIONS, "usd,docs")
node_type.set_metadata(ogn.MetadataKeys.LANGUAGE, "Python")
icon_path = carb.tokens.get_tokens_interface().resolve("${omni.graph.test}")
icon_path = icon_path + '/' + "ogn/icons/omni.graph.test.BundleChildProducerPy.svg"
node_type.set_metadata(ogn.MetadataKeys.ICON_PATH, icon_path)
OgnBundleChildProducerPyDatabase.INTERFACE.add_to_node_type(node_type)
@staticmethod
def on_connection_type_resolve(node):
on_connection_type_resolve_function = getattr(OgnBundleChildProducerPyDatabase.NODE_TYPE_CLASS, 'on_connection_type_resolve', None)
if callable(on_connection_type_resolve_function):
on_connection_type_resolve_function(node)
NODE_TYPE_CLASS = None
@staticmethod
def register(node_type_class):
OgnBundleChildProducerPyDatabase.NODE_TYPE_CLASS = node_type_class
og.register_node_type(OgnBundleChildProducerPyDatabase.abi, 1)
@staticmethod
def deregister():
og.deregister_node_type("omni.graph.test.BundleChildProducerPy")
| 12,523 | Python | 46.984674 | 143 | 0.640581 |
Subsets and Splits
No saved queries yet
Save your SQL queries to embed, download, and access them later. Queries will appear here once saved.