Bundle

Bases: Bundle

Bundle Socket.

To create a new Bundle, one can use the Combine method with named_sockets dict and sockets keyword arguments.

New items can be added using with syntax.

To get the content of a Bundle, use separate method. This method requires a signature argument giving the structure of the bundle. The signature can be read from Bundle or directly created from a dict.

with GeoNodes("Bundle Test") as tree:

    # One way to combine a new bundle

    with Layout("Combining from dict"):
        bundle1 = Bundle.Combine({"Float": 1., "Integer": Integer(2), "Name": "Bundle 1", "Geometry": Geometry()})

    # Adding entries

    with bundle1:
        Mesh.Cube().out("Mesh 1")
        Mesh.IcoSphere().out("Mesh 2")

    # Get the signature

    sig1 = bundle1.get_signature()

    # Second bundle with its signature

    bundle2 = Bundle.Combine({"Geometry": Mesh.UVSphere()}, A=1, B=2)
    sig2 = bundle2.get_signature()

    # Join the bundles
    # Raises info on duplicate keys

    bundle = bundle1 + bundle2

    # Extract geometry from bundle
    # Add the signatures to separate properly
    node = bundle.separate(signature=sig1 + sig2)
    node.out()

    # Using a dict as signature
    bundle = Bundle.Combine(pi=3.14, count=123)
    node = bundle.separate(signature={'pi': Float, 'count': Integer})
    node.out(panel="Manual Signature")

Source code in core/sock_bundle.py

class Bundle(generated.Bundle):
    """ Bundle Socket.

    To create a new Bundle, one can use the `Combine` method with `named_sockets` dict and `sockets` keyword
    arguments.

    New items can be added using `with` syntax.

    To get the content of a Bundle, use `separate` method. This method requires a `signature` argument giving
    the structure of the bundle. The signature can be read from Bundle or directly created from a dict.


    ``` python
    with GeoNodes("Bundle Test") as tree:

        # One way to combine a new bundle

        with Layout("Combining from dict"):
            bundle1 = Bundle.Combine({"Float": 1., "Integer": Integer(2), "Name": "Bundle 1", "Geometry": Geometry()})

        # Adding entries

        with bundle1:
            Mesh.Cube().out("Mesh 1")
            Mesh.IcoSphere().out("Mesh 2")

        # Get the signature

        sig1 = bundle1.get_signature()

        # Second bundle with its signature

        bundle2 = Bundle.Combine({"Geometry": Mesh.UVSphere()}, A=1, B=2)
        sig2 = bundle2.get_signature()

        # Join the bundles
        # Raises info on duplicate keys

        bundle = bundle1 + bundle2

        # Extract geometry from bundle
        # Add the signatures to separate properly
        node = bundle.separate(signature=sig1 + sig2)
        node.out()

        # Using a dict as signature
        bundle = Bundle.Combine(pi=3.14, count=123)
        node = bundle.separate(signature={'pi': Float, 'count': Integer})
        node.out(panel="Manual Signature")
    ```
    """

    SOCKET_TYPE = 'BUNDLE'

    # ====================================================================================================
    # Get the signature
    # ====================================================================================================

    @property
    def _is_combine(self):
        return self._bsocket.node.bl_idname == 'NodeCombineBundle'


    # ====================================================================================================
    # Get the signature
    # ====================================================================================================

    def get_signature(self, with_sockets: bool = False):
        """ Build the closure signature of the node.

        Parameters
        ----------
        with_sockets : bool, optional
            include sockets default=False.


        Returns
        -------
        Signature
        """
        if self._is_combine:
            return Signature(self.node.get_signature(with_sockets=with_sockets).inputs)
        else:
            raise RuntimeError(f"The Bundle socket {self} doesn't come from a 'Combine Bundle' node. Impossible to get its signature.")

    # ====================================================================================================
    # Separate
    # ====================================================================================================

    def separate(self, signature: Signature = None):
        """ > Node Separate Bundle

        Separate the bundle.
        """

        # ----------------------------------------------------------------------------------------------------
        # Create the node
        # ----------------------------------------------------------------------------------------------------

        node = Node('Separate Bundle', {'Bundle': self})

        # ----------------------------------------------------------------------------------------------------
        # Applies the signature
        # ----------------------------------------------------------------------------------------------------

        if signature is None and self._is_combine:
            signature = self.get_signature()

        if signature is not None:
            node.set_signature('OUTPUT', signature)

        return node

    # ====================================================================================================
    # Operators
    # ====================================================================================================

    def __add__(self, other):
        return self.join(other)

    # ====================================================================================================
    # Class test    
    # ====================================================================================================

    @staticmethod
    def _class_test():

        from geonodes import GeoNodes, Geometry, Mesh, Layout, Integer, Bundle, Float

        with GeoNodes("Bundle Test") as tree:

            # One way to combine a new bundle

            with Layout("Combining from dict"):
                bundle1 = Bundle.Combine({"Float": 1., "Integer": Integer(2), "Name": "Bundle 1", "Geometry": Geometry()})

            # Adding entries

            with bundle1:
                Mesh.Cube().out("Mesh 1")
                Mesh.IcoSphere().out("Mesh 2")

            # Get the signature

            sig1 = bundle1.get_signature()

            # Second bundle with its signature

            bundle2 = Bundle.Combine({"Geometry": Mesh.UVSphere()}, A=1, B=2)
            sig2 = bundle2.get_signature()

            # Join the bundles
            # Raises info on duplicate keys

            bundle = bundle1 + bundle2

            # Extract geometry from bundle
            # Add the signatures to separate properly
            node = bundle.separate(signature=sig1 + sig2)
            node.out()

            # Using a dict as signature
            bundle = Bundle.Combine(pi=3.14, count=123)
            node = bundle.separate(signature={'pi': Float, 'count': Integer})
            node.out(panel="Manual Signature")

_interface_socket property

Return the interface socket if exists

An interface socket exists when the socket a tree input or output socket or when it is the socket of a group

Returns:

Type	Description
Interface Socket

_name property

Return the name or the label

Returns:

Type	Description
str	default is ""

_panel_name property

Return the name of the panel

Returns:

Type	Description
str	default is ""

is_grid property

bool property

Returns True if socket is a grid (inferred_structure_type == 'GRID').

node_color property writable

Node color

Returns:

Type	Description
SysColor

node_label property writable

Node Label

Returns:

Type	Description
str

Combine(named_sockets={}, define_signature=False, **sockets) classmethod

Node Combine Bundle

Parameters:

Name	Type	Description	Default
named_sockets	dict	Sockets created with string names	{}
define_signature	bool	parameter define_signature	False
sockets	dict	Socket created with python name attributes	{}

Returns:

Type	Description
Bundle

Source code in core/generated/bundle.py

@classmethod
def Combine(cls, named_sockets: dict = {}, define_signature = False, **sockets):
    """ > Node Combine Bundle

    Parameters
    ----------
    named_sockets : dict, default={}
        Sockets created with string names

    define_signature : bool
        parameter `define_signature`

    sockets : dict, default={}
        Socket created with python name attributes

    Returns
    -------
    Bundle
    """
    node = Node('Combine Bundle', named_sockets, define_signature=define_signature, **sockets)
    return cls(node._out)

