Python TreeDict.update方法代码示例

# 需要导入模块: from treedict import TreeDict [as 别名]
# 或者: from treedict.TreeDict import update [as 别名]
 def addSequence(self, sequence, replacement_dict = TreeDict(), position = None):
     """
     Insert a subsequence, position is either time or None to insert at the 
     end
     """
     if sequence not in self.required_subsequences:
         message = "Adding subsequence {0} that is not listed in the required subequences"
         raise Exception (message.format(sequence.__class__.__name__))
     if not type(replacement_dict) == TreeDict:
         raise Exception ("replacement_dict must be a TreeDict")
     for replacement_key in replacement_dict.keys():
         parsed = tuple(replacement_key.split('.'))
         key_list = self.replaced_parameters.get(sequence, [])
         if not parsed in key_list:
             message = "Error in {0}: replacing the key {1} in the sequence {2} that is not listed among the replacement parameters"
             raise Exception(message.format(self, replacement_key, sequence))
     if position is None:
         position = self.end
     # replacement conists of global replacement and keyword arguments
     replacement = TreeDict()
     replacement.update(self.replace)
     replacement.update(replacement_dict)
     seq = sequence(replacement, start = position)
     self._dds_pulses.extend( seq._dds_pulses )
     self._ttl_pulses.extend( seq._ttl_pulses )
     self.end = max(self.end, seq.end)

# 需要导入模块: from treedict import TreeDict [as 别名]
# 或者: from treedict.TreeDict import update [as 别名]
    def checkUpdate_09_ProperParents(self, deep_copy, overwrite, preserve_structure):

        p = TreeDict()

        ab = p.a.b = unique_object()
        ac = p.a.c = unique_object()
        b  = p.b   = unique_object()

        p2 = TreeDict()

        p2.update(p)

        self.assert_(p.a is not p2.a)
        self.assert_(p.a.rootNode() is p)
        self.assert_(p.a.parentNode() is p)
        self.assert_(p2.a.rootNode() is p2)
        self.assert_(p2.a.parentNode() is p2)

        self.assert_(p.a.b == p2.a.b)
        self.assert_(p.a.b is p2.a.b)
        
        self.assert_(p.a.c == p2.a.c)
        self.assert_(p.a.c is p2.a.c)
            
        self.assert_(p == p2)

# 需要导入模块: from treedict import TreeDict [as 别名]
# 或者: from treedict.TreeDict import update [as 别名]
    def testFromdict_with_get_02(self):
        t1 = TreeDict.fromdict({'a':1,'b':2})
        
        t2 = TreeDict()
        t2.update({'a':1,'b':2})

        self.assert_(t1 == t2)

# 需要导入模块: from treedict import TreeDict [as 别名]
# 或者: from treedict.TreeDict import update [as 别名]
    def testDictBehavior_10_straight_iteration(self):
        p = TreeDict()

        d = {'a.b.x' : 1, 'b.x' : 2, 'd.b.c' : 3}

        p.update(d)

        s1 = set([v for v in d])
        s2 = set([v for v in p])

        self.assert_(s1 == s2, (s1, s2))

# 需要导入模块: from treedict import TreeDict [as 别名]
# 或者: from treedict.TreeDict import update [as 别名]
    def checkUpdate_15_DanglingNodesAttached(self, overwrite, protect_structure):
        p = TreeDict()
        a = p.a

        q = TreeDict()
        q.a.x = 1

        p.update(q, overwrite=overwrite, protect_structure =protect_structure)

        self.assert_(p.a.x == 1)
        self.assert_(a is p.a)
        self.assert_(a.rootNode() is p)

# 需要导入模块: from treedict import TreeDict [as 别名]
# 或者: from treedict.TreeDict import update [as 别名]
    def testIterators_13_Large(self):

        n_iter = 300
        n_node = 300

        tml = random_node_list(122, n_node, 0.75)

        random.seed(0)

        p = TreeDict()
        
        p.update(dict((t, 1) for t in tml))

        # set up a list of iterators
        def newIter():
            recursive = random.random() < 0.7
            brv = random.random()
            if 0 <= brv <= 0.33:
                branch_mode = "all"
            elif 0.33 < brv <= 0.66:
                branch_mode = "only"
            else:
                branch_mode = "none"

            irv = random.random()
            if 0 <= brv <= 0.33:
                return p.iterkeys(recursive, branch_mode)
            elif 0.33 < brv <= 0.66:
                return p.itervalues(recursive, branch_mode)
            else:
                return p.iteritems(recursive, branch_mode)

        iter_list = [newIter() for i in xrange(n_iter)]

        while len(iter_list) > 0:

            del_queue = []

            for i, it in enumerate(iter_list):
                try:
                    it.next()
                except StopIteration:
                    self.assert_(p._iteratorRefCount() <= len(iter_list))
                    del_queue.append(i)

            for i in sorted(del_queue, reverse=True):
                del iter_list[i]

        # Now make sure that everything is cool
        self.assert_(p._iteratorRefCount() == 0, p._iteratorRefCount())

        for tm in tml:
            p.pop(tm)

