PlugArray

PlugArray est une collection de plugs Maya. Ses filtres renvoient de nouvelles collections ; les plugs continuent de représenter les mêmes attributs live.

om.MPlugArray→PlugArray

9propriétés13méthodes

Import

from weSkel.src.core.node.extensions.plugs_lib import PlugArray

À exécuter dans Maya avec weSkel disponible. Les types om.* désignent maya.api.OpenMaya.

Héritage et périmètre

Élément	Valeur
Classe	PlugArray
Module	weSkel.src.core.node.extensions.plugs_lib
Parent direct	om.MPlugArray
Nature	Sous-classe Maya API 2.0
Propriétés issues des specs	Aucune.

Cette fiche documente les membres définis par cette classe. Les mécanismes Python standard et les membres natifs hérités sont exclus des compteurs.

Membres natifs hérités : om.MPlugArray — Autodesk.

Constructeur

PlugArray(array: Optional[Union[Sequence[Plug], Sequence[om.MPlug], om.MPlugArray, om.MPlug]]=None) → PlugArray

Paramètre	Type	Défaut
array	Optional[Union[Sequence[Plug], Sequence[om.MPlug], om.MPlugArray, om.MPlug]]	None

Sans argument, crée une collection vide. Accepte un om.MPlug unique, un om.MPlugArray ou une séquence de plugs. Un générateur doit passer par PlugArray.from_iter(). Autre type : TypeError. La collection référence des attributs existants, sans les dupliquer.

Propriétés

Membres propres. L = lecture seule ; L/E = lecture et écriture.

Propriété	Type retourné	Accès	Rôle
writable	PlugArray	L	Filtre les plugs non verrouillés, sans vérifier leurs connexions.
keyable	PlugArray	L	Filtre les plugs keyable.
channel_box	PlugArray	L	Filtre les plugs dont le drapeau Channel Box est actif.
locked	PlugArray	L	Filtre les plugs verrouillés.
unlocked	PlugArray	L	Filtre les plugs non verrouillés.
arrays	PlugArray	L	Filtre les racines de multis.
elements	PlugArray	L	Rassemble les éléments matérialisés des racines de multis présentes.
compounds	PlugArray	L	Filtre les plugs compound.
dynamic	PlugArray	L	Filtre les attributs dynamiques.

writable

plugs.writableLecture seule

Type	Contrat
PlugArray	Filtre les plugs non verrouillés, sans vérifier leurs connexions.

Ce filtre teste uniquement le verrou local. Un plug non verrouillé peut rester non modifiable parce qu’il est connecté ou soumis à une autre contrainte Maya.

keyable

plugs.keyableLecture seule

Type	Contrat
PlugArray	Filtre les plugs keyable.

channel_box

plugs.channel_boxLecture seule

Type	Contrat
PlugArray	Filtre les plugs dont le drapeau Channel Box est actif.

locked

plugs.lockedLecture seule

Type	Contrat
PlugArray	Filtre les plugs verrouillés.

unlocked

plugs.unlockedLecture seule

Type	Contrat
PlugArray	Filtre les plugs non verrouillés.

Ce filtre teste uniquement le verrou local. Un plug non verrouillé peut rester non modifiable parce qu’il est connecté ou soumis à une autre contrainte Maya.

arrays

plugs.arraysLecture seule

Type	Contrat
PlugArray	Filtre les racines de multis.

elements

plugs.elementsLecture seule

Type	Contrat
PlugArray	Rassemble les éléments matérialisés des racines de multis présentes.

compounds

plugs.compoundsLecture seule

Type	Contrat
PlugArray	Filtre les plugs compound.

dynamic

plugs.dynamicLecture seule

Type	Contrat
PlugArray	Filtre les attributs dynamiques.

Méthodes

Méthodes propres.