Constant(value, user_label='') classmethod

Create an input socket from a constant Node.

Parameters:

Name	Type	Description	Default
value	Any	constant default value default=None.	required
user_label	str	socket name (used to rename nodes if not None) default="".	''

Source code in core/socket_class.py

@classmethod
def Constant(cls, value: None, user_label: str = ""):
    """ Create an input socket from a constant Node.

    Parameters
    ----------
    value : Any, optional
        constant default value default=None.

    user_label : str, optional
        socket name (used to rename nodes if not None) default="".

    """

    # ---------------------------------------------------------------------------
    # Ensure array
    # ---------------------------------------------------------------------------

    def get_shaped(v, *shapes):
        r = np.ravel(v)
        shape = np.shape(r)
        if shape in shapes:
            return tuple(r)

        if shape == (1,):
            return tuple(np.resize(r, shapes[0]))

        raise NodeError(
            f"The value <{v}> can't be transformed in a valid initial value for {SocketType(cls.SOCKET_TYPE).class_name}."
        )

    # ---------------------------------------------------------------------------
    # Does the array contain sockets
    # ---------------------------------------------------------------------------

    def has_sockets(a):
        for v in a:
            if SocketType.get_bsocket(v) is not None:
                return True
        return False

    # ---------------------------------------------------------------------------
    # Default value
    # ---------------------------------------------------------------------------

    socket_type = SocketType(cls.SOCKET_TYPE)
    if cls.SOCKET_TYPE not in ['RGBA', 'VECTOR', 'ROTATION', 'MATRIX']:
        def_val = socket_type.get_default_from_value(value)

    # ---------------------------------------------------------------------------
    # Depending on the socket type
    # ---------------------------------------------------------------------------

    if cls.SOCKET_TYPE == 'BOOLEAN':
        return Node('Boolean', boolean=def_val)._out._ul(user_label)

    elif cls.SOCKET_TYPE == 'BUNDLE':
        return Node("Combine Bundle")._out._ul(user_label)

    elif cls.SOCKET_TYPE == 'CLOSURE':
        socket = ZoneNode.Closure().closure
        socket._use_layout = False
        return socket._ul(user_label)

    elif cls.SOCKET_TYPE == 'COLLECTION':
        return Node('Collection', collection=def_val)._out._ul(user_label)

    elif cls.SOCKET_TYPE == 'RGBA':

        if value is None:
            a = (0, 0, 0, 1)
        elif isinstance(value, str):
            #a = colors.to_color(value)
            a = SysColor(value).rgba
        else:
            a = get_shaped(value, (4,), (3,))

        if has_sockets(a):
            if Tree.is_geonodes():
                node = Node('Combine Color', {0: a[0], 1: a[1], 2:a[2]})
                if len(a) == 4:
                    node.alpha = a[3]
                return node._out._ul(user_label)
            else:
                return Node('Combine Color', {0: a[0], 1: a[1], 2:a[2]})._out._ul(user_label)

        else:
            def_val = SocketType('COLOR').get_default_from_value(a)
            if Tree.is_geonodes():
                return Node('Color', value=def_val)._out._ul(user_label)

            else:
                socket = Node('Color')._out
                socket._bsocket.default_value = def_val
                return socket._ul(user_label)

    elif cls.SOCKET_TYPE == 'IMAGE':
        return Node('Image', image=def_val)._out._ul(user_label)

    elif cls.SOCKET_TYPE == 'INT':
        return Node('Integer', integer=def_val)._out._ul(user_label)

    elif cls.SOCKET_TYPE == 'MATERIAL':
        return Node('Material', material=def_val)._out._ul(user_label)

    elif cls.SOCKET_TYPE == 'MATRIX':

        if value is None:
            a = (1, 0, 0, 0,   0, 1, 0, 0,   0, 0, 1, 0,   0, 0, 0, 1)
        else:
            a = get_shaped(value, (16,))

        return Node('Combine Matrix', named_sockets = {i: a[i] for i in range(16)})._out._ul(user_label)

    elif cls.SOCKET_TYPE == 'MENU':
        return Node('Menu Switch')._out._ul(user_label)

    elif cls.SOCKET_TYPE == 'OBJECT':
        return Node('Object', object=def_val)._out._ul(user_label)

    elif cls.SOCKET_TYPE == 'FONT':
        return cls.NewInput("Font", value)

    elif cls.SOCKET_TYPE == 'ROTATION':

        if value is None:
            a = (0, 0, 0)
        else:
            a = get_shaped(value, (3,))

        if has_sockets(a):
            return Node('Combine XYZ', x=a[0], y=a[1], z=a[2])._out.to_rotation()._ul(user_label)
        else:
            return Node('Rotation', rotation_euler=a)._out._ul(user_label)

    elif cls.SOCKET_TYPE == 'STRING':
        return Node('String', string=def_val)._out._ul(user_label)

    elif cls.SOCKET_TYPE == 'VALUE':
        node = Node('Value')
        node._bnode.outputs[0].default_value = def_val
        return node._out._ul(user_label)

    elif cls.SOCKET_TYPE == 'VECTOR':

        if value is None:
            a = (0, 0, 0)
        else:
            a = get_shaped(value, (3,))

        if has_sockets(a):
            return Node('Combine XYZ', x=a[0], y=a[1], z=a[2])._out._ul(user_label)
        else:
            return Node('Vector', vector=a)._out._ul(user_label)

    elif cls.SOCKET_TYPE == 'GEOMETRY':
        raise NodeError(f"There is no node to create a Geometry. Use explicit constructors such as 'Mesh.Cube()', 'Curve.Spiral()' or 'Cloud.Points().")

    else:
        assert False, f"Shouldn't happen {socket_type}"

Empty(value=None) classmethod

Create an empty socket.

An empty socket is used temporarily as an input for nodes with dynamic sockets:

Parameters:

Name	Type	Description	Default
value	Any	default value default=None.	None

Source code in core/socket_class.py

@classmethod
def Empty(cls, value = None):
    """ Create an empty socket.

    An empty socket is used temporarily as an input for nodes with dynamic sockets:

    Parameters
    ----------
    value : Any, optional
        default value default=None.

    """
    socket = cls(constants.EMPTY_SOCKET)
    socket._bsocket = SocketType(cls.SOCKET_TYPE).get_default_from_value(value)
    return socket

IndexSwitch(*values, index=None, default_index=0) classmethod

Node Index Switch

with GeoNodes("IndexSwitch demo"):

    # Create some geometries
    geo    = Geometry()
    cube   = Mesh.Cube()
    sphere = Mesh.IcoSphere()
    cone   = Mesh.Cone()

    # Pick in this list
    pick_geo = Geometry.IndexSwitch(geo, cube, sphere, cone, index=tree.new_input("Geometry index", default_value=2))

    # Plug the result to the output
    pick_geo.out()

Parameters:

Name	Type	Description	Default
*values	Any	List of Sockets to select into	()
index	Integer	socket 'Index' (Index) default=None.	None
default_index	int	default idex default=0.	0

Returns:

Type	Description
Socket

Source code in core/socket_class.py

@classmethod
def IndexSwitch(cls, *values, index = None, default_index: int = 0):
    """ > Node Index Switch

    ``` python
    with GeoNodes("IndexSwitch demo"):

        # Create some geometries
        geo    = Geometry()
        cube   = Mesh.Cube()
        sphere = Mesh.IcoSphere()
        cone   = Mesh.Cone()

        # Pick in this list
        pick_geo = Geometry.IndexSwitch(geo, cube, sphere, cone, index=tree.new_input("Geometry index", default_value=2))

        # Plug the result to the output
        pick_geo.out()
    ```

    Parameters
    ----------
    *values : Any
        List of Sockets to select into

    index : Integer, optional
        socket 'Index' (Index) default=None.

    default_index : int, optional
        default idex default=0.


    Returns
    -------
    Socket
    """
    #return IndexSwitchNode(*values, index=index, data_type=cls.input_type())._out
    return MenuNode('Index Switch', 
                    {str(i): value for i, value in enumerate(values)}, 
                    data_type=cls.SOCKET_TYPE, 
                    Index=index,
                    default_menu = default_index)._out

Input(name, panel='', halt=True) classmethod

Get an exist input socket from its name and panel.

Note

The "input" socket here is an "output" socket of the current input node

To create a input socket use NewInput.

If the 'name' argument is None, the first socket of the proper type is returned.

Raises:

Type	Description
- NodeError if socket is not found and halt is requested

Parameters:

Name	Type	Description	Default
name	str | None	socket name	required
panel	str	panel name default="".	''
halt	bool	raises an error if not found default=True.	True

Returns:

Type	Description
Socket

Source code in core/socket_class.py

@classmethod
def Input(cls, name: str, panel: str = "", halt: bool = True):
    """ Get an exist input socket from its name and panel.

    !!! note
        The "input" socket here is an "output" socket of the current input node

    To create a input socket use NewInput.

    If the 'name' argument is None, the first socket of the proper type is returned.

    Raises
    ------
    - NodeError if socket is not found and halt is requested

    Parameters
    ----------
    name : str | None
        socket name

    panel : str, optional
        panel name default="".

    halt : bool, optional
        raises an error if not found default=True.


    Returns
    -------
    Socket
    """
    in_node = Tree.current_tree().get_input_node()

    include = None if name is None else [name]
    bsockets = in_node.get_sockets('OUTPUT', include=include, panel=panel)

    for _, bsock in bsockets:
        if SocketType(bsock).type == cls.SOCKET_TYPE: # and utils.snake_case(sock_name) == utils.snake_case(name):
            return cls(bsock._bsocket)._ul(name)

    if halt:
        sname = "" if name is None else f" named '{name}'"
        raise NodeError(
            f"There is no {SocketType(cls.SOCKET_TYPE).class_name} input socket{sname}.\n"
            f"Available sockets are : {[bsock[0] for bsock in in_node.get_sockets('OUTPUT')]}.")

    return None

MenuSwitch(named_sockets={}, default_menu=None, **sockets) classmethod

Node Menu Switch

The items of the Menu Switch node are provided in the 'items' dict.

Parameters:

Name	Type	Description	Default
named_sockets	dict	sockets to create default={}.	{}
default_menu	str	default menu value default=None.	None
sockets	dict	items	{}

Returns:

Type	Description
Socket

Source code in core/socket_class.py

@classmethod
def MenuSwitch(cls, 
               named_sockets    : dict = {},
               default_menu     : str = None,
               **sockets):
    """ > Node Menu Switch

    The items of the Menu Switch node are provided in the 'items' dict.

    Parameters
    ----------
    named_sockets : dict, optional
        sockets to create default={}.

    default_menu : str, optional
        default menu value default=None.

    sockets : dict
        items


    Returns
    -------
    Socket
    """
    node = MenuNode('Menu Switch',
            named_sockets = named_sockets,
            data_type = SocketType(cls.SOCKET_TYPE).type,
            default_menu = default_menu,
            **sockets)

    return cls(node._out)

Named(name) classmethod

Node Named Attribute

Information

• Parameter 'data_type' : 'BOOLEAN'

Parameters:

Name	Type	Description	Default
name	String	socket 'Name' (id: Name)	required

Returns:

Type	Description
Boolean

Source code in core/socket_class.py

@classmethod
def Named(cls, name):
    """ > Node Named Attribute

    Information
    -----------
    - Parameter 'data_type' : 'BOOLEAN'

    Parameters
    ----------
    name : String
        socket 'Name' (id: Name)


    Returns
    -------
    Boolean
    """
    if SocketType(cls.SOCKET_TYPE).class_name not in constants.ATTRIBUTE_CLASSES:
        raise NodeError(
            f"The class {SocketType(cls.SOCKET_TYPE).class_name} is not an attribute.\n"
            f"Attribute classes are: {constants.ATTRIBUTE_CLASSES}")

    node = Node('Named Attribute', name=name)
    data_type = SocketType(cls.SOCKET_TYPE).get_node_data_type(
        tree_type = node._tree._btree.bl_idname,
        bl_idname = node._bnode.bl_idname,
        halt = True)

    node.set_parameter('data_type', data_type)

    return node._out._ul(name)

NewInput(name, value=None, tip='', panel='', **props) classmethod

Create an new input socket

Note

The "input" socket here is an "output" socket of the current input node

To get an existing input socket use Input.

Raises:

Type	Description
- NodeError if socket is not found

Parameters:

Name	Type	Description	Default
name	str	socket name	required
value	Any	default_value default=None.	None
tip	str	description default="".	''
panel	str: None	panel name	''

Returns:

Type	Description
Socket

Source code in core/socket_class.py

@classmethod
def NewInput(cls,
        name: str, 
        value       = None, 
        tip: str    = "", 
        panel: str  = "", 
        **props):
    """ Create an new input socket

    !!! note
        The "input" socket here is an "output" socket of the current input node

    To get an existing input socket use Input.

    Raises
    ------
    - NodeError if socket is not found

    Parameters
    ----------
    name : str
        socket name

    value : Any, optional
        default_value default=None.

    tip : str, optional
        description default="".

    panel : str: None
        panel name


    Returns
    -------
    Socket
    """
    if value is None:
        defval = None
    else:
        defval = SocketType(cls.SOCKET_TYPE).get_default_from_value(value)
        new_props = {**props}

        if 'default' in new_props:
            new_props['default'] = defval

        elif 'default_value' in new_props:
            new_props['default_value'] = defval

        else:
            if 'default' not in constants.SOCKETS[cls.SOCKET_TYPE]['props']:
                raise NodeError(f"The {SocketType(cls.SOCKET_TYPE).class_name} socket doesn't accept a default value. Value argument <{value}> is invalid.")

            new_props['default_value'] = defval

        props = new_props

    return cls(Tree.current_tree().create_input_socket(
        SocketType(cls.SOCKET_TYPE).socket_id,
        name         = name,
        tip          = tip,
        panel        = panel,
        **props))