# 需要导入模块: from treedict import TreeDict [as 别名]
# 或者: from treedict.TreeDict import update [as 别名]
    def testUpdate_WithFreezing_StructureOnly_01(self):

        p = TreeDict()
        
        p.a = 1
        p.freeze(structure_only = True)

        q = TreeDict()
        q.a = 2

        p.update(q)

        self.assert_(p.a == 2)

# 需要导入模块: from treedict import TreeDict [as 别名]
# 或者: from treedict.TreeDict import update [as 别名]
def clean(custom_opttree = None, **kwargs):
    
    if custom_opttree is None:
        custom_opttree = TreeDict()
        
    custom_opttree.update(TreeDict.fromdict(kwargs))
    
    __initLoggingSystem(custom_opttree)

    log = logging.getLogger("Configuration")
    opttree = configuration.setupOptionTree(custom_opttree, log, False)

    loading.cleanAll(opttree)

# 需要导入模块: from treedict import TreeDict [as 别名]
# 或者: from treedict.TreeDict import update [as 别名]
    def testUpdate_WithFreezing_ValuesOnly_02(self):

        p = TreeDict()

        p.a.b = 1
        p.freeze(values_only=True)

        q = TreeDict()
        q.a.c = 2

        p.update(q)

        self.assert_(p.a.b == 1)
        self.assert_(p.a.c == 2)

# 需要导入模块: from treedict import TreeDict [as 别名]
# 或者: from treedict.TreeDict import update [as 别名]
    def testUpdate_WithFreezing_01(self):

        p = TreeDict()
        
        p.a.x = 1

        q = TreeDict()

        q.b = 2

        p.update(q)

        self.assert_(p.a.x == 1)
        self.assert_(p.b == 2)

# 需要导入模块: from treedict import TreeDict [as 别名]
# 或者: from treedict.TreeDict import update [as 别名]
    def testUpdate_10_rewritingLocal(self):

        # This test solidifies the following behavior

        p = TreeDict()
        p.a = TreeDict()

        q = TreeDict()
        q.a.x = 1

        p.update(q)

        self.assert_(p.a.isRoot())
        self.assert_(p.a.x == 1)

# 需要导入模块: from treedict import TreeDict [as 别名]
# 或者: from treedict.TreeDict import update [as 别名]
	def addSequence(self, sequence, replacement_dict = TreeDict(), position = None):
		'''insert a subsequence, position is either time or None to insert at the end'''
		#position where sequence is inserted
		if sequence not in self.required_subsequences: raise Exception ("Adding subsequence {0} that is not listed in the required subequences".format(sequence.__class__.__name__))
		if not type(replacement_dict) == TreeDict: raise Exception ("replacement_dict must be a TreeDict")
		if position is None:
			position = self.end
		#replacement conists of global replacement and keyword arguments
		replacement = TreeDict()
		replacement.update(self.replace)
		replacement.update(replacement_dict)
		seq = sequence(replacement, start = position)
		self._dds_pulses.extend( seq._dds_pulses )
		self._ttl_pulses.extend( seq._ttl_pulses )
		self.end = max(self.end, seq.end)

# 需要导入模块: from treedict import TreeDict [as 别名]
# 或者: from treedict.TreeDict import update [as 别名]
    def testUpdate_WithFreezing_StructureOnly_04(self):

        p = TreeDict()
        
        p.a.x = 1
        p.freeze('a', structure_only = True)

        q = TreeDict()
        q.a.x = 2
        q.b = 3

        p.update(q)

        self.assert_(p.a.x == 2)
        self.assert_(p.b == 3)

# 需要导入模块: from treedict import TreeDict [as 别名]
# 或者: from treedict.TreeDict import update [as 别名]
 def addSequence(self, sequence, replacement_dict = TreeDict(), position = None):
     '''insert a subsequence, position is either time or None to insert at the end'''
     #if not type(replacement_dict) == TreeDict: raise Exception ("replacement_dict must be a TreeDict")
     if position is None:
         position = self.end
     #replacement conists of global replacement and keyword arguments
     replacement = TreeDict()
     replacement.update(self.replace)
     replacement.update(replacement_dict)
     seq = sequence(replacement, start = position)
     self._dds_pulses.extend( seq._dds_pulses )
     #print 'heres the seq pulses'
     #print seq._ttl_pulses
     self._ttl_pulses.extend( seq._ttl_pulses )
     self.end = max(self.end, seq.end)

# 需要导入模块: from treedict import TreeDict [as 别名]
# 或者: from treedict.TreeDict import update [as 别名]
def initialize(custom_opttree = None, **kwargs):
    global __manager

    if __manager is not None:
        raise RuntimeError("Initialize has already been called!  Call reset first to reinitialize.")

    # fill in the custom opt_tree here with default options.
    if custom_opttree is None:
        custom_opttree = TreeDict()

    custom_opttree.update(TreeDict.fromdict(kwargs)) 
    
    __initLoggingSystem(custom_opttree)

    # set up the manager    
    __manager = _RunManager(custom_opttree)