Méthode	Type retourné	Rôle
to_mplug_array	om.MPlugArray	Crée une collection native om.MPlugArray contenant les mêmes plugs.
from_iter	PlugArray	Construit une collection depuis un itérable ; méthode de classe.
filter	PlugArray	Conserve les plugs pour lesquels le prédicat renvoie vrai.
connected	PlugArray	Filtre les plugs connectés selon leur rôle source ou destination.
of_type	PlugArray	Filtre par identifiants API de type d’attribut.
match	PlugArray	Filtre les noms avec un motif fnmatch.
disconnect_all_inputs	None	Déconnecte les entrées de chaque plug, successivement.
disconnect_all_outputs	None	Déconnecte les sorties de chaque plug, successivement.
disconnect_all	None	Déconnecte toutes les relations de chaque plug, successivement.
connect_to	None	Connecte la collection de sources aux destinations.
connect_from	None	Connecte des sources à cette collection de destinations.
disconnect_to	None	Déconnecte les relations vers les cibles ; fournir des cibles explicites.
disconnect_from	None	Déconnecte les relations provenant des sources, ou les entrées actuelles.

to_mplug_array

plugs.to_mplug_array()Méthode

Retour	Contrat
om.MPlugArray	Crée une collection native om.MPlugArray contenant les mêmes plugs.

from_iter

PlugArray.from_iter(iterable: Iterator[Plug])Méthode

Paramètre	Type	Défaut
iterable	Iterator[Plug]	obligatoire

Retour	Contrat
PlugArray	Construit une collection depuis un itérable ; méthode de classe.

filter

plugs.filter(fn: Callable[[Plug], bool])Méthode

Paramètre	Type	Défaut
fn	Callable[[Plug], bool]	obligatoire

Retour	Contrat
PlugArray	Conserve les plugs pour lesquels le prédicat renvoie vrai.

connected

plugs.connected(what: str='any')Méthode

Paramètre	Type	Défaut
what	str	'any'

Retour	Contrat
PlugArray	Filtre les plugs connectés selon leur rôle source ou destination.

what accepte uniquement "any", "source" ou "destination" ; toute autre valeur lève ValueError.

of_type

plugs.of_type(attr_types: Set[int])Méthode

Paramètre	Type	Défaut
attr_types	Set[int]	obligatoire

Retour	Contrat
PlugArray	Filtre par identifiants API de type d’attribut.

match

plugs.match(pattern: str, where: str='full')Méthode

Paramètre	Type	Défaut
pattern	str	obligatoire
where	str	'full'

Retour	Contrat
PlugArray	Filtre les noms avec un motif fnmatch.

where vaut "full" (nom natif), "long" ou "short". Tous incluent le nom du nœud. Les motifs utilisent fnmatch, pas une expression régulière. Mode inconnu : ValueError.

disconnect_all_inputs

plugs.disconnect_all_inputs()Méthode

Retour	Contrat
None	Déconnecte les entrées de chaque plug, successivement.

disconnect_all_outputs

plugs.disconnect_all_outputs()Méthode

Retour	Contrat
None	Déconnecte les sorties de chaque plug, successivement.

disconnect_all

plugs.disconnect_all()Méthode

Retour	Contrat
None	Déconnecte toutes les relations de chaque plug, successivement.

connect_to

plugs.connect_to(targets: Union['PlugArray', Plug], *, force: bool=False, clear_dest: bool=False)Méthode

Paramètre	Type	Défaut
targets	Union[PlugArray, Plug]	obligatoire
force	bool	False
clear_dest	bool	False

Retour	Contrat
None	Connecte la collection de sources aux destinations.

Deux PlugArray sont appariés par position et doivent avoir la même longueur (ValueError sinon). Une source unique vers plusieurs destinations est prise en charge par destinations.connect_from(source). Plusieurs sources vers un unique plug scalaire ne constituent pas un mélange valide. Les cibles déjà occupées restent intactes sans remplacement explicite. Les plugs nuls sont ignorés ; contrôler les connexions attendues après l’appel. clear_dest=True ou force=True remplacent l’entrée existante des destinations.

