Collaboration diagram for python.Node.Node:

Public Member Functions
	__init__ (self, name="root", flags=None, root=None)
	__setattr__ (self, name, value)
	__getattribute__ (self, name)
	__getattr__ (self, name)
	__contains__ (self, name)
	__copy__ (self)
	__delattr__ (self, name)
	__delitem__ (self, name)
	lock (self, lockstate=_LOCKED)
	unlock (self)
	lock_forever (self)
	islocked (self)
	locked (self)
	name (self)
	add (self, attr_name, value)
	addFlag (self, tag, value, flags=None)
	addNode (self, item, flags=None)
	has (self, name)
	hasFlag (self, name)
	hasNode (self, name)
	nodes (self)
	node_flags (self)
	node (self, name)
	delete (self, name)
	rename (self, name, newname)
	clone (self, name=None)
	print (self, spacer="")
	dump (self)
	cloneAndReplace (self, targetname, flagname)

Protected Member Functions
	_fail_if_locked_forever (self)
	_fail_if_locked (self)
	_loadflags (self, name)
	_addDynaFlags (self, name)
	_stragglers (self, flags, dbg="")
	_rootnode (self)
	_setrootnode (self, rootnode)
	_addFlagImpl (self, tag, value, flags=None, unlock=False)
	_addFlagUnlock (self, tag, value, flags=None)
	_addNewNode (self, str name, flags=None)
	_addNode (self, node)
	_hasFlagPath (self, name)

Protected Attributes
raise AttributeError(f)	_children
return self._root._loadflags(name)	_root
	_lockstate = _LOCKED:

Private Attributes
raise AttributeError(f)	__dict__

Detailed Description

Basic node class, so we can get all the egregious flags from a
flags object, and use, and pass round, the individual nodes, as
actual nodes without all the nonsense limitations of using the
flags directly

Definition at line 52 of file Node.py.

Constructor & Destructor Documentation

◆ init()

python.Node.Node.__init__	(	self,
		name = "root",
		flags = None,
		root = None )

Definition at line 60 of file Node.py.

    def __init__(self, name="root", flags=None, root=None ):
        object.__setattr__(self, "_lockstate", _UNLOCKED)
        object.__setattr__(self, "_name", name)
        object.__setattr__(self, "_children", {})
        object.__setattr__(self, "_flags", flags)
        object.__setattr__(self, "_root", root)
 

Member Function Documentation

◆ contains()

python.Node.Node.__contains__	(		self,
			name )

Definition at line 98 of file Node.py.

    def __contains__(self, name):
        return self.has(name)
 

◆ copy()

python.Node.Node.__copy__ ( self )

Definition at line 101 of file Node.py.

    def __copy__(self):
        return self.clone()
 

◆ delattr()

python.Node.Node.__delattr__	(		self,
			name )

Definition at line 104 of file Node.py.

    def __delattr__(self, name):
        self.delete(name)
 

◆ delitem()

python.Node.Node.__delitem__	(		self,
			name )

Definition at line 107 of file Node.py.

    def __delitem__(self, name):
        self.delete(name)
 

◆ getattr()

python.Node.Node.__getattr__	(		self,
			name )

will attempt a dynamic load from flags if need be

Definition at line 83 of file Node.py.

    def __getattr__(self, name):
        """ will attempt a dynamic load from flags if need be """
        if name in self._children : return self._children[name]
        if self._root :
            if self._root._loadflags( f"{self.name()}.{name}" ) :
                if name in self._children : return self._children[name]
            if name in self._root._children : return self._root._children[name]
            if self._root._loadflags( name ) :
                if name in self._root._children : return self._root._children[name]
        else:
            if self._loadflags( name ) :
                if name in self._children : return self._children[name]
                
        raise AttributeError(f"no attribute {name}")
 

◆ getattribute()

python.Node.Node.__getattribute__	(		self,
			name )

Definition at line 76 of file Node.py.

    def __getattribute__(self, name):
        value = object.__getattribute__(self, name)        
        if type(value).__name__ == "CfgFlag": 
            flags = object.__getattribute__(self, "_flags")
            return value.get(flags)
        return value
 

◆ setattr()

python.Node.Node.__setattr__	(	self,
		name,
		value )

Definition at line 67 of file Node.py.

    def __setattr__(self, name, value):
        self._fail_if_locked()
        if name in self._children : raise AttributeError(f"node {name} already exists")  
        current = self.__dict__.get(name)
        if type(current).__name__ == "CfgFlag":
            current.set(value)
        else:
            object.__setattr__(self, name, value) 
            