Switch(condition=None, false=None, true=None) classmethod

Node Switch

with GeoNodes("Switch demo"):

    # Two possible geometries
    cube   = Mesh.Cube()
    sphere = Mesh.IcoSphere()

    # Select
    geo = Geometry.Switch(Boolean(True, "Use Sphere"), cube, sphere)

    # To group output
    geo.out()

Parameters:

Name	Type	Description	Default
condition	Boolean	socket 'Switch' (Switch)	None
false		socket 'False' (False)	None
true		socket 'True' (True)	None

Returns:

Type	Description
Socket

Source code in core/socket_class.py

@classmethod
def Switch(cls, condition=None, false=None, true=None):
    """ > Node Switch

    ``` python
    with GeoNodes("Switch demo"):

        # Two possible geometries
        cube   = Mesh.Cube()
        sphere = Mesh.IcoSphere()

        # Select
        geo = Geometry.Switch(Boolean(True, "Use Sphere"), cube, sphere)

        # To group output
        geo.out()
    ```

    Parameters
    ----------
    condition : Boolean
        socket 'Switch' (Switch)

    false
        socket 'False' (False)

    true
        socket 'True' (True)


    Returns
    -------
    Socket
    """
    input_type = SocketType(cls.SOCKET_TYPE).items_type
    return Node('Switch', {'Switch': condition, 'False': false, 'True': true}, input_type=input_type)._out

__init__(socket=None, name=None, tip='', panel='', user_label=None, **props)

Parameters:

Name	Type	Description	Default
socket	NodeSocket	the output socket to wrap default=None.	None
name	str	input name if not None default=None.	None
tip	str	description default="".	''
panel	str	panel name default="".	''
user_label	str	user label default=None.	None

Source code in core/socket_class.py

def __init__(self, 
        socket  = None, 
        name         : str = None, 
        tip          : str = "",
        panel        : str = "",
        user_label   : str = None,
        **props):
    """

    Parameters
    ----------
    socket : NodeSocket, optional
        the output socket to wrap default=None.

    name : str, optional
        input name if not None default=None.

    tip : str, optional
        description default="".

    panel : str, optional
        panel name default="".

    user_label : str, optional
        user label default=None.

    """

    # ---------------------------------------------------------------------------
    # Attributes
    # ---------------------------------------------------------------------------

    self._layout      = None
    self._use_layout  = True
    self._tree        = Tree.current_tree()
    self._bsocket     = None

    self._reset()

    # ---------------------------------------------------------------------------
    # Socket is a Node
    # ---------------------------------------------------------------------------

    if isinstance(socket, Node):
        socket = socket._out

    # ---------------------------------------------------------------------------
    # Empty socket
    # ---------------------------------------------------------------------------

    if utils.request_empty(socket):
        return

    # ---------------------------------------------------------------------------
    # Socket is a string
    # ---------------------------------------------------------------------------

    socktype = self._socket_type
    cname = socktype.class_name

    if isinstance(socket, str):

        # Named attribute (but colors because the string can be the name of a color)
        if (cname in constants.ATTRIBUTE_CLASSES) and (cname != 'Color'):
            self._bsocket = self.Named(socket)._bsocket
            return

    # ---------------------------------------------------------------------------
    # Let's get the socket
    # ---------------------------------------------------------------------------

    self._bsocket = utils.get_bsocket(socket)
    if self._bsocket is not None:

        if self._bsocket.type != self.SOCKET_TYPE:

            # "Bundle Get Item" like nodes : we change the data_type
            node = self.node

            blid = node._bnode.bl_idname
            if blid == 'NodeGetBundleItem'and self.SOCKET_TYPE in utils.get_node_param_enum(blid, 'socket_type'):
                node._bnode.socket_type = self.SOCKET_TYPE
                self._bsocket = utils.get_enabled_bsocket(node, 'Item')

        return

    # ---------------------------------------------------------------------------
    # No name: we create from a constant Node
    # The socket argument is the value to set
    # ---------------------------------------------------------------------------

    if name is None:
        if socktype == 'GEOMETRY':
            new_socket = self.Input(None, halt=False)
            if new_socket is None:
                new_socket = self.NewInput(type(self).__name__)
            self._bsocket = new_socket._bsocket
        else:
            self._bsocket = self.Constant(socket, user_label=user_label)._bsocket

    # ---------------------------------------------------------------------------
    # With a name, we request the creation from current input
    # ---------------------------------------------------------------------------

    else:
        # Font : make sure it is a font 
        if self.SOCKET_TYPE == 'FONT':
            socket = blender.get_font(socket)

        # Socket can be the default value
        if socket is not None:

            if 'default' not in constants.SOCKETS[self._socket_type.type]['props']:
                raise NodeError(f"The {self._socket_type()} socket doesn't accept default value. <{socket}> is not valid.")

            # Perhaps it is given in the props
            def_key = 'default' if 'default' in props else None
            if def_key is None:
                def_key = 'default_value' if 'default_value' in props else None

            if def_key is None:
                props = {'value': socket, **props}

        new_socket = self.NewInput(name, tip=tip, panel=panel, **props)
        self._bsocket = new_socket._bsocket
        self._use_layout = new_socket._use_layout

_create_input_socket(name='Bundle', tip='', panel='', optional_label=False, hide_value=False, hide_in_modifier=False) classmethod

Bundle Input

New Bundle input with subtype 'NONE'.

Parameters:

Name	Type	Description	Default
name	str	Input socket name	`Bundle`
tip	str	Property description	`''`
panel	str	Panel name	``
optional_label	bool	Property optional_label	`False`
hide_value	bool	Property hide_value	`False`
hide_in_modifier	bool	Property hide_in_modifier	`False`

Returns:

Type	Description
Bundle

Source code in core/generated/bundle.py

@classmethod
def _create_input_socket(cls,
    name: str = 'Bundle',
    tip: str = '',
    panel: str = "",
    optional_label: bool = False,
    hide_value: bool = False,
    hide_in_modifier: bool = False,
     ):
    """ > Bundle Input

    New Bundle input with subtype 'NONE'.

    Parameters
    ----------
    name : str, default=`Bundle`
        Input socket name

    tip : str, default=`''`
        Property description

    panel : str, default=``
        Panel name

    optional_label : bool, default=`False`
        Property optional_label

    hide_value : bool, default=`False`
        Property hide_value

    hide_in_modifier : bool, default=`False`
        Property hide_in_modifier


    Returns
    -------
    Bundle
    """
    from ..treeclass import Tree

    return Tree.current_tree().create_input_socket('NodeSocketBundle', name=name, tip=tip, panel=panel,
        optional_label=optional_label, hide_value=hide_value, hide_in_modifier=hide_in_modifier)

_get_bsocket_from_input(name=None)

Get the availble input socket if any.

The socket is get a an OUTPUT socket of the current input.

Parameters:

Name	Type	Description	Default
name	str	name filter default=None.	None

