Node

Node représente l’identité d’un nœud Maya : son objet natif, sa validité et ses capacités API. C’est la base commune des wrappers weSkel.

object→Node

10propriétés Python propres2méthodes propres3attributs de classe

Import

from weSkel.src.core.node.abstract.node.lib import Node

À exécuter dans Maya, avec weSkel accessible. Cette ligne suffit pour importer la classe.

Héritage et périmètre

Élément	Valeur
Classe	Node
Module	weSkel.src.core.node.abstract.node.lib
Parent Python	object ; aucune classe parente weSkel.
Métaclasse	NodeMeta ; elle intervient lors de la construction, sans être un parent de Node.
Sous-classe directe dans weSkel	DGNode, qui ajoute les opérations du Dependency Graph.
Membres hérités spécifiques à weSkel	Aucun ; tous les membres ci-dessous sont définis par Node.
Propriétés générées par des specs	Aucune sur cette classe de base.

Node contient un MObject ; il n’hérite pas de MObject. La création de nœuds, l’accès aux plugs, les snapshots et le replay appartiennent aux wrappers spécialisés. Pour créer un transform, voir Transform.

Constructeur

Signature : Node(node) → Node ou une sous-classe compatible déjà enregistrée.

Paramètre	Type accepté	Comportement
node	str	Nom Maya. Un nom introuvable produit un wrapper sans nœud live ; il ne crée rien.
node	om.MObject	Objet Maya API 2.0 représentant le nœud. Un objet nul produit un wrapper vide.
node	om.MObjectHandle	Handle dont l’objet est utilisé pour construire ou retrouver le wrapper.

Le paramètre est obligatoire, sans valeur par défaut. Le constructeur n’accepte pas directement MPlug, MDagPath ou un autre wrapper ; utiliser leur objet de nœud approprié, ou other.mobject pour un wrapper.

Que renvoie le constructeur ? Un wrapper Python qui représente le nœud Maya. Appeler Node(...) ne crée pas de nœud dans la scène.

Situation	Résultat
Nœud déjà connu	Pour un nœud live déjà enregistré, un nouvel appel retrouve le même wrapper compatible. Il peut donc renvoyer une sous-classe de Node.
Nom introuvable	Le wrapper peut s’attacher lorsque ce nom devient résolvable et que mobject est consulté.
Nœud supprimé après sa prise en charge	Un wrapper précédemment attaché ne récupère pas automatiquement un autre nœud recréé sous le même nom.
Erreurs possibles	TypeError pour une entrée ou un type de wrapper incompatible ; RuntimeError pour un objet natif non enregistrable ou un conflit d’identité.

Les points d’entrée Python sont __new__(cls, node) -> Node et __init__(self, node) -> None. Utiliser Node(node) pour bénéficier du mécanisme complet de construction et de réutilisation.

Propriétés

Toutes ces propriétés sont définies sur Node. L/E signifie lecture et écriture ; L signifie lecture seule. Les types om.* appartiennent à maya.api.OpenMaya.

Propriété	Type retourné	Accès	Valeur ou rôle
mobject	om.MObject	L/E	Objet Maya live, ou objet nul.
mobject_handle	om.MObjectHandle	L/E	Handle associé au nœud.
api_type	int | None	L	Identifiant du type API Maya.
api_type_str	str	L	Nom du type API, par exemple "kTime".
exists	bool	L	Le wrapper possède actuellement un nœud live.
is_null	bool	L	L’objet Maya retourné est nul.
is_alive	bool	L	L’objet existe avec un handle valide et vivant.
is_valid_handle	bool	L	Validité du handle mémorisé.
is_dag_node	bool	L	Compatibilité avec om.MFn.kDagNode.
hash_code	int	L	Hash du handle Maya.

mobject

node.mobjectLecture / écriture

Opération	Type / résultat
node.mobject	om.MObject ; objet nul si aucun nœud live n’est disponible.
node.mobject = value	Accepte None, str ou om.MObject.

La lecture suit l’identité native. Un renommage du nœud conserve cette identité. L’écriture réaffecte explicitement le wrapper ; elle ne renomme, ne crée et ne supprime pas de nœud Maya.

None détache le wrapper et efface son nom mémorisé. Un MObject nul le détache également. Un nom donné au setter doit déjà exister, contrairement au nom fourni au constructeur.

Exceptions du setter : TypeError pour un type non accepté, ValueError pour un nom introuvable, RuntimeError si un autre wrapper possède déjà cette identité ou si l’objet ne peut pas être enregistré.

mobject_handle

node.mobject_handleLecture / écriture

Opération	Type / résultat
node.mobject_handle	om.MObjectHandle, éventuellement invalide.
node.mobject_handle = value	Accepte uniquement un om.MObjectHandle valide et réaffecte l’objet du wrapper.

Exceptions du setter : TypeError pour un autre type, ValueError pour un handle invalide. La réaffectation peut aussi lever les erreurs d’identité de mobject.

api_type

node.api_typeLecture seule

Type retourné	Sans nœud live
int | None	None

Valeur native de MObject.apiType() si exists vaut True, sinon None. Il s’agit d’un identifiant de type API, pas du nom de type DG tel que "transform".

api_type_str

node.api_type_strLecture seule

Type retourné	Sans nœud live
str	"Unknown"

Nom API tel que "kTime" ou "kTransform". Renvoie "Unknown" lorsque exists vaut False.

exists

node.existsLecture seule

Type retourné	Sans nœud live
bool	False

Vaut True lorsque le wrapper est vivant et que son objet n’est pas nul. Utiliser cette propriété avant de travailler avec un nœud qui a pu être supprimé.

is_null

node.is_nullLecture seule

Type retourné	Sans nœud live
bool	True