◆ _addDynaFlags()

python.Node.Node._addDynaFlags	(		self,
			name )

protected

Definition at line 155 of file Node.py.

    def _addDynaFlags(self, name) :
        flags = self._flags
        self._flags._loadDynaFlags(name)
        return self._stragglers(flags)
        

◆ _addFlagImpl()

python.Node.Node._addFlagImpl	(	self,
		tag,
		value,
		flags = None,
		unlock = False )

protected

addFlag method like that in the egregious flags

Definition at line 182 of file Node.py.

    def _addFlagImpl(self, tag, value, flags=None, unlock=False):
        """ addFlag method like that in the egregious flags """
        node = self
        if flags is not None and self._flags is None : node._flags = flags
        names = tag.split(".")
        for name in names[:-1]:
            node = node._addNewNode(name, flags )
            if unlock : object.__setattr__( node, "_lockstate", _UNLOCKED )
        if flags is not None : node._flags = flags
        if names[-1] in node.__dict__ : return False
        # just use a value at the moment, can use CfgFlag(value, type) if we really have to(
        setattr(node, names[-1], value)
        return True
 

◆ _addFlagUnlock()

python.Node.Node._addFlagUnlock	(	self,
		tag,
		value,
		flags = None )

protected

Definition at line 200 of file Node.py.

    def _addFlagUnlock(self, tag, value, flags=None):
        self._addFlagImpl( tag, value, flags, True )
 

◆ _addNewNode()

python.Node.Node._addNewNode	(		self,
		str	name,
			flags = None )

protected

add a new child node

Definition at line 208 of file Node.py.

    def _addNewNode(self, name : str, flags=None):
        """ add a new child node """
        self._fail_if_locked()
        if name in self.__dict__: raise AttributeError(f"attribute {name} already exists")
        rootnode = self._rootnode()
        if name not in self._children :
            self._children[name] = ( node := Node(name, root=rootnode) )
            if flags is not None : node._flags = flags
        return self._children[name]
 

◆ _addNode()

python.Node.Node._addNode	(		self,
			node )

protected

an en existing node as a child node

Definition at line 218 of file Node.py.

    def _addNode(self, node ):
        """ an en existing node as a child node """
        self._fail_if_locked()
        name = node.name()
        if name in self.__dict__: raise AttributeError(f"attribute {name} already exists")
        rootnode = self._rootnode()
        if name not in self._children :
            if node._root and rootnode is not node._root :
                raise RuntimeError(f"cannot add node {name} from a different tree")
            self._children[node.name()] = node
            if not node._root : node._setrootnode( rootnode )
        return  self._children[node.name()]
 

◆ _fail_if_locked()

python.Node.Node._fail_if_locked ( self )

protected

Definition at line 132 of file Node.py.

    def _fail_if_locked(self):
        if self._lockstate == _LOCKED : raise RuntimeError(f"Node {self._name} is locked; ")
        if self._lockstate == _LOCKED_FOREVER : raise RuntimeError(f"Node {self._name} is permanently locked; ")
 

◆ _fail_if_locked_forever()

python.Node.Node._fail_if_locked_forever ( self )

protected

Definition at line 129 of file Node.py.

    def _fail_if_locked_forever(self):
        if self._lockstate == _LOCKED_FOREVER : raise RuntimeError(f"Node {self._name} is permanently locked; ")
 

◆ _hasFlagPath()

python.Node.Node._hasFlagPath	(		self,
			name )

protected

Definition at line 240 of file Node.py.

    def _hasFlagPath(self, name):
        parts = name.split('.')
        node = self._rootnode()       
        for part in parts[:-1]:
            if not node.hasNode(part) : return False
            node = node.node(part)
        return node.hasFlag(parts[-1])
 

◆ _loadflags()

python.Node.Node._loadflags	(		self,
			name )

protected

load dynamic flags - can only load flags on the root node

Definition at line 136 of file Node.py.

    def _loadflags(self, name ) :
        """ load dynamic flags - can only load flags on the root node """
 
        if self._root : return self._root._loadflags( name )
 
        flags = self._flags
        if flags is None : raise AttributeError(f"no attribute {name}")
        lockstate = self._lockstate
        object.__setattr__(self, "_lockstate", _UNLOCKED)
        try:
            if name in flags._loaded    : return self._stragglers(flags)
            if name in flags._dynaflags : return self._addDynaFlags(name)
            for key in flags._dynaflags :
                if name in key : return self._addDynaFlags(key)
            return False
        finally:
            # ensure the lock state is restored if something goes wrong ...
            if lockstate != _UNLOCKED : self.lock(lockstate)
 