Returns:

Type	Description
Socket	or None if not found

Source code in core/socket_class.py

def _get_bsocket_from_input(self, name: str = None) -> bpy.types.NodeSocket:
    """ Get the availble input socket if any.

    The socket is get a an OUTPUT socket of the current input.

    Parameters
    ----------
    name : str, optional
        name filter default=None.


    Returns
    -------
    Socket
        or None if not found

    """
    in_node = self._tree.get_input_node()

    include = None if name is None else [name]

    bsockets = in_node.get_sockets('OUTPUT', include=include)
    for _, bsock in bsockets:
        if SocketType(bsock).type == self.SOCKET_TYPE:
            return bsock._bsocket
    else:
        return None

_jump(socket, reset=True)

Change the wrapped output socket

When changing the socket, the description is copied to the new socket. The node color, if any, is also propagated.

Parameters:

Name	Type	Description	Default
socket	NodeSocket	the new output socket to jump to	required
reset	bool	reset the cache default=True.	True

Returns:

Type	Description
self

Source code in core/socket_class.py

def _jump(self, socket: bpy.types.NodeSocket, reset: bool = True):
    """ Change the wrapped output socket

    When changing the socket, the description is copied to the new socket.
    The node color, if any, is also propagated.

    Parameters
    ----------
    socket : bpy.types.NodeSocket
        the new output socket to jump to

    reset : bool, optional
        reset the cache default=True.


    Returns
    -------
    self
    """

    # Keep user label stored in socket description
    user_label = self.user_label

    bsocket = utils.get_bsocket(socket)
    if bsocket is None:
        raise NodeError(f"Socket error: Impossible to jump to socket {socket}")

    self._bsocket = bsocket
    if reset:
        self._reset()

    # Restore user label
    self.user_label = user_label


    return self

_lc(label=None, color=None)

Set node label and color.

This method returns self to be chained to as socket:

with GeoNodes("Node label and color"):
    Geometry().out()

    a = Float(10)._lc("Var a")
    b = Float(10)._lc("Var b")
    c = (a + b)._lc("a + b", (1, 0, 0))

Parameters:

Name	Type	Description	Default
label	str	node label default=None.	None
color	SysColor	node color default=None.	None

Returns:

Type	Description
self

Source code in core/socket_class.py

def _lc(self, label: str = None, color: SysColor = None):
    """ Set node label and color.

    This method returns self to be chained to as socket:

    ``` python
    with GeoNodes("Node label and color"):
        Geometry().out()

        a = Float(10)._lc("Var a")
        b = Float(10)._lc("Var b")
        c = (a + b)._lc("a + b", (1, 0, 0))
    ```

    Parameters
    ----------
    label : str, optional
        node label default=None.

    color : SysColor, optional
        node color default=None.


    Returns
    -------
    self
    """

    if self.node._bnode.bl_idname == 'NodeGroupInput':
        return self

    self.node_label = label
    self.node_color = color
    self.user_label = label

    return self

_ul(label)

Set the user label

Parameters:

Name	Type	Description	Default
label	str	the label to append	required

Returns:

Type	Description
self

Source code in core/socket_class.py

def _ul(self, label : str):
    """ Set the user label

    Parameters
    ----------
    label : str
        the label to append


    Returns
    -------
    self
    """
    self.user_label = label
    return self

add_method(name=None, jump=False, ret_class=None, **fixed)

Add the current tree as a method of the Socket class.

Important

The socket instance must be an input socket of the Tree. This input plays the role of self argument.