Résultat de mobject.isNull(). La lecture de mobject peut résoudre le nom d’un wrapper qui n’a encore jamais été attaché.

is_alive

node.is_aliveLecture seule

Type retourné	Sans nœud live
bool	False

Vaut False pour un objet nul. Sinon, vérifie la validité du handle et son état vivant via l’API Maya. Ce contrôle est plus complet que le seul MObjectHandle.isAlive().

is_valid_handle

node.is_valid_handleLecture seule

Type retourné	Sans nœud live
bool	Validité du handle mémorisé ; False pour un handle nul.

Résultat de mobject_handle.isValid(). Ce test du handle ne remplace pas le contrôle complet de exists ; consulter mobject ou exists pour résoudre un nom encore absent au moment de la construction.

is_dag_node

node.is_dag_nodeLecture seule

Type retourné	Sans nœud live
bool	False

Indique si l’objet accepte le function set DAG. Un transform est un nœud DAG ; le nœud time1 de l’exemple ne l’est pas. Sur un objet nul, cette propriété vaut False.

hash_code

node.hash_codeLecture seule

Type retourné	Sans nœud live
int	0 pour un handle nul.

Résultat de MObjectHandle.hashCode() ; vaut 0 pour un handle nul. Ce hash n’est ni un UUID ni un identifiant persistant à sauvegarder pour retrouver le nœud dans une autre session.

Méthodes

Méthode	Nature	Retour	Rôle
has_fn(fn_type)	Instance	bool	Tester la compatibilité avec un function set Maya.
clear_node_registry()	Classe	None	Détacher les wrappers enregistrés et vider leur registre partagé.

has_fn

node.has_fn(fn_type: int) → boolMéthode d’instance

Élément	Description
fn_type	Constante de om.MFn, par exemple om.MFn.kDependencyNode ou om.MFn.kDagNode. Obligatoire, sans valeur par défaut.
Retour	True si le nœud accepte ce function set ; False sinon, ou si le wrapper n’a pas de nœud live.
Effet	Aucun changement de la scène.

L’appel ne crée pas de function set et ne renvoie pas de MFn*. Fournir une constante MFn valide ; les erreurs de type de l’API Maya ne sont pas converties par cette méthode.

clear_node_registry

Node.clear_node_registry() → NoneMéthode de classe

Élément	Description
Paramètres	Aucun.
Retour	None.
Portée	Tous les wrappers du registre partagé, y compris ceux des sous-classes.
Effet	Détache les wrappers enregistrés et vide le registre. Les nœuds Maya eux-mêmes restent dans la scène.

Réinitialisation globale. Ce n’est pas une commande de nettoyage de scène. Les variables conservées par d’autres outils peuvent désormais contenir des wrappers détachés. Réserver cet appel à une réinitialisation maîtrisée de l’environnement de wrappers.

Attributs de classe

Attribut	Type	Valeur sur Node / rôle
NODE_TYPE	str | None	None ; aucun type Maya concret n’est imposé par cette base.
COMPATIBLE_MAYA_FN_TYPES	tuple[int, ...]	(om.MFn.kDependencyNode,) ; compatibilité native acceptée par la base.
NODE_REGISTRY	weakref.WeakValueDictionary[str, Node]	Registre partagé, indexé par UUID Maya, contenant des références faibles aux wrappers.

Ces attributs décrivent la classe et son infrastructure. Pour les scripts d’utilisation, les consulter sans les remplacer ni modifier directement le registre. Les champs et méthodes préfixés par _ ne constituent pas l’API publique de cette page ; les méthodes standard héritées de object ne sont pas répétées.

Comportements à retenir

Situation	Résultat
Deux appels avec le même nœud live	Même wrapper compatible, tant qu’il reste enregistré.
Renommage dans Maya	L’identité du wrapper est conservée.
Nom absent à la construction	Wrapper non résolu ; aucune création automatique.
Nœud supprimé, puis autre nœud créé sous le même nom	L’ancien wrapper n’adopte pas le nouveau nœud automatiquement.
Besoin de name, plugs, create() ou snapshot()	Ces membres ne sont pas définis sur Node ; utiliser le wrapper spécialisé approprié.

Voir aussi Fonctionnement pour le fonctionnement général et SDK pour sa disponibilité.

Exemples d’utilisation

Ici, om sert à accéder à om.MFn.kDependencyNode, pas à importer Node.

Dans le Script Editor → Python, ou dans un fichier .py exécuté par Maya :

import maya.api.OpenMaya as om
from weSkel.src.core.node.abstract.node.lib import Node

node = Node("time1")
assert node.exists, "The example requires Maya's default time1 node."

print(node.api_type_str)
print(node.has_fn(om.MFn.kDependencyNode))
assert Node(node.mobject) is node
assert Node(node.mobject_handle) is node

Résultat attendu : kTime, puis True. Le script consulte le nœud time1 déjà présent dans une scène Maya standard ; il ne crée aucun nœud. Remplacer "time1" par le nom d’un nœud existant pour l’inspecter.

Depuis un script autonome avec mayapy

Utiliser le Python livré avec Maya (mayapy), avec weSkel accessible à cet interpréteur. Un Python standard sans les bibliothèques Maya ne suffit pas. Le chemin d’import de Node reste identique.

import maya.standalone

maya.standalone.initialize(name="python")
try:
    from weSkel.src.core.node.abstract.node.lib import Node

    node = Node("time1")
    assert node.exists
    print(node.api_type_str)
finally:
    maya.standalone.uninitialize()

Ce bloc initialise une session autonome. Dans le Script Editor de Maya, utiliser l’exemple précédent : la session est déjà initialisée.

API source · Exemples vérifiés dans Maya 2025.3 et 2026.3. La validation du package compilé est distincte.