◆ _rootnode()

python.Node.Node._rootnode ( self )

protected

Definition at line 166 of file Node.py.

    def _rootnode(self):
        if self._root : return self._root
        return self
 

◆ _setrootnode()

python.Node.Node._setrootnode	(		self,
			rootnode )

protected

Definition at line 170 of file Node.py.

    def _setrootnode(self, rootnode ):
        if self._root is rootnode : return 
        object.__setattr__(self, "_root", rootnode )
        for node in self.nodes() : node._setrootnode(rootnode)
            

◆ _stragglers()

python.Node.Node._stragglers	(	self,
		flags,
		dbg = "" )

protected

Definition at line 160 of file Node.py.

    def _stragglers(self, flags, dbg="") :
        for key, val in self._flags._flagdict.items() :
            if self._hasFlagPath(key) : continue
            self._addFlagUnlock( key, val, flags )
        return True
        

◆ add()

python.Node.Node.add	(	self,
		attr_name,
		value )

add an attribute to this node

Definition at line 178 of file Node.py.

    def add(self, attr_name, value):
        """ add an attribute to this node """
        setattr(self, attr_name, value)
 

◆ addFlag()

python.Node.Node.addFlag	(	self,
		tag,
		value,
		flags = None )

Definition at line 196 of file Node.py.

    def addFlag(self, tag, value, flags=None):
        if not self._addFlagImpl( tag, value, flags, False ):
            raise  KeyError(f"flag {tag} already exists")
 

◆ addNode()

python.Node.Node.addNode	(	self,
		item,
		flags = None )

Definition at line 203 of file Node.py.

    def addNode( self, item, flags=None):
        if isinstance(item, Node) : return self._addNode(item)
        if isinstance(item, str)  : return self._addNewNode(item, flags)
        raise TypeError(f"Cannot construct node from type {type(item).__name__}, value {item}")
        

◆ clone()

python.Node.Node.clone	(		self,
			name = None )

Return an independent copy" of this node

Definition at line 275 of file Node.py.

    def clone(self, name=None):
        """Return an independent copy" of this node"""
 
        if name is not None : newnode = Node(name)
        else:                 newnode = Node(self._name)
 
        for key, value in self.__dict__.items():
            if key in {"_name", "_children", "_lockstate", "_root" } : continue
            setattr(newnode, key, value)
 
        for node in self.nodes():
            child = node.clone()
            child._root = None
            newnode._addNode(child)
 
        return newnode
 
    

◆ cloneAndReplace()

python.Node.Node.cloneAndReplace	(	self,
		targetname,
		flagname )

Definition at line 306 of file Node.py.

    def cloneAndReplace(self, targetname, flagname ) :
        # we really, really, should not have this ...
        warnings.warn( "cloneAndReplace() is unnecessary for Node flags; "
                       "use the appropriate Node directly",
                       RuntimeWarning,  stacklevel=2 )
        # eventually, instead of delegation, should raise an exception ...
        # raise RuntimeError( "cloneAndReplace() should not be used for node flags" )
        return self._rootnode()._flags.cloneAndReplace( targetname, flagname )
 
        

◆ delete()

python.Node.Node.delete	(		self,
			name )

Definition at line 260 of file Node.py.

    def delete(self, name):
        self._fail_if_locked()
        if name in self._children  : del  self._children[name]
        elif name in self.__dict__ : object.__delattr__(self, name) # delattr( self, name )
        else : raise AttributeError(f"Node {self._name} has no member {name}")
 

◆ dump()

python.Node.Node.dump ( self )

Definition at line 303 of file Node.py.

    def dump(self): self.print()
 
        

◆ has()

python.Node.Node.has	(		self,
			name )

Definition at line 231 of file Node.py.

    def has(self, name ):
        return hasattr( self, name )
 

◆ hasFlag()

python.Node.Node.hasFlag	(		self,
			name )

Definition at line 234 of file Node.py.

    def hasFlag(self, name ):
        return name in self.__dict__
 

◆ hasNode()

python.Node.Node.hasNode	(		self,
			name )

Definition at line 237 of file Node.py.

    def hasNode(self, name):
        return name in self._children
 

◆ islocked()

python.Node.Node.islocked ( self )

Definition at line 123 of file Node.py.

    def islocked(self):
        return self._lockstate != _UNLOCKED
 

◆ lock()

python.Node.Node.lock	(		self,
			lockstate = _LOCKED )