with GeoNodes("Translate"):
    geo = Geometry()
    v = Vector(0, "Translation)
    geo.transform(translation=v)

    geo.add_method(jump=True)

Once the modifier completed, it can be called as a method of geometry geo.translate(translation=(1, 2, 3))

Parameters:

Name	Type	Description	Default
name	str	replace the default name which is the snake case version of the group name default=None.	None
ret_class	type	transtype the default node output default=None.	None
jump	bool	the calling socket jumps to the node outpus after the call default=False.	False
ret_class	type	transtype the result with this class if not None default=None.	None

Source code in core/socket_class.py

def add_method(self, name: str = None, jump: bool = False, ret_class: type = None, **fixed):
    """ Add the current tree as a method of the Socket class.

    !!! important

        The socket instance must be an input socket of the Tree. This input plays the role of
        self argument.

    ``` python
    with GeoNodes("Translate"):
        geo = Geometry()
        v = Vector(0, "Translation)
        geo.transform(translation=v)

        geo.add_method(jump=True)
    ```

    Once the modifier completed, it can be called as a method of geometry ```geo.translate(translation=(1, 2, 3))```

    Parameters
    ----------
    name : str, optional
        replace the default name which is the snake case version of the group name default=None.

    ret_class : type, optional
        transtype the default node output default=None.

    jump : bool, optional
        the calling socket jumps to the node outpus after the call default=False.

    ret_class : type, optional
        transtype the result with this class if not None default=None.

    """

    if self.node._bnode.bl_idname != 'NodeGroupInput':
        raise NodeError(
            f"'add_method' can be called only from a 'Group Input' socket. "
            "This socket is used a 'self' argument when calling the method of {type(self).__name__}.")

    tree = Tree.current_tree()

    # ---------------------------------------------------------------------------
    # Method Body
    # ---------------------------------------------------------------------------

    socket_rank = self.node._outputs.get_socket_rank(self)
    socket_name = utils.snake_case(self._bsocket.name)


    def call(self_, *args, **kwargs):
        node = Group(tree._btree.name)
        if socket_rank >= len(args):
            new_args = args
            new_kwargs = {socket_name: self_, **kwargs}
        else:
            new_args = args[:socket_rank] + (self_,) + args[socket_rank:]
            new_kwargs = kwargs

        res = node.method_call(*new_args, ret_class=ret_class, **new_kwargs, **fixed)

        if jump:
            return self_._jump(res)
        else:
            return res

    # ---------------------------------------------------------------------------
    # Add the method to the class
    # ---------------------------------------------------------------------------

    if name is None:
        name = tree._btree.name[len(tree._prefix):].strip()
        name = utils.snake_case(name)

    class_ = type(self)
    if name in dir(class_):
        print(f"CAUTION: the method '{name}' (implementing group '{tree._btree.name}') already exists in class {class_}.")

    setattr(class_, name, call)

enable_output(enable=None)

Node Enable Output

Fixed values

Kind	Name	Value
Socket	Value	self
Parameter	data_type	'BUNDLE'

Parameters:

Name	Type	Description	Default
enable	Boolean	socket 'Enable' (id: Enable)	None

Returns:

Type	Description
Bundle

Source code in core/generated/bundle.py

def enable_output(self, enable: Boolean = None):
    """ > Node Enable Output

    **Fixed values**

    | Kind      | Name        | Value      |
    | --------- | ----------- | ---------- |
    | Socket    | Value       | `self`     |
    | Parameter | `data_type` | `'BUNDLE'` |

    Parameters
    ----------
    enable : Boolean, optional
        socket 'Enable' (id: Enable)


    Returns
    -------
    Bundle
    """
    node = Node('Enable Output', {'Enable': enable, 'Value': self}, data_type='BUNDLE')
    return node._out

get_item(path=None, remove=None, socket_type='FLOAT', structure_type='AUTO')

Node Get Bundle Item

Jump : Socket refers to node output socket after the call

Fixed values

Kind	Name	Value
Socket	Bundle	self

Parameters:

Name	Type	Description	Default
path	String	socket 'Path' (id: Path)	None
remove	Boolean	socket 'Remove' (id: Remove)	None
socket_type	Literal['Float', 'Integer', 'Boolean', 'Vector', 'Color', 'Rotation', 'Matrix', 'String', 'Menu', 'Object', 'Image', 'Geometry', 'Collection', 'Material', 'Bundle', 'Closure', 'Font']	parameter socket_type	'FLOAT'
structure_type	Literal['Auto', 'Dynamic', 'Field', 'Grid', 'List', 'Single']	parameter structure_type	'AUTO'

Returns:

Type	Description
Item

Source code in core/generated/bundle.py

def get_item(self,
                path: String = None,
                remove: Boolean = None,
                socket_type: Literal['FLOAT', 'INT', 'BOOLEAN', 'VECTOR', 'RGBA', 'ROTATION', 'MATRIX', 'STRING', 'MENU', 'OBJECT', 'IMAGE', 'GEOMETRY', 'COLLECTION', 'MATERIAL', 'BUNDLE', 'CLOSURE', 'FONT'] = 'FLOAT',
                structure_type: Literal['AUTO', 'DYNAMIC', 'FIELD', 'GRID', 'LIST', 'SINGLE'] = 'AUTO'):
    """ > Node Get Bundle Item

    > ***Jump*** : Socket refers to node output socket after the call

    **Fixed values**

    | Kind   | Name   | Value  |
    | ------ | ------ | ------ |
    | Socket | Bundle | `self` |

    Parameters
    ----------
    path : String, optional
        socket 'Path' (id: Path)

    remove : Boolean, optional
        socket 'Remove' (id: Remove)

    socket_type : Literal['Float', 'Integer', 'Boolean', 'Vector', 'Color', 'Rotation', 'Matrix', 'String', 'Menu', 'Object', 'Image', 'Geometry', 'Collection', 'Material', 'Bundle', 'Closure', 'Font']
        parameter `socket_type`

    structure_type : Literal['Auto', 'Dynamic', 'Field', 'Grid', 'List', 'Single']
        parameter `structure_type`


    Returns
    -------
    Item
    """
    utils.check_enum_arg('Get Bundle Item', 'socket_type', socket_type, 'get_item', ('FLOAT', 'INT', 'BOOLEAN', 'VECTOR', 'RGBA', 'ROTATION', 'MATRIX', 'STRING', 'MENU', 'OBJECT', 'IMAGE', 'GEOMETRY', 'COLLECTION', 'MATERIAL', 'BUNDLE', 'CLOSURE', 'FONT'))
    utils.check_enum_arg('Get Bundle Item', 'structure_type', structure_type, 'get_item', ('AUTO', 'DYNAMIC', 'FIELD', 'GRID', 'LIST', 'SINGLE'))
    node = Node('Get Bundle Item', {'Bundle': self, 'Path': path, 'Remove': remove}, socket_type=socket_type, structure_type=structure_type)
    self._jump(node._out)
    return node.Item

get_signature(with_sockets=False)

Build the closure signature of the node.

Parameters:

Name	Type	Description	Default
with_sockets	bool	include sockets default=False.	False

Returns:

Type	Description
Signature

Source code in core/sock_bundle.py

def get_signature(self, with_sockets: bool = False):
    """ Build the closure signature of the node.

    Parameters
    ----------
    with_sockets : bool, optional
        include sockets default=False.


    Returns
    -------
    Signature
    """
    if self._is_combine:
        return Signature(self.node.get_signature(with_sockets=with_sockets).inputs)
    else:
        raise RuntimeError(f"The Bundle socket {self} doesn't come from a 'Combine Bundle' node. Impossible to get its signature.")

index_switch(*values, index=None, default_index=0)

Node Index Switch

with GeoNodes("index_switch demo") as tree:

    # Create some geometries
    geo    = Geometry()
    cube   = Mesh.Cube()
    sphere = Mesh.IcoSphere()
    cone   = Mesh.Cone()

    # Pick in this list
    pick_geo = geo.index_switch(cube, sphere, cone, index=tree.new_input("Geometry index", default_value=2))

    # Plug the result to the output
    pick_geo.out()

Parameters:

Name	Type	Description	Default
*values	Any	List of Sockets to select into	()
index	Integer	socket 'Index' (Index)	None
default_index	int	default idex	0

Returns:

Type	Description
Socket

Source code in core/socket_class.py

def index_switch(self, *values, index = None, default_index: int = 0):
    """ > Node Index Switch

    ``` python
    with GeoNodes("index_switch demo") as tree:

        # Create some geometries
        geo    = Geometry()
        cube   = Mesh.Cube()
        sphere = Mesh.IcoSphere()
        cone   = Mesh.Cone()

        # Pick in this list
        pick_geo = geo.index_switch(cube, sphere, cone, index=tree.new_input("Geometry index", default_value=2))

        # Plug the result to the output
        pick_geo.out()
    ```

    Parameters
    ----------
    *values : Any
        List of Sockets to select into

    index : Integer, optional
        socket 'Index' (Index)

    default_index : int, default=0
        default idex

    Returns
    -------
    Socket
    """
    return self.IndexSwitch(self, *values, index=index, default_index=default_index)

join(*bundle)

Node Join Bundle

Parameters:

Name	Type	Description	Default
bundle	Bundle	socket 'Bundle' (id: Bundle)	()

Returns:

Type	Description
Bundle

Source code in core/generated/bundle.py

def join(self, *bundle: Bundle):
    """ > Node Join Bundle

    Parameters
    ----------
    bundle : Bundle, optional
        socket 'Bundle' (id: Bundle)


    Returns
    -------
    Bundle
    """
    node = Node('Join Bundle', {'Bundle': [self] + list(bundle)})
    return node._out

join_bundle(*bundle)

Node Join Bundle

Parameters:

Name	Type	Description	Default
bundle	Bundle	socket 'Bundle' (id: Bundle)	()

Returns:

Type	Description
Bundle

Source code in core/generated/bundle.py

def join_bundle(self, *bundle: Bundle):
    """ > Node Join Bundle

    Parameters
    ----------
    bundle : Bundle, optional
        socket 'Bundle' (id: Bundle)


    Returns
    -------
    Bundle
    """
    node = Node('Join Bundle', {'Bundle': [self] + list(bundle)})
    return node._out

link_inputs(from_node=None, from_panel='', *, include=None, exclude=[], panel='')

Link input sockets of the node

Allow to chain input sockets linking.

Source code in core/socket_class.py

def link_inputs(self,
    from_node   : Node = None,
    from_panel  : str = "",
    *,
    include     : list =  None,
    exclude     : list  = [],
    panel       : str = "",
    ):
    """ Link input sockets of the node

    Allow to chain input sockets linking.
    """
    self.node.link_inputs(from_node, from_panel=from_panel, include=include, exclude=exclude, panel=panel)
    return self

link_panel(panel, from_node=None)

Link panel input sockets of the node

Allow to chain input sockets linking.

Source code in core/socket_class.py

def link_panel(self, panel: str, from_node : Node = None):
    """ Link panel input sockets of the node

    Allow to chain input sockets linking.
    """
    self.node.link_panel(panel, from_node=from_node)
    return self

menu_switch(self_name='Self', named_sockets={}, default_menu=None, **sockets)

Node Menu Switch

[&NO_JUMP]

Self is connected to the first menu item with the name provided as argument.

The items of the Menu Switch node are provided in the 'items' dict. An group input socket named after the 'name' argument is linked to menu selector.

Parameters:

Name	Type	Description	Default
named_sockets	dict	sockets to create default={}.	{}
default_menu	str	default menu value default=None.	None
sockets	dict	items	{}

Returns:

Type	Description
Socket

Source code in core/socket_class.py

def menu_switch(self,
            self_name       : str = 'Self', 
            named_sockets   : dict = {},
            default_menu    : str = None,
            **sockets):
    """ > Node Menu Switch

    [&NO_JUMP]

    Self is connected to the first menu item with the name provided as argument.

    The items of the Menu Switch node are provided in the 'items' dict.
    An group input socket named after the 'name' argument is linked to menu selector.

    Parameters
    ----------
    named_sockets : dict, optional
        sockets to create default={}.

    default_menu : str, optional
        default menu value default=None.

    sockets : dict
        items


    Returns
    -------
    Socket
    """        
    return self.MenuSwitch(named_sockets = {self_name: self, **named_sockets}, default_menu=default_menu, **sockets)

out(name=None, panel='', **props)

Plug the value to the Group Output Node.

with GeoNodes("Plug to group output"):
    # Create a cube
    geo = Mesh.Cube()
    # To Group Output geometry as socket named "Cube"
    geo.out("Cube")

The "Do nothing" modifier is simply Geometry().out()

Parameters:

Name	Type	Description	Default
name	str	socket name default=None.	None

Returns:

Type	Description
None

Source code in core/socket_class.py

def out(self, name: str = None, panel: str = "", **props):
    """ Plug the value to the Group Output Node.

    ``` python
    with GeoNodes("Plug to group output"):
        # Create a cube
        geo = Mesh.Cube()
        # To Group Output geometry as socket named "Cube"
        geo.out("Cube")
    ```

    The "Do nothing" modifier is simply ``` Geometry().out() ```

    Parameters
    ----------
    name : str, optional
        socket name default=None.


    Returns
    -------
    None
    """
    self._is_empty(f"Impossible to link an empty socket (name: '{name}').")

    out_node = self._tree.get_output_node()
    out_node.set_input_socket(name=name, value=self, create=True, panel=panel, **props)

repeat(iterations=1, named_sockets={}, **sockets)

Repeat zone

Parameters:

Name	Type	Description	Default
iterations	Integer	iteration socket	1
named_sockets	dict	named sockets	{}
sockets	dict	other sockets	{}

Returns:

Type	Description
ZoneIterator

Source code in core/socket_class.py

def repeat(self, iterations=1, named_sockets: dict={}, **sockets):
    """ Repeat zone

    Parameters
    ----------
    iterations : Integer, default=1
        iteration socket

    named_sockets : dict, default={}
        named sockets

    sockets : dict, optional
        other sockets


    Returns
    -------
    ZoneIterator
    """
    class_name = type(self).__name__
    node = ZoneNode("Repeat", named_sockets={class_name: self, **named_sockets}, Iterations=iterations, **sockets)
    return ZoneIterator(self, node)

separate(signature=None)

Node Separate Bundle

Separate the bundle.

Source code in core/sock_bundle.py

def separate(self, signature: Signature = None):
    """ > Node Separate Bundle

    Separate the bundle.
    """

    # ----------------------------------------------------------------------------------------------------
    # Create the node
    # ----------------------------------------------------------------------------------------------------

    node = Node('Separate Bundle', {'Bundle': self})

    # ----------------------------------------------------------------------------------------------------
    # Applies the signature
    # ----------------------------------------------------------------------------------------------------

    if signature is None and self._is_combine:
        signature = self.get_signature()

    if signature is not None:
        node.set_signature('OUTPUT', signature)

    return node

separate_bundle(named_sockets={}, define_signature=False, **sockets)

Node Separate Bundle

Fixed values

Kind	Name	Value
Socket	Bundle	self

Parameters:

Name	Type	Description	Default
named_sockets	dict	Sockets created with string names	{}
define_signature	bool	parameter define_signature	False
sockets	dict	Socket created with python name attributes	{}

Returns:

Type	Description
node []

Source code in core/generated/bundle.py

def separate_bundle(self, named_sockets: dict = {}, define_signature = False, **sockets):
    """ > Node Separate Bundle

    **Fixed values**

    | Kind   | Name   | Value  |
    | ------ | ------ | ------ |
    | Socket | Bundle | `self` |

    Parameters
    ----------
    named_sockets : dict, default={}
        Sockets created with string names

    define_signature : bool
        parameter `define_signature`

    sockets : dict, default={}
        Socket created with python name attributes

    Returns
    -------
    node []
    """
    node = Node('Separate Bundle', {'Bundle': self, **named_sockets}, define_signature=define_signature, **sockets)
    return node

set_item(path=None, item=None, structure_type='AUTO')

Node Store Bundle Item

Jump : Socket refers to node output socket after the call

Fixed values

Kind	Name	Value
Socket	Bundle	self
Parameter	socket_type	socket_type

Parameters:

Name	Type	Description	Default
path	String	socket 'Path' (id: Path)	None
item	Float	socket 'Item' (id: Item)	None
structure_type	Literal['Auto', 'Dynamic', 'Field', 'Grid', 'List', 'Single']	parameter structure_type	'AUTO'

Returns:

Type	Description
Bundle

Source code in core/generated/bundle.py

def set_item(self,
                path: String = None,
                item: Float = None,
                structure_type: Literal['AUTO', 'DYNAMIC', 'FIELD', 'GRID', 'LIST', 'SINGLE'] = 'AUTO'):
    """ > Node Store Bundle Item

    > ***Jump*** : Socket refers to node output socket after the call

    **Fixed values**

    | Kind      | Name          | Value         |
    | --------- | ------------- | ------------- |
    | Socket    | Bundle        | `self`        |
    | Parameter | `socket_type` | `socket_type` |

    Parameters
    ----------
    path : String, optional
        socket 'Path' (id: Path)

    item : Float, optional
        socket 'Item' (id: Item)

    structure_type : Literal['Auto', 'Dynamic', 'Field', 'Grid', 'List', 'Single']
        parameter `structure_type`


    Returns
    -------
    Bundle
    """
    utils.check_enum_arg('Store Bundle Item', 'structure_type', structure_type, 'set_item', ('AUTO', 'DYNAMIC', 'FIELD', 'GRID', 'LIST', 'SINGLE'))
    socket_type = SocketType(item).class_name
    node = Node('Store Bundle Item', {'Bundle': self, 'Path': path, 'Item': item}, socket_type=socket_type, structure_type=structure_type)
    self._jump(node._out)
    return self._domain_to_geometry

simulation(named_sockets={}, **sockets)

Simulation zone

Parameters:

Name	Type	Description	Default
named_sockets	dict	named sockets	{}
sockets	dict	other sockets	{}

Returns:

Type	Description
ZoneIterator

Source code in core/socket_class.py

def simulation(self, named_sockets: dict={}, **sockets):
    """ Simulation zone

    Parameters
    ----------
    named_sockets : dict, default={}
        named sockets

    sockets : dict, optional
        other sockets

    Returns
    -------
    ZoneIterator
    """
    class_name = type(self).__name__
    node = ZoneNode("Simulation", named_sockets={class_name: self, **named_sockets}, **sockets)
    return ZoneIterator(self, node)

store_item(path=None, item=None, structure_type='AUTO')

Node Store Bundle Item

Jump : Socket refers to node output socket after the call

Fixed values

Kind	Name	Value
Socket	Bundle	self
Parameter	socket_type	socket_type

Parameters:

Name	Type	Description	Default
path	String	socket 'Path' (id: Path)	None
item	Float	socket 'Item' (id: Item)	None
structure_type	Literal['Auto', 'Dynamic', 'Field', 'Grid', 'List', 'Single']	parameter structure_type	'AUTO'

Returns:

Type	Description
Bundle

Source code in core/generated/bundle.py

def store_item(self,
                path: String = None,
                item: Float = None,
                structure_type: Literal['AUTO', 'DYNAMIC', 'FIELD', 'GRID', 'LIST', 'SINGLE'] = 'AUTO'):
    """ > Node Store Bundle Item

    > ***Jump*** : Socket refers to node output socket after the call

    **Fixed values**

    | Kind      | Name          | Value         |
    | --------- | ------------- | ------------- |
    | Socket    | Bundle        | `self`        |
    | Parameter | `socket_type` | `socket_type` |

    Parameters
    ----------
    path : String, optional
        socket 'Path' (id: Path)

    item : Float, optional
        socket 'Item' (id: Item)

    structure_type : Literal['Auto', 'Dynamic', 'Field', 'Grid', 'List', 'Single']
        parameter `structure_type`


    Returns
    -------
    Bundle
    """
    utils.check_enum_arg('Store Bundle Item', 'structure_type', structure_type, 'store_item', ('AUTO', 'DYNAMIC', 'FIELD', 'GRID', 'LIST', 'SINGLE'))
    socket_type = SocketType(item).class_name
    node = Node('Store Bundle Item', {'Bundle': self, 'Path': path, 'Item': item}, socket_type=socket_type, structure_type=structure_type)
    self._jump(node._out)
    return self._domain_to_geometry

switch(condition=None, true=None)

Node Switch

Self is connected to 'false' socket.

Note

switch returns self if global constant SWITCH_JUMP = True (default) set SWITCH_JUMP = False for legacy behavior

with GeoNodes("Switch demo"):

    from geonodes.core import constants
    # Legacy behavior (default is True)
    constants.SWITCH_JUMP = False

    choice = Boolean(True, "Use Sphere")

    # Two possible geometries
    cube   = Mesh.Cube()
    sphere = Mesh.IcoSphere()

    # Select
    # Legacy behavior: cube is unchanged otherwise cube
    geo = cube.switch(choice, sphere)

    # To group output
    geo.out()

Information

• Socket 'False' : self

Parameters:

Name	Type	Description	Default
condition	Boolean	socket 'Switch' (Switch)	None
true		socket 'True' (True)	None

Returns:

Type	Description
Socket(self)

Source code in core/socket_class.py

def switch(self, condition=None, true=None):
    """ > Node Switch

    Self is connected to 'false' socket.

    !!! note
        switch returns self if global constant SWITCH_JUMP = True (default)
        set SWITCH_JUMP = False for legacy behavior

    ``` python
    with GeoNodes("Switch demo"):

        from geonodes.core import constants
        # Legacy behavior (default is True)
        constants.SWITCH_JUMP = False

        choice = Boolean(True, "Use Sphere")

        # Two possible geometries
        cube   = Mesh.Cube()
        sphere = Mesh.IcoSphere()

        # Select
        # Legacy behavior: cube is unchanged otherwise cube
        geo = cube.switch(choice, sphere)

        # To group output
        geo.out()
    ```

    Information
    -----------
    - Socket 'False' : self

    Parameters
    ----------
    condition : Boolean
        socket 'Switch' (Switch)

    true
        socket 'True' (True)


    Returns
    -------
    Socket (self)
    """
    res = self.Switch(condition=condition, false=self, true=true)
    if constants.SWITCH_JUMP:
        return self._jump(res)
    else:
        return res

switch_false(condition=None, false=None)

Node Switch

[&JUMP]

Self is connected to 'true' socket.

Important

This methods behaves the inverse of switch : self is connected to "True" socket and the argument to "False", socket

Note

This method is mainly provided to cover the case when 'False' socket is None

with GeoNodes("Switch demo"):

    geo = Geometry()

    show_geometry = Boolean(False, "Merge with Cube")

    cube = Mesh.Cube()

    geo += cube.switch_false(show_geometry)

    # Is equivalent to
    geo += Geometry.Switch(show_geometry, None, cube)

    # To group output
    geo.out()

Note

This method let self socket unchanged. To set self socket to the result

Information

• Socket 'True' : self

Parameters:

Name	Type	Description	Default
condition	Boolean	socket 'Switch' (Switch)	None
false		socket 'False' (False)	None

Returns:

Type	Description
Socket

Source code in core/socket_class.py

def switch_false(self, condition=None, false=None):
    """ > Node Switch

    [&JUMP]

    Self is connected to 'true' socket.

    !!! important
        This methods behaves the inverse of switch : self is connected to "True" socket and  the argument to "False", socket

    !!! note
        This method is mainly provided to cover the case when 'False' socket is None

    ``` python
    with GeoNodes("Switch demo"):

        geo = Geometry()

        show_geometry = Boolean(False, "Merge with Cube")

        cube = Mesh.Cube()

        geo += cube.switch_false(show_geometry)

        # Is equivalent to
        geo += Geometry.Switch(show_geometry, None, cube)

        # To group output
        geo.out()
    ```

    !!! note
        This method let self socket unchanged. To set self socket to the result

    Information
    -----------
    - Socket 'True' : self

    Parameters
    ----------
    condition : Boolean
        socket 'Switch' (Switch)

    false
        socket 'False' (False)


    Returns
    -------
    Socket
    """
    res = self.Switch(condition=condition, false=false, true=self)
    if constants.SWITCH_JUMP:
        return self._jump(res)
    else:
        return res