connect_from

plugs.connect_from(sources: Union['PlugArray', Plug], *, force: bool=False, clear_src: bool=False)Méthode

Paramètre	Type	Défaut
sources	Union[PlugArray, Plug]	obligatoire
force	bool	False
clear_src	bool	False

Retour	Contrat
None	Connecte des sources à cette collection de destinations.

Deux PlugArray sont appariés par position et doivent avoir la même longueur (ValueError sinon). Une source unique vers plusieurs destinations est prise en charge par destinations.connect_from(source). Plusieurs sources vers un unique plug scalaire ne constituent pas un mélange valide. Les cibles déjà occupées restent intactes sans remplacement explicite. Les plugs nuls sont ignorés ; contrôler les connexions attendues après l’appel. Malgré son nom, clear_src=True efface l’entrée des destinations de self, pas les sorties de la source. Il a ici le même effet de remplacement que force=True.

disconnect_to

plugs.disconnect_to(targets: Optional[Union['PlugArray', Plug]]=None)Méthode

Paramètre	Type	Défaut
targets	Optional[Union[PlugArray, Plug]]	None

Retour	Contrat
None	Déconnecte les relations vers les cibles ; fournir des cibles explicites.

Limite reproduite : sans targets, le chemin actuel utilise une signature connectedTo incompatible et lève TypeError. Fournir un Plug ou un PlugArray explicite, ou utiliser disconnect_all_outputs(). Avec deux collections, les longueurs doivent correspondre.

disconnect_from

plugs.disconnect_from(sources: Optional[Union['PlugArray', Plug]]=None)Méthode

Paramètre	Type	Défaut
sources	Optional[Union[PlugArray, Plug]]	None

Retour	Contrat
None	Déconnecte les relations provenant des sources, ou les entrées actuelles.

sources=None retire les entrées natives actuelles. Un plug unique s’applique à chaque destination ; deux collections s’apparient par position et exigent la même longueur. Les verrous sont restaurés.

Accès Python

Expression	Retour	Comportement
len(plugs)	int	Nombre d’entrées.
plugs[index]	Plug	Index de collection positif ou nul ; négatif/hors limites : IndexError. Les slices ne sont pas prises en charge par cet override.
for plug in plugs	Iterator[Plug]	Parcourt la collection dans son ordre.

Comportements à retenir

Les filtres ne modifient pas la collection initiale. Le contenu sélectionné correspond à l’instant du filtre, mais les valeurs des plugs restent live. PlugArray n’est ni un attribut multi ni une liste de valeurs.

Les connexions par collection ne font pas de calcul de mélange. Les méthodes disconnect_all_* traitent les plugs successivement : ne pas supposer un rollback global si un appel ultérieur échoue.

Exemple d’utilisation

from uuid import uuid4
from weSkel.src.core.node.dag.transform.lib import Transform
from weSkel.src.core.node.extensions.plugs_lib import PlugArray

suffix = uuid4().hex[:8]
driver = Transform("sdk_driver_" + suffix)
follower = Transform("sdk_follower_" + suffix)
try:
    driver.create()
    follower.create()
    source = driver.plugs["scaleX"]
    source.value = 3.0
    targets = PlugArray([follower.plugs[name] for name in
                         ("scaleX", "scaleY", "scaleZ")])
    targets.connect_from(source)
    assert len(targets.connected("destination")) == 3
    assert [plug.value for plug in targets] == [3.0, 3.0, 3.0]
    assert len(targets.match("*scaleY")) == 1
    targets.disconnect_from(source)
    assert all(plug.src is None for plug in targets)
    print("PlugArray: PASS")
finally:
    follower.delete(snapshot=False)
    driver.delete(snapshot=False)

Résultat attendu : PlugArray: PASS. Les nœuds temporaires sont supprimés dans finally.

Voir aussi : Plug · Plugs.