Definition at line 110 of file Node.py.

    def lock(self, lockstate=_LOCKED):
        for node in self.nodes() : node.lock(lockstate)
        object.__setattr__(self, "_lockstate", lockstate)
                           

◆ lock_forever()

python.Node.Node.lock_forever ( self )

Definition at line 120 of file Node.py.

    def lock_forever(self):
        self.lock(_LOCKED_FOREVER) 
 

◆ locked()

python.Node.Node.locked ( self )

Definition at line 126 of file Node.py.

    def locked(self):
        return self.islocked()
 

◆ name()

python.Node.Node.name ( self )

Definition at line 175 of file Node.py.

    def name(self) :
        return self._name
 

◆ node()

python.Node.Node.node	(		self,
			name )

Definition at line 256 of file Node.py.

    def node(self, name):
        if self.hasNode(name) : return self._children[name]
        raise RuntimeError(f"So such child: {name}")
 

◆ node_flags()

python.Node.Node.node_flags ( self )

Definition at line 251 of file Node.py.

    def node_flags(self):
        for key, value in self.__dict__.items():
            if not key.startswith("_"):
                yield key, getattr(self, key)
      

◆ nodes()

python.Node.Node.nodes ( self )

Definition at line 248 of file Node.py.

    def nodes(self):
        return self._children.values()
 

◆ print()

python.Node.Node.print	(		self,
			spacer = "" )

Definition at line 293 of file Node.py.

    def print(self, spacer=""):
        print( f"{spacer}{self._name} (Node)" )
        if    spacer=="" : spacer = "|__ "
        else: spacer=f"    {spacer}"
        for key, value in self.__dict__.items():
            if key in {"_name","_children","_lockstate", "_flags", "_root"} : continue 
            print( f"{spacer}{key}\t:  {value}" )
        for node in self.nodes() : node.print( spacer )
 
        

◆ rename()

python.Node.Node.rename	(	self,
		name,
		newname )

Definition at line 266 of file Node.py.

    def rename( self, name, newname ):
        if newname in self._children or newname in self.__dict__ :
            raise RuntimeError(f"name {newname} already in node")
 
        if name in self.__dict__: setattr(self, newname, self.__dict__.pop(name) )
        elif name in self._children :
            self._children[newname] = ( node := self._children.pop(name) )
            node._name = newname
    

◆ unlock()

python.Node.Node.unlock ( self )

Definition at line 114 of file Node.py.

    def unlock(self):
        self._fail_if_locked_forever()
        if self._lockstate == _LOCKED:
             object.__setattr__(self, "_lockstate", _UNLOCKED)
             for node in self.nodes(): node.unlock()
                     

Member Data Documentation

◆ dict

raise AttributeError(f) python.Node.Node.__dict__

private

Definition at line 211 of file Node.py.

◆ _children

raise AttributeError(f) python.Node.Node._children

protected

Definition at line 69 of file Node.py.

◆ _lockstate

python.Node.Node._lockstate = _LOCKED:

protected

Definition at line 116 of file Node.py.

◆ _root

return self._root._loadflags( name ) python.Node.Node._root

protected

Definition at line 86 of file Node.py.

The documentation for this class was generated from the following file:

Node.py

Public Member Functions

Protected Member Functions

Protected Attributes

Private Attributes

Detailed Description

Constructor & Destructor Documentation

◆ __init__()

Member Function Documentation

◆ __contains__()

◆ __copy__()

◆ __delattr__()

◆ __delitem__()

◆ __getattr__()

◆ __getattribute__()

◆ __setattr__()

◆ _addDynaFlags()

◆ _addFlagImpl()

◆ _addFlagUnlock()

◆ _addNewNode()

◆ _addNode()

◆ _fail_if_locked()

◆ _fail_if_locked_forever()

◆ _hasFlagPath()

◆ _loadflags()

◆ _rootnode()

◆ _setrootnode()

◆ _stragglers()

◆ add()

◆ addFlag()

◆ addNode()

◆ clone()

◆ cloneAndReplace()

◆ delete()

◆ dump()

◆ has()

◆ hasFlag()

◆ hasNode()

◆ islocked()

◆ lock()

◆ lock_forever()

◆ locked()

◆ name()

◆ node()

◆ node_flags()

◆ nodes()

◆ print()

◆ rename()

◆ unlock()

Member Data Documentation

◆ __dict__

◆ _children

◆ _lockstate

◆ _root

◆ init()

◆ contains()

◆ copy()

◆ delattr()

◆ delitem()

◆ getattr()

◆ getattribute()

◆ setattr()

◆ dict