Пример #1
0
 def test_static_required_extraction_success(self):
     # if static dict is required, dict values must not be empty
     widget = factory(
         'error:dict',
         name='mydict',
         value=odict([('k1', 'v1')]),
         props={
             'required': True,
             'static': True,
             'key_label': 'Key',
             'value_label': 'Value'
         })
     # check valid extraction
     request = {
         'mydict.exists': '1',
         'mydict.entry0.value': 'Value1',
     }
     data = widget.extract(request=request)
     self.assertFalse(data.has_errors)
     self.assertEqual(
         data.extracted,
         odict([('k1', 'Value1')])
     )
     # check rendered
     rendered = widget(data=data)
     expected = '<div class="errormessage">'
     self.assertFalse(rendered.find(expected) > -1)
     expected = 'name="mydict.entry0.value" type="text" value="Value1"'
     self.assertTrue(rendered.find(expected) > -1)
Пример #2
0
def parse_override_function(myclasses_array_dict):
	while True:
		should_be_continue = False
		for class_name, one_myclass in myclasses_array_dict.iteritems():
			my_supers = one_myclass[const.m_dict['super']]

			# setup self's override set
			override_set = set()
			if not one_myclass.has_key(const.override_all):
				one_myclass[const.override_all] = False
				for over_function in one_myclass[const.m_dict['override']]:
					if over_function[const.func.name] == const.override_all:
						one_myclass[const.override_all] = True
						break
					override_set.add(over_function[const.func.name])
					# also snap super's free|destructor
					override_set.add(const.member_destructor[const.func.name])
					override_set.add(const.member_free[const.func.name])

			# traverse all super's vtable, try-match my override-func
			for super_name in my_supers.keys():
				super_class = convert_to_class(myclasses_array_dict, super_name)
				# create new inherit-vtable
				if (not my_supers[super_name].has_key(super_name)) \
					and super_class[const.m_dict['virtual']]:
					should_be_continue = True
					my_supers[super_name][super_name] = odict()
					my_supers[super_name][super_name]['path'] = super_name
					my_supers[super_name][super_name][const.control_super] = False
					v_func_list = []
					if not my_supers[super_name][super_name].has_key(const.m_dict['virtual']):
						my_supers[super_name][super_name][const.m_dict['virtual']] = v_func_list

					# check override function
					for v_function in super_class[const.m_dict['virtual']]:
						if one_myclass[const.override_all] \
							or v_function[const.func.name] in override_set:
							v_func_list.append(v_function)

				# clone inherit-vtable from supers
				super2_supers = super_class[const.m_dict['super']]
				for super2_name, super2_class in super2_supers.iteritems():
					for super2_vtable_name, super2_vtable in super2_class.iteritems():
						if not my_supers[super_name].has_key(super2_vtable_name):
							should_be_continue = True
							vtable_class = convert_to_class(myclasses_array_dict, super2_vtable_name)
							my_supers[super_name][super2_vtable_name] = odict()
							my_supers[super_name][super2_vtable_name]['path'] = super_name + '.' + super2_vtable['path']
							my_supers[super_name][super2_vtable_name][const.control_super] = False
							v_func_list = []
							if not my_supers[super_name][super2_vtable_name].has_key(const.m_dict['virtual']):
								my_supers[super_name][super2_vtable_name][const.m_dict['virtual']] = v_func_list

							# check override function
							for v_function in vtable_class[const.m_dict['virtual']]:
								if v_function[const.func.name] in override_set:
									v_func_list.push(v_function)

		if not should_be_continue:
			break
Пример #3
0
    def __call__(self, track, *args ):
        """count number of entries in a table."""

        config = ConfigParser.ConfigParser()
        config.readfp(open(track),"r")

        result = odict()

        def convert( value ):
            '''convert a value to int, float or str.'''
            rx_int = re.compile("^\s*[+-]*[0-9]+\s*$")
            rx_float = re.compile("^\s*[+-]*[0-9.]+[.+\-eE][+-]*[0-9.]*\s*$")

            if value == None: return value

            if rx_int.match( value ):
                return int(value), "int"
            elif rx_float.match( value ):
                return float(value), "float"
            return value, "string"

        for section in config.sections():
            x = odict()
            for key,value in config.items( section ):
                x[key] = odict( zip( ("value", "type" ), convert( value )) )
            result[section] = x
        
        return result
Пример #4
0
def convert_namespace_to_tree(def_path, input_dict):
	mysuper = odict()
	context_dict_tree = odict()

	# file header or comments
	mysuper['file_note'] = get_value_else_default(input_dict, 'file_note', False)
	mysuper['trace']     = get_value_else_default(input_dict, 'trace',     False)
	mysuper['copyright'] = get_value_else_default(input_dict, 'copyright', [])
	mysuper['author']    = get_value_else_default(input_dict, 'author',    []) # author with email
	mysuper['date']      = get_value_else_default(input_dict, 'date',      strftime("%Y-%m-%d", gmtime()))
	mysuper['summary']   = get_value_else_default(input_dict, 'summary',   [])
	mysuper['note']      = get_value_else_default(input_dict, 'note',      [])
	mysuper['comment']   = get_value_else_default(input_dict, 'comment',   [])
	mysuper['message']   = get_value_else_default(input_dict, 'message',   '')
	mysuper['error']     = get_value_else_default(input_dict, 'error',     '')

	# generate path
	mysuper['path']      = get_value_else_default(input_dict, 'path',      def_path)
	mysuper['namespace'] = get_value_else_default(input_dict, 'namespace', def_path)

	mysuper[const.config_super] = 'False'
	mysuper[const.config_destructor] = 'False'
	mysuper[const.m_dict['super']]   = []
	if input_dict.has_key(const.classes):
		convert_to_myclasses(context_dict_tree, input_dict[const.classes], mysuper)
	else:
		raise Exception('json source no "{0}"'.format(const.classes))

	return context_dict_tree
Пример #5
0
def etud_get_poursuite_info(context, sem, etud):
    """{ 'nom' : ..., 'semlist' : [ { 'semestre_id': , 'moy' : ... }, {}, ...] }
    """
    I = {}
    I.update(etud) # copie nom, prenom, sexe, ...
    
    # Now add each semester, starting from the first one
    semlist = []
    current_id = sem['semestre_id']
    for sem_id in range(1, current_id+1):
        sem_descr = None
        for s in etud['sems']:
            if s['semestre_id'] == sem_id:
                etudid = etud['etudid']
                nt = context._getNotesCache().get_NotesTable(context, s['formsemestre_id'])
                dec = nt.get_etud_decision_sem(etudid)
                if (dec
                    and (code_semestre_validant(dec['code']) or code_semestre_attente(dec['code']))
                    and nt.get_etud_etat(etudid) == 'I'):
                    sem_descr = odict( data=(
                        ('moy', nt.get_etud_moy_gen(etudid)),
                        ('rang', nt.get_etud_rang(etudid)),
                        ('effectif', len(nt.T)),
                        ('date_debut', s['date_debut']),
                        ('date_fin', s['date_fin']),
                        ('periode', '%s - %s' % (s['mois_debut'], s['mois_fin']))
                        ))
        if not sem_descr:
            sem_descr = odict( data=(('moy',''), ('rang',''), ('effectif', ''),
                               ('date_debut', ''), ('date_fin', ''), ('periode', '')))
        sem_descr['semestre_id'] = sem_id
        semlist.append(sem_descr)

    I['semlist'] = semlist
    return I
Пример #6
0
 def form(self):
     # make configuration data available on form context
     self.props = ILDAPProps(self.plugin)
     self.users = ILDAPUsersConfig(self.plugin)
     self.groups = ILDAPGroupsConfig(self.plugin)
     # prepare users data on form context
     self.users_attrmap = odict()
     for key in self.static_attrs_users:
         self.users_attrmap[key] = self.users.attrmap.get(key)
     self.users_propsheet_attrmap = odict()
     for key, value in self.users.attrmap.items():
         if key in self.static_attrs_users:
             continue
         self.users_propsheet_attrmap[key] = value
     # prepare groups data on form context
     self.groups_attrmap = odict()
     for key in self.static_attrs_groups:
         self.groups_attrmap[key] = self.groups.attrmap.get(key)
     self.groups_propsheet_attrmap = odict()
     for key, value in self.groups.attrmap.items():
         if key in self.static_attrs_groups:
             continue
         self.groups_propsheet_attrmap[key] = value
     # handle form
     form = parse_from_YAML('pas.plugins.ldap:properties.yaml', self, _)
     controller = Controller(form, self.request)
     if not controller.next:
         return controller.rendered
     self.request.RESPONSE.redirect(controller.next)
     return u''
Пример #7
0
    def GET(self, what="any", field="any", key="*", limit=10, offset=0, 
            which='3'):

        if what not in ("any", "gene", "enrichment", "species", "tissue"):
            return web.notfound()        

        sexp=self.get_search_expression(what, field, key, limit, offset)

        limit=int(limit)
        offset=int(offset)

        html=odict.odict()        
        html['species']=html['tissue']=html['gene']=html['enrichment']=''
        hitcounts=odict.odict()
        hitcounts['species']=hitcounts['tissue']=hitcounts['gene']= \
            hitcounts['enrichment']=0
        chitcounts=odict.odict()

        ## Get the hit counts
        hitcounts['species']= \
            model.search_for_species(field, key, which, count=True)[0].count
        chitcounts['species']=0
        hitcounts['tissue']=\
            model.search_for_tissue(field, key, which, count=True)[0].count
        chitcounts['tissue']=hitcounts['species']
        hitcounts['gene']= \
            model.search_for_gene(field, key, which, count=True)[0].count
        chitcounts['gene']=chitcounts['tissue']+hitcounts['tissue'];
        hitcounts['enrichment']= \
            model.search_for_enrichment(field, key, which,count=True)[0].count
        chitcounts['enrichment']=chitcounts['gene']+hitcounts['gene']

        ## What to show
        offsets, limits = self.get_pos(hitcounts, offset, limit)

        ## Show it
        if what in ('species', 'any') and limits['species'] != 0:
            html['species']=self.search_for_species(field, key, which,
                                                    limits['species'],
                                                    offsets['species'])
        if what in ('tissue', 'any') and limits['tissue'] != 0:
            html['tissue']=self.search_for_tissue(field, key, which,
                                                  limits['tissue'],
                                                  offsets['species'])
        if what in ('gene', 'any') and limits['gene'] != 0:
            html['gene']=self.search_for_gene(field, key, which,
                                              limits['gene'], 
                                              offsets['gene'])
        if what in ('enrichment', 'any') and limits['enrichment'] != 0:
            html['enrichment']= \
                self.search_for_enrichment(field, key, which,
                                           limits['enrichment'], 
                                           offsets['enrichment'])

        return render.searchresults(hitcounts, chitcounts, 
                                    html, offset, web.ctx.home,
                                    field, key, limit, what,
                                    sum(hitcounts.values()), 
                                    sexp, which)
Пример #8
0
    def generate_thesaurus(self, neg_kwds):
        """The main function which gets thesaurus keywords.

        Loops through existing keywords and get
        thesaurus keywords based on config.

        Args:
            neg_kwds: a list of keywords whose context related keywords
                      should not be included.
        Returns:
            A dictionary containing """
        ekwds = self.ekwds  # existing keywords.
        synsxx = odict()  # Ordered dictionary.
        for kwd in ekwds:
            # do this for each word in a kwd
            s_kwd = kwd.split()
            synsxx[kwd] = odict()  # ([],[]) #close syns and hyponyms
            for x in s_kwd:
                synsxx[kwd][x] = [[x], []]  # close syns and hyponyms
                #only take verbs and nouns
                kwd_syns = wn.synsets(x)
                if not kwd_syns:
                    continue
                counter = 0
                words_temp_syns = []
                words_temp_hyps = []
                if x in self.final_word_dict.keys():
                    continue
                # TODO: add a separate loop for homonyms
                cached_kwd_syns = set(kwd_syns[:])
                for i in kwd_syns:
                    #TODO(mrafi): remove negative kwds.
                    negative_keywords = self.get_negative_keywords(
                            neg_kwds, i)
                    cached_kwd_syns = cached_kwd_syns - set(negative_keywords)
                    if not cached_kwd_syns.__contains__(i):
                        continue
                    if not self.config.get('include_all_pos_types') and i.pos not in ('n', 'v', 'a'):
                        continue
                    if self.config['close_syns']:
                        types_of_kwd = i.lemmas  # XXX:for synonyms this is it
                        temp = sorted(i.lemma_names())
                        #if i in
                        for j in temp:
                            words_temp_syns.append('%s ' % (j.replace('_', ' ')))
                    if self.config['hypo_syns']:
                        types_of_kwd = i.hyponyms()  # data for hyponyms
                        temp = sorted([lemma.name for synset in types_of_kwd for lemma in synset.lemmas])
                        for j in temp:
                            words_temp_hyps.append('%s ' % (j.replace('_', ' ')))
                    if not types_of_kwd:
                        continue
                    counter += 1
                if words_temp_syns:
                    synsxx[kwd][x][0] = sorted(list(set(words_temp_syns)))
                if words_temp_hyps:
                    synsxx[kwd][x][1] = sorted(list(set(words_temp_hyps)))
        return synsxx
Пример #9
0
 def asdict(self):
     ndx = np.arange(0, self.len)
     by_row = odict.odict()
     for n in ndx:
         by_row[n] = odict.odict()
     for n in by_row.keys():
         for cn in self.names:
             by_row[n][cn] = self.col[cn][n]
     return by_row
Пример #10
0
 def __init__(self):
     self.Ty = TypeContainer()
     PublishWellKnownTypes(self.Ty)
     self.recs = odict([(rName, self.Ty.get(rName)) for rName in sd.recordSchema.iterkeys()])
     self.hnds = odict([(hName + 'Handle', self.Ty.get(hName + 'Handle')) for hName in sd.handleSchema])
     for rec in self.recs.itervalues():
         rec.handle = self.hnds[str(rec) + 'Handle']
     self.Ty.NativeReader = ClassDef('NativeReader')
     self.Ty.NativeWriter = ClassDef('NativeWriter')
Пример #11
0
 def reset(self):
     """
     Empty the table
     """
     self.keywords = odict()
     self.comments = []
     self.columns = odict()
     self.data = None
     self._primary_key = None
     return
Пример #12
0
 def test_first_and_last_key(self):
     # Test first and last key.
     o = odict([('a', 1), ('b', 2), ('c', 3), ('d', 4)])
     self.assertEqual(o.firstkey(), 'a')
     self.assertEqual(o.lastkey(), 'd')
     o = odict()
     msg = "\"'firstkey(): ordered dictionary is empty'\""
     self.assertRaisesWithMessage(msg, o.firstkey, KeyError)
     msg = "\"'lastkey(): ordered dictionary is empty'\""
     self.assertRaisesWithMessage(msg, o.lastkey, KeyError)
Пример #13
0
    def test_odict_storage(self):
        obj = OdictStorageObject()
        self.assertEqual(obj.storage, odict())

        obj['foo'] = 'foo'
        self.assertEqual(obj.storage, odict([('foo', 'foo')]))
        self.assertEqual(obj['foo'], 'foo')
        self.assertEqual([key for key in obj], ['foo'])

        del obj['foo']
        self.assertEqual(obj.storage, odict())
Пример #14
0
 def test_casting(self):
     # casting to dict will fail
     # Reason -> http://bugs.python.org/issue1615701
     # The __init__ function of dict checks wether arg is subclass of dict,
     # and ignores overwritten __getitem__ & co if so.
     # This was fixed and later reverted due to behavioural problems with
     # pickle.
     self.assertEqual(dict(odict([(1, 1)])), {1: [_nil, 1, _nil]})
     # The following ways for type conversion work
     self.assertEqual(dict(odict([(1, 1)]).items()), {1: 1})
     self.assertEqual(odict([(1, 1)]).as_dict(), {1: 1})
Пример #15
0
    def defaults(self, param=None, ipython_globals=None, paramvalue=None, subparam=None):
	if not hasattr(self, "__globals__") or self.__globals__ == None :
           self.__globals__=sys._getframe(len(inspect.stack())-1).f_globals
        if ipython_globals == None:
            myf=self.__globals__
        else:
            myf=ipython_globals

        a = odict()
        a['vis']  = ''
        a['field']  = ''
        a['spw']  = ''
        a['model']  = ''
        a['nterms']  = 1
        a['wprojplanes']  = 1
        a['complist']  = ''
        a['incremental']  = False
        a['usescratch']  = False

        a['async']=False
        a['nterms'] = {
                    0:odict([{'notvalue':1}, {'reffreq':''}])}

### This function sets the default values but also will return the list of
### parameters or the default value of a given parameter
        if(param == None):
                myf['__set_default_parameters'](a)
        elif(param == 'paramkeys'):
                return a.keys()
        else:
            if(paramvalue==None and subparam==None):
               if(a.has_key(param)):
                  return a[param]
               else:
                  return self.itsdefault(param)
            else:
               retval=a[param]
               if(type(a[param])==dict):
                  for k in range(len(a[param])):
                     valornotval='value'
                     if(a[param][k].has_key('notvalue')):
                        valornotval='notvalue'
                     if((a[param][k][valornotval])==paramvalue):
                        retval=a[param][k].copy()
                        retval.pop(valornotval)
                        if(subparam != None):
                           if(retval.has_key(subparam)):
                              retval=retval[subparam]
                           else:
                              retval=self.itsdefault(subparam)
		     else:
                        retval=self.itsdefault(subparam)
               return retval
Пример #16
0
    def update( self ):
        self.detailedBalance = dict.fromkeys( self.goods, 0 )
        self.globalBalance = 0

        self.neededDiversity = 0

        self.imports = dict()
        self.exports = dict()
        for good in self.goods:
            self.imports[ good ] = self.board.getImports( self.category + "." + good )
            self.exports[ good ] = self.board.getExports( self.category + "." + good )
            self.detailedBalance[ good ] += self.imports[ good ] - self.exports[ good ]
            self.globalBalance += self.imports[ good ] - self.exports[ good ]

        self.producers = odict()
        for producer in self.__producers:
            number = len( self.board.getObjectsByType( producer ) )
            available = self.board.isAvailable( producer )
            goods = dict()
            for good in self.goods:
                if self.category + "." + good in GameItemTypes.attributes[ producer ]:
                    goods[ good ] = number * GameItemTypes.attributes[ producer ][ self.category + "." + good ]
                    self.detailedBalance[ good ] += goods[ good ]
                    self.globalBalance += goods[ good ]
            self.producers[ producer ] = ( number, available, goods )

        self.detailedConsumers = odict()
        for detailedConsumer in self.__detailedConsumers:
            number = len( self.board.getObjectsByType( detailedConsumer ) )
            available = self.board.isAvailable( detailedConsumer )
            goods = dict()
            for good in self.goods:
                if self.category + "." + good in GameItemTypes.attributes[ detailedConsumer ]:
                    goods[ good ] = number * GameItemTypes.attributes[ detailedConsumer ][ self.category + "." + good ]
                    self.detailedBalance[ good ] += goods[ good ]
                    self.globalBalance += goods[ good ]
            self.detailedConsumers[ detailedConsumer ] = ( number, available, goods )

        self.globalConsumers = odict()
        for globalConsumer in self.__globalConsumers:
            number = len( self.board.getObjectsByType( globalConsumer ) )
            available = self.board.isAvailable( globalConsumer )
            goods = number * GameItemTypes.attributes[ globalConsumer ][ self.category ]
            self.globalBalance += goods
            self.globalConsumers[ globalConsumer ] = ( number, available, goods )
            if number > 0:
                self.neededDiversity = max( self.neededDiversity, GameItemTypes.attributes[ globalConsumer ][ "NeededDiversity." + self.category ] )
        self.hasGlobalConsumers = len( self.__globalConsumers ) > 0

        self.globalBalanceIsOk = self.globalBalance >= 0
        self.availableDiversity = len( [ good for good in self.goods if self.detailedBalance[ good ] > 0 ] )
        self.availableDiversityIsOk = self.availableDiversity >= self.neededDiversity
        self.detailedBalanceIsOk = dict( [ ( good, balance >= 0 ) for ( good, balance ) in self.detailedBalance.iteritems() ] )
Пример #17
0
 def __init__(self):
     self.cfg = dict()
     self.cfg_file = self._find_cfg()
     self.load_config()
     self.cmds = odict()
     self.aliases = odict()
     for ep in iter_entry_points(self.entry_point_keys['commands']):
         self.cmds[ep.name] = ep.load()(ep.name, self)
     for ep in iter_entry_points(self.entry_point_keys['aliases']):
         self.aliases[ep.name] = ep.load()()
     self.cmds.sort()
     self.aliases.sort()
Пример #18
0
 def __init__(self, class_, context=None):
     """
     :param class_: class object for creating children in test.
     :param context: an optional root context to test against, If None, an
     instance of class_ is created as root.
     """
     self._results = odict()
     self.class_ = class_
     self.context = context
     if self.context is None:
         self.context = class_()
     self._results = odict()
Пример #19
0
 def __init__(self, *args, **kwargs):
     BaseWindow.__init__(self, *args, **kwargs)
     [setattr(self,k,v) for k,v in kwargs.iteritems() if k in ('settings','translator','platform','fanArt','cachesByName', 'upcoming', )]
     [setattr(self,k,v) for k,v in self.cachesByName.iteritems() if k in ('mythChannelIconCache','domainCache', )]
     
     self.programs = []                       # [RecordedProgram]
     self.channelsById = None                 # {int:Channel}
     self.tunersById = None                   # {int:Tuner}
     self.listItemsByProgram = odict.odict()  # {Program:ListItem}
     self.programsByListItemKey = odict.odict()  # {ListItem:Program}
     self.sortBy = self.settings.get('upcoming_sort_by')
     self.sortAscending = self.settings.getBoolean('upcoming_sort_ascending')
     self.activeRenderToken = None
Пример #20
0
 def __init__(self, exist_kwds, config):
     """Constructor.
     Args:
         exist_kwds: A list of source/sample words.
         # TODO(mrafi): Change config from a dictionary to depth level.
         config: a dictionary containing flags for hypernymns and hyponymns."""
     self.ekwds = self.make_list(exist_kwds)
     self.config = config  # config is a dictionary
     self.nkwds = []
     self.word_dict = odict()
     self.filex = 'test.txt'
     self.kwd_list = []
     self.final_word_dict = odict()
Пример #21
0
 def save(self, widget, data):
     props =  ILDAPProps(self.plugin)
     users =  ILDAPUsersConfig(self.plugin)
     groups = ILDAPGroupsConfig(self.plugin)
     def fetch(name):
         name = 'ldapsettings.%s' % name
         __traceback_info__ = name
         return data.fetch(name).extracted
     props.uri = fetch('server.uri')
     props.user = fetch('server.user')
     password = fetch('server.password')
     if password is not UNSET:
         props.password = password
     # XXX: later
     #props.start_tls = fetch('server.start_tls')
     #props.tls_cacertfile = fetch('server.tls_cacertfile')
     #props.tls_cacertdir = fetch('server.tls_cacertdir')
     #props.tls_clcertfile = fetch('server.tls_clcertfile')
     #props.tls_clkeyfile = fetch('server.tls_clkeyfile')
     #props.retry_max = fetch(at('server.retry_max')
     #props.retry_delay = fetch('server.retry_delay')
     props.cache = fetch('cache.cache')
     props.memcached = fetch('cache.memcached')
     props.timeout = fetch('cache.timeout')
     users.baseDN = fetch('users.dn')
     map = odict()
     map.update(fetch('users.aliases_attrmap'))
     users_propsheet_attrmap = fetch('users.propsheet_attrmap')
     if users_propsheet_attrmap is not UNSET:
         map.update(users_propsheet_attrmap)
     users.attrmap = map
     users.scope = fetch('users.scope')
     users.queryFilter = fetch('users.query')
     objectClasses = fetch('users.object_classes')
     objectClasses = \
         [v.strip() for v in objectClasses.split(',') if v.strip()]
     users.objectClasses = objectClasses
     groups = self.groups
     groups.baseDN = fetch('groups.dn')
     map = odict()
     map.update(fetch('groups.aliases_attrmap'))
     groups_propsheet_attrmap = fetch('groups.propsheet_attrmap')
     if groups_propsheet_attrmap is not UNSET:
         map.update(groups_propsheet_attrmap)
     groups.attrmap = map
     groups.scope = fetch('groups.scope')
     groups.queryFilter = fetch('groups.query')
     objectClasses = fetch('groups.object_classes')
     objectClasses = \
         [v.strip() for v in objectClasses.split(',') if v.strip()]
     groups.objectClasses = objectClasses
    def test_posix_account(self, props):
        ucfg = UsersConfig(
            baseDN='ou=defaults,dc=my-domain,dc=com',
            attrmap=odict((
                ('rdn', 'cn'),
                ('id', 'cn')
            )),
            scope=SUBTREE,
            queryFilter='(objectClass=posixAccount)',
            objectClasses=['account', 'posixAccount'],
            defaults={}
        )
        users = Users(props, ucfg)
        user = users.create('posixuser')
        user()
        self.assertEqual(sorted(user.context.attrs.items()), [
            (u'cn', u'posixuser'),
            (u'gidNumber', u'100'),
            (u'homeDirectory', u'/home/posixuser'),
            (u'objectClass', [u'account', u'posixAccount']),
            (u'uid', u'posixuser'),
            (u'uidNumber', u'100')
        ])

        defaults.creation_defaults['posixAccount']['loginShell'] = posix.loginShell
        ucfg = UsersConfig(
            baseDN='ou=defaults,dc=my-domain,dc=com',
            attrmap=odict((
                ('rdn', 'uid'),
                ('id', 'uid')
            )),
            scope=SUBTREE,
            queryFilter='(objectClass=posixAccount)',
            objectClasses=['account', 'posixAccount'],
            defaults={}
        )
        users = Users(props, ucfg)
        user = users.create('posixuser1')
        user()
        self.assertEqual(sorted(user.context.attrs.items()), [
            (u'cn', u'posixuser1'),
            (u'gidNumber', u'101'),
            (u'homeDirectory', u'/home/posixuser1'),
            (u'loginShell', u'/bin/false'),
            (u'objectClass', [u'account', u'posixAccount']),
            (u'uid', u'posixuser1'),
            (u'uidNumber', u'101')
        ])
        del defaults.creation_defaults['posixAccount']['loginShell']
Пример #23
0
    def collect(self):
        """collect all data.

        Data is stored in a multi-level dictionary (DataTree)
        """

        self.data = odict()

        is_function, datapaths = self.getDataPaths(self.tracker)

        # if function, no datapaths
        if is_function:
            d = self.getData(())

            # save in data tree as leaf
            DataTree.setLeaf(self.data, ("all",), d)

            self.debug("%s: collecting data finished for function." % (self.tracker))
            return

        # if no tracks, error
        if len(datapaths) == 0 or len(datapaths[0]) == 0:
            self.warn("%s: no tracks found - no output" % self.tracker)
            raise ValueError("no tracks found from %s" % self.tracker)

        # filter data paths
        datapaths = self.filterDataPaths(datapaths)

        # if no tracks, error
        if len(datapaths) == 0 or len(datapaths[0]) == 0:
            self.warn("%s: no tracks remain after filtering - no output" % self.tracker)
            raise ValueError("no tracks found from %s" % self.tracker)

        all_paths = list(itertools.product(*datapaths))
        self.debug("%s: collecting data started for %i data paths" % (self.tracker, len(all_paths)))

        self.data = odict()
        for path in all_paths:

            d = self.getData(path)

            # ignore empty data sets
            if d == None:
                continue

            # save in data tree as leaf
            DataTree.setLeaf(self.data, path, d)

        self.debug("%s: collecting data finished for %i data paths" % (self.tracker, len(all_paths)))
Пример #24
0
 def __init__(self, class_, context=None, sorted_output=False):
     """
     ``class_``
         class object for creating children in test.
     ``context``
         an optional root context to test against, If None, an instance of 
         class_ is created as root.
     """
     self._results = odict()
     self.class_ = class_
     self.context = context
     if self.context is None:
         self.context = class_()
     self.sorted_output = sorted_output
     self._results = odict()
Пример #25
0
    def getDict( self, stmt ):
        """return results from SQL statement *stmt* as a dictionary.

        Example: SELECT column1, column2 FROM table
        Result: { 1: 2, 2: 4, 3: 2}

        The first column is taken as the dictionary key
        """
        # convert to tuples
        e = self.execute(self.buildStatement(stmt))
        columns = e.keys()
        result = odict()
        for row in e:
            result[row[0]] = odict( zip( columns[1:], row[1:] ) )
        return result
Пример #26
0
 def test_create_tree(self):
     self.assertEqual(create_tree(odict), odict([
         ('child_0', odict([
             ('subchild_0', odict()),
             ('subchild_1', odict())
         ])),
         ('child_1', odict([
             ('subchild_0', odict()),
             ('subchild_1', odict())
         ])),
         ('child_2', odict([
             ('subchild_0', odict()),
             ('subchild_1', odict())
         ]))
     ]))
Пример #27
0
 def _load_keys(self):
     self._keys = odict()
     self._child_dns = {}
     attrlist = ['dn']
     if self._seckey_attrs:
         self._seckeys = dict()
         attrlist.extend(self._seckey_attrs)
     for key, attrs in self.search(attrlist=attrlist):
         try:
             self._keys[key]
         except KeyError:
             self._keys[key] = None
             self._child_dns[key] = attrs['dn']
             for seckey_attr, seckey in \
                     self._calculate_seckeys(attrs).items():
                 try:
                     self._seckeys[seckey_attr]
                 except KeyError:
                     self._seckeys[seckey_attr] = {}
                 try:
                     self._seckeys[seckey_attr][seckey]
                 except KeyError:
                     self._seckeys[seckey_attr][seckey] = key
                 else:
                     raise KeyError(
                         u"Secondary key not unique: %s='%s'." % \
                                 (seckey_attr, seckey))
         else:
             raise RuntimeError(u"Key not unique: %s='%s'." % \
                     (self._key_attr, key))
Пример #28
0
 def _resolvearg(self, arg):
     if isinstance(arg, _ast.Str):
         return repr(arg.s)
     elif isinstance(arg, _ast.Num):
         return arg.n
     elif isinstance(arg, _ast.Name):
         return arg.id
     elif isinstance(arg, _ast.Call):
         args = list()
         for a in arg.args:
             args.append(self._resolvearg(a))
         kwargs = odict()
         for keyword in arg.keywords:
             kwargs[keyword.arg] = self._resolvearg(keyword.value)
         try:
             return Call(name=arg.func.id, args=args, kwargs=kwargs)
         except AttributeError:
             return Call(name=arg.func.attr, args=args, kwargs=kwargs)
     elif isinstance(arg, _ast.Tuple) or isinstance(arg, _ast.List):
         ret = list()
         for a in arg.elts:
             ret.append(self._resolvearg(a))
         if isinstance(arg, _ast.Tuple):
             ret = tuple(ret)
         return ret
     elif isinstance(arg, _ast.Dict):
         ret = dict()
         pointer = 0
         for key in arg.keys:
             key = self._resolvearg(key)
             ret[key] = self._resolvearg(arg.values[pointer])
             pointer += 1
         return ret
Пример #29
0
def run():
    head('dict')
    root = dict()
    global root
    print CREATE_DELETE_ROW
    dict_results = {
        1000: result(dict, 1000),
        10000: result(dict, 10000),
        100000: result(dict, 100000),
        1000000: result(dict, 1000000),
    }
    head('odict')
    root = odict.odict()
    global root
    print CREATE_DELETE_ROW
    odict_results = {
        1000: result(odict.odict, 1000),
        10000: result(odict.odict, 10000),
        100000: result(odict.odict, 100000),
        1000000: result(odict.odict, 1000000),
    }
    head('relation ``dict:odict``')
    print RELATION_ROW
    for key, value in dict_results.items():
        dstart, dmid, dend = value
        ostart, omid, oend = odict_results[key]
        relation_create = (omid - ostart) / (dmid - dstart)
        relation_delete = (oend - omid) / (dend - dmid)
        relation_row('creating', key, relation_create)
        relation_row('deleting', key, relation_delete)
Пример #30
0
def returnQuantities(runNumber):
  infoCollector =  getInfoCollector(runNumber)
  quantities =[]
#  f = returnFile(runNumber)
#  for key in f.GetListOfKeys():
#    if key.ReadObj().ClassName() == "PotCollection":
#      potCollection = key.ReadObj() 

  for pot in getPotCollection(runNumber):
    for trigStat in pot.fConditionalTriggerStat:
      quantities.append(odict())
      #quantities[-1]["runName"] = "testRunName"
      quantities[-1]["runName"] = infoCollector.runName.replace('run_','')
      quantities[-1]["potName"] = pot.GetName()
      quantities[-1]["condition"] = trigStat.GetName()
      quantities[-1]["nevents"] = trigStat.fConditions
      quantities[-1][""] = trigStat.fConditionANDRawSimuCCoutputTheSame                                 
      quantities[-1]["fConditionANDRawSimuCCoutputNotTheSame"] = trigStat.fConditionANDRawSimuCCoutputNotTheSame           
      quantities[-1]["fConditionANDRawSimuCCoutputNotTheSameEven"] = trigStat.fConditionANDRawSimuCCoutputNotTheSameEven         
      quantities[-1]["fConditionANDRawSimuCCoutputNotTheSameOdd"] = trigStat.fConditionANDRawSimuCCoutputNotTheSameOdd   
      quantities[-1]["fConditionANDRawSimuCCoutputNotTheSameEvenOdd"] = trigStat.fConditionANDRawSimuCCoutputNotTheSameEvenOdd     
      quantities[-1]["fConditionANDTriggerRaw0Simu0"] = trigStat.fConditionANDTriggerRaw0Simu0 
      quantities[-1]["fConditionANDTriggerRaw1Simu0"] = trigStat.fConditionANDTriggerRaw1Simu0                 
      quantities[-1]["fConditionANDTriggerRaw0Simu1"] = trigStat.fConditionANDTriggerRaw0Simu1                 
      quantities[-1]["fConditionANDTriggerRaw1Simu1"] = trigStat.fConditionANDTriggerRaw1Simu1 
      for potType in (ROOT.ERawOrSimu.kRaw,ROOT.ERawOrSimu.kSimu):  
        for trigStat in pot.GetPot(potType).fConditionalTriggerStat:
          if  quantities[-1]["condition"] == trigStat.GetName(): 
            #print "fConditionANDTrigger"+str(ROOT.PreTriggerStat.RawOrSimuString(potType))
            quantities[-1]["fConditionANDTrigger"+str(ROOT.PreTriggerStat.RawOrSimuString(potType))] = trigStat.fConditionANDTrigger
  assert(len(quantities)!=0)
  return quantities
Пример #31
0
    def nodespaces(self):
        """A storage and general way to access our nodespaces.

        An ``AttributedNode`` uses this to store the ``attrs`` nodespace i.e.
        """
        if self._nodespaces is None:
            self._nodespaces = odict()
            self._nodespaces['__children__'] = self
        return self._nodespaces
Пример #32
0
 def test_pop(self):
     # Test pop and popitem
     o = odict([(1, 'a'), (2, 'b')])
     self.assertRaisesWithMessage('3', o.pop, KeyError, 3)
     self.assertEqual(o.pop(3, 'foo'), 'foo')
     self.assertEqual(o.pop(2), 'b')
     self.assertEqual(o.popitem(), (1, 'a'))
     msg = "\"'popitem(): ordered dictionary is empty'\""
     self.assertRaisesWithMessage(msg, o.popitem, KeyError)
Пример #33
0
 def __init__(self, decoratorname=None, astnode=None, buffer=[]):
     PythonNode.__init__(self, None, astnode, buffer)
     CallableArguments.__init__(self)
     self.decoratorname = decoratorname
     self._args_orgin = list()
     self._kwargs_orgin = odict()
     self.parser = self.parserfactory(self)
     if astnode is not None:
         self.parser()
Пример #34
0
 def test_swap(self):
     # Test ``swap``
     o = odict([('0', 'a'), ('1', 'b'), ('2', 'c'), ('3', 'd'), ('4', 'e')])
     # Cannot swap same key
     with self.assertRaises(ValueError):
         o.swap('0', '0')
     self.assertEqual(o.keys(), ['0', '1', '2', '3', '4'])
     self.assertEqual(o.values(), ['a', 'b', 'c', 'd', 'e'])
     # Case first 2, a < b
     o.swap('0', '1')
     self.assertEqual(o.keys(), ['1', '0', '2', '3', '4'])
     self.assertEqual(o.values(), ['b', 'a', 'c', 'd', 'e'])
     # Case first 2, a > b
     o.swap('0', '1')
     self.assertEqual(o.keys(), ['0', '1', '2', '3', '4'])
     self.assertEqual(o.values(), ['a', 'b', 'c', 'd', 'e'])
     # Case last 2, a < b
     o.swap('3', '4')
     self.assertEqual(o.keys(), ['0', '1', '2', '4', '3'])
     self.assertEqual(o.values(), ['a', 'b', 'c', 'e', 'd'])
     # Case last 2, a > b
     o.swap('3', '4')
     self.assertEqual(o.keys(), ['0', '1', '2', '3', '4'])
     self.assertEqual(o.values(), ['a', 'b', 'c', 'd', 'e'])
     # Case neighbors, a < b
     o.swap('1', '2')
     self.assertEqual(o.keys(), ['0', '2', '1', '3', '4'])
     self.assertEqual(o.values(), ['a', 'c', 'b', 'd', 'e'])
     # Case neighbors, a > b
     o.swap('1', '2')
     self.assertEqual(o.keys(), ['0', '1', '2', '3', '4'])
     self.assertEqual(o.values(), ['a', 'b', 'c', 'd', 'e'])
     # Case non neighbors, one key first, a < b
     o.swap('0', '2')
     self.assertEqual(o.keys(), ['2', '1', '0', '3', '4'])
     self.assertEqual(o.values(), ['c', 'b', 'a', 'd', 'e'])
     # Case non neighbors, one key first, a > b
     o.swap('0', '2')
     self.assertEqual(o.keys(), ['0', '1', '2', '3', '4'])
     self.assertEqual(o.values(), ['a', 'b', 'c', 'd', 'e'])
     # Case non neighbors, one key last, a < b
     o.swap('2', '4')
     self.assertEqual(o.keys(), ['0', '1', '4', '3', '2'])
     self.assertEqual(o.values(), ['a', 'b', 'e', 'd', 'c'])
     # Case non neighbors, one key last, a > b
     o.swap('2', '4')
     self.assertEqual(o.keys(), ['0', '1', '2', '3', '4'])
     self.assertEqual(o.values(), ['a', 'b', 'c', 'd', 'e'])
     # Case non neighbors, a < b
     o.swap('1', '3')
     self.assertEqual(o.keys(), ['0', '3', '2', '1', '4'])
     self.assertEqual(o.values(), ['a', 'd', 'c', 'b', 'e'])
     # Case non neighbors, a > b
     o.swap('1', '3')
     self.assertEqual(o.keys(), ['0', '1', '2', '3', '4'])
     self.assertEqual(o.values(), ['a', 'b', 'c', 'd', 'e'])
Пример #35
0
    def defaults(self,
                 param=None,
                 ipython_globals=None,
                 paramvalue=None,
                 subparam=None):
        if not hasattr(self, "__globals__") or self.__globals__ == None:
            self.__globals__ = sys._getframe(len(inspect.stack()) -
                                             1).f_globals
        if ipython_globals == None:
            myf = self.__globals__
        else:
            myf = ipython_globals

        a = odict()
        a['muser'] = globalpy.muser_global_muser
        a['inputfile'] = ''
        a['start'] = ''
        a['integral'] = 1
        a['niter'] = 1
        a['hourangle'] = 999
        a['declination'] = 999
        a['correct'] = 0
        a['calibration'] = True
        a['bigfile'] = False
        a['debug'] = globalpy.muser_global_debug

        ### This function sets the default values but also will return the list of
        ### parameters or the default value of a given parameter
        if (param == None):
            myf['__set_default_parameters'](a)
        elif (param == 'paramkeys'):
            return a.keys()
        else:
            if (paramvalue == None and subparam == None):
                if (a.has_key(param)):
                    return a[param]
                else:
                    return self.itsdefault(param)
            else:
                retval = a[param]
                if (type(a[param]) == dict):
                    for k in range(len(a[param])):
                        valornotval = 'value'
                        if (a[param][k].has_key('notvalue')):
                            valornotval = 'notvalue'
                        if ((a[param][k][valornotval]) == paramvalue):
                            retval = a[param][k].copy()
                            retval.pop(valornotval)
                            if (subparam != None):
                                if (retval.has_key(subparam)):
                                    retval = retval[subparam]
                                else:
                                    retval = self.itsdefault(subparam)
                        else:
                            retval = self.itsdefault(subparam)
                return retval
Пример #36
0
 def test_reverse_iteration(self):
     # Reverse iteration
     o = odict([('a', 1), ('b', 2), ('c', 3), ('d', 4)])
     self.assertEqual([x for x in o.riterkeys()], ['d', 'c', 'b', 'a'])
     self.assertEqual(o.rkeys(), ['d', 'c', 'b', 'a'])
     self.assertEqual([x for x in o.ritervalues()], [4, 3, 2, 1])
     self.assertEqual(o.rvalues(), [4, 3, 2, 1])
     self.assertEqual([x for x in o.riteritems()], [('d', 4), ('c', 3),
                                                    ('b', 2), ('a', 1)])
     self.assertEqual(o.ritems(), [('d', 4), ('c', 3), ('b', 2), ('a', 1)])
Пример #37
0
def create_odict_from_items(name, key, dictlst):
    """
    Construct an ordered dictionary from a list of dictionaries, using 
    the key from the dictionary.
    """
    def _generator():
        for delement in dictlst:        
            dvalues = dict((k, v) for (k, v) in delement.iteritems())
            yield (delement[key], Struct(name, **dvalues))
    return odict(_generator())      
Пример #38
0
    def test_compound_blueprint_structural_children(self):
        # Compound with structural compound as child
        value = {
            'inner': 'Value 1 from parent',
            'inner2': 'Value 2 from parent',
        }
        compound = factory('compound', name='COMPOUND', value=value)
        structural = compound['STRUCTURAL'] = factory(
            'compound', props={'structural': True})
        structural['inner'] = factory('text')
        structural['inner2'] = factory('text', props={'required': True})
        self.check_output(
            """
        <div>
          <input class="text" id="input-COMPOUND-inner" name="COMPOUND.inner"
                 type="text" value="Value 1 from parent"/>
          <input class="required text" id="input-COMPOUND-inner2"
                 name="COMPOUND.inner2" required="required" type="text"
                 value="Value 2 from parent"/>
        </div>
        """, fxml(tag('div', compound())))

        self.assertEqual(compound.treerepr().split('\n'), [
            "<class 'yafowil.base.Widget'>: COMPOUND",
            "  <class 'yafowil.base.Widget'>: STRUCTURAL",
            "    <class 'yafowil.base.Widget'>: inner",
            "    <class 'yafowil.base.Widget'>: inner2", ""
        ])

        data = compound.extract({
            'COMPOUND.inner': 'newvalue',
            'COMPOUND.inner2': '',
        })
        self.assertEqual(data.name, 'COMPOUND')
        self.assertEqual(data.value, {
            'inner2': 'Value 2 from parent',
            'inner': 'Value 1 from parent'
        })
        expected = odict()
        expected['inner'] = 'newvalue'
        expected['inner2'] = ''
        self.assertEqual(data.extracted, expected)

        data_inner = data['inner']
        self.assertEqual(data_inner.name, 'inner')
        self.assertEqual(data_inner.value, 'Value 1 from parent')
        self.assertEqual(data_inner.extracted, 'newvalue')
        self.assertEqual(data_inner.errors, [])

        data_inner2 = data['inner2']
        self.assertEqual(data_inner2.name, 'inner2')
        self.assertEqual(data_inner2.value, 'Value 2 from parent')
        self.assertEqual(data_inner2.extracted, '')
        self.assertEqual(data_inner2.errors,
                         [ExtractionError('Mandatory field was empty')])
Пример #39
0
    def defaults(self,
                 param=None,
                 ipython_globals=None,
                 paramvalue=None,
                 subparam=None):
        if not hasattr(self, "__globals__") or self.__globals__ == None:
            self.__globals__ = sys._getframe(len(inspect.stack()) -
                                             1).f_globals
        if ipython_globals == None:
            myf = self.__globals__
        else:
            myf = ipython_globals

        a = odict()
        a['vis'] = ''
        a['outputvis'] = ''
        a['timerange'] = ''
        a['spw'] = ''
        a['subtime1'] = ''
        a['subtime2'] = ''
        a['splitsel'] = True
        a['reverse'] = False
        a['overwrite'] = False

        ### This function sets the default values but also will return the list of
        ### parameters or the default value of a given parameter
        if (param == None):
            myf['__set_default_parameters'](a)
        elif (param == 'paramkeys'):
            return a.keys()
        else:
            if (paramvalue == None and subparam == None):
                if (a.has_key(param)):
                    return a[param]
                else:
                    return self.itsdefault(param)
            else:
                retval = a[param]
                if (type(a[param]) == dict):
                    for k in range(len(a[param])):
                        valornotval = 'value'
                        if (a[param][k].has_key('notvalue')):
                            valornotval = 'notvalue'
                        if ((a[param][k][valornotval]) == paramvalue):
                            retval = a[param][k].copy()
                            retval.pop(valornotval)
                            if (subparam != None):
                                if (retval.has_key(subparam)):
                                    retval = retval[subparam]
                                else:
                                    retval = self.itsdefault(subparam)
                        else:
                            retval = self.itsdefault(subparam)
                return retval
Пример #40
0
 def ldap_rcfg(self):
     settings = self.attrs
     attr_map = odict(settings.roles_aliases_attrmap.items())
     return RolesConfig(
         baseDN=settings.roles_dn,
         attrmap=attr_map,
         scope=int(settings.roles_scope),
         queryFilter=settings.roles_query,
         objectClasses=settings.roles_object_classes,
         # member_relation=settings.roles_relation,
         defaults=factory_defaults.role)
Пример #41
0
    def __init__(self, *args, **kwargs):
        BaseWindow.__init__(self, *args, **kwargs)
        # inject dependencies from constructor
        [setattr(self,k,v) for k,v in kwargs.iteritems() if k in ('settings', 'translator', 'platform', 'fanArt', 'cachesByName', 'bus',)]
        [setattr(self,k,v) for k,v in self.cachesByName.iteritems()]

        self.t = self.translator.get
        self.programs = []                       # [RecordedProgram]
        self.allGroupTitle = self.t(m.ALL_RECORDINGS)
        self.activeRenderToken = None
        self.groupsByTitle = odict.odict()       # {unicode:Group}
        self.groupsListItems = []
        self.activeGroup = None
        self.lastFocusId = None
        self.sameBackgroundCache = {}            # {title:filepath}
        self.bus.register(self)
        self.GROUP_SORT_BY = odict.odict([
            ('Title', {'translation_id': m.TITLE, 'reverse': False, 'sorter' : lambda g: [g.title, u'0000'][g.title == self.allGroupTitle]}),
            ('Date',  {'translation_id': m.DATE,  'reverse': True,  'sorter' : lambda g: [g.programs[0].starttimeAsTime(), datetime.datetime(datetime.MAXYEAR, 12, 31, 23, 59, 59, 999999, tzinfo=None)][g.title == self.allGroupTitle]})])
        self.dirty = False
Пример #42
0
def tget_defaults(param=None):
    myf = stack_frame_find()
    a = odict()
    a['task'] = ''
    a['savefile'] = ''
    if (param == None):
        myf['__set_default_parameters'](a)
    elif (param == 'paramkeys'):
        return a.keys()
    else:
        if (a.has_key(param)):
            return a[param]
Пример #43
0
def test3_hc(topo, ncgic, nhc) :
	# Copy over fgice and fgrnd
	# The values of these might have to change a bit, but
	# not the structure.
	ovars = odict()
	ovars['fgice'] = gread(topo, 'fgice')
	ovars['fgrnd'] = gread(topo, 'fgrnd')

	fgice = ovars['fgice'][0]
	fgrnd = ovars['fgrnd'][0]

	# Allocate but only read things we need now
	zatmo_t = gread(topo, 'zatmo')
	tlandi_t = gread(ncgic, 'tlandi')
	snowli_t = gread(ncgic, 'snowli')
	ovars['elevhc'] = prepend_dim(zatmo_t, 'nhc', nhc)
	ovars['tlandi'] = prepend_dim(tlandi_t, 'nhc', nhc)
	ovars['snowli'] = prepend_dim(snowli_t, 'nhc', nhc)
	ovars['fhc'] = (np.zeros(ovars['snowli'][0].shape), ovars['snowli'][1], 'f8')

	elevhc = ovars['elevhc'][0]
	tlandi = ovars['tlandi'][0]
	snowli = ovars['snowli'][0]
	fhc = ovars['fhc'][0]


	# Make height-classified versions of vars by copying
	for ihc in range(0,nhc) :
		elevhc[ihc,:] = zatmo_t[0][:]
		tlandi[ihc,:] = tlandi_t[0][:]
		snowli[ihc,:] = snowli_t[0][:]
		fhc[:] = 1.0 / float(nhc)

	# ---------------------------------------------
	jm = snowli.shape[1]
	im = snowli.shape[2]
	print fgrnd.shape, jm, im
	for j in range(0,jm) :
		for i in range(0, im) :
			if fgice[j,i] == 0 : continue
			elevhc[0,j,i] = max(0, zatmo_t[0][j,i] - 300)
			elevhc[1,j,i] = zatmo_t[0][j,i]
			elevhc[2,j,i] = zatmo_t[0][j,i] + 300
#			elevhc[0,j,i] = 0
#			elevhc[1,j,i] = 1000
#			elevhc[2,j,i] = 2000


	fhc[0,:] = .25
	fhc[1,:] = .5
	fhc[2,:] = .25

	return ovars
Пример #44
0
    def defaults(self, param=None, ipython_globals=None, paramvalue=None, subparam=None):
	if not hasattr(self, "__globals__") or self.__globals__ == None :
           self.__globals__=sys._getframe(len(inspect.stack())-1).f_globals
        if ipython_globals == None:
            myf=self.__globals__
        else:
            myf=ipython_globals

        a = odict()
        a['infile'] = ''
        a['is_loop_mode'] = True
        a['mode'] = True
        a['band'] = None
        a['channel'] = 4
        a['weight'] = 0
        a['polarization']  = 0
        a['movera'] = 0
        a['movedec'] = 0
        a['P_ANGLE']  = False
        a['fits'] = 0
        a['debug']  = globalpy.muser_global_debug
        a['outdir'] = ''

### This function sets the default values but also will return the list of
### parameters or the default value of a given parameter
        if(param == None):
                myf['__set_default_parameters'](a)
        elif(param == 'paramkeys'):
                return a.keys()
        else:
            if(paramvalue==None and subparam==None):
               if(a.has_key(param)):
                  return a[param]
               else:
                  return self.itsdefault(param)
            else:
               retval=a[param]
               if(type(a[param])==dict):
                  for k in range(len(a[param])):
                     valornotval='value'
                     if(a[param][k].has_key('notvalue')):
                        valornotval='notvalue'
                     if((a[param][k][valornotval])==paramvalue):
                        retval=a[param][k].copy()
                        retval.pop(valornotval)
                        if(subparam != None):
                           if(retval.has_key(subparam)):
                              retval=retval[subparam]
                           else:
                              retval=self.itsdefault(subparam)
		     else:
                        retval=self.itsdefault(subparam)
               return retval
Пример #45
0
 def test_insertafter(self):
     o = odict([('0', 'a')])
     with self.assertRaises(ValueError):
         o.insertafter('0', '0', 'a')
     with self.assertRaises(KeyError):
         o.insertafter('x', '1', 'b')
     o.insertafter('0', '1', 'b')
     self.assertEqual(o.keys(), ['0', '1'])
     self.assertEqual(o.values(), ['a', 'b'])
     o.insertafter('0', '2', 'c')
     self.assertEqual(o.keys(), ['0', '2', '1'])
     self.assertEqual(o.values(), ['a', 'c', 'b'])
Пример #46
0
class CheckForDupesUsing(object):
    # TODO: Rename to RecordingDupMethodType

    NONE = 1
    SUBTITLE = 2
    DESCRIPTION = 4
    SUBTITLE_AND_DESCRIPTION = 6
    SUBTITLE_THEN_DESCRIPTION = 8  # TODO: Verify if exists in protocol 40

    translations = odict([(NONE, 145), (SUBTITLE, 146), (DESCRIPTION, 147),
                          (SUBTITLE_AND_DESCRIPTION, 148),
                          (SUBTITLE_THEN_DESCRIPTION, 200)])
Пример #47
0
class AppRoot(FactoryNode):
    """Application root.
    """
    factories = odict()

    @instance_property
    def properties(self):
        return Properties()

    @instance_property
    def metadata(self):
        return Metadata()
Пример #48
0
    def defaults(self,
                 param=None,
                 ipython_globals=None,
                 paramvalue=None,
                 subparam=None):
        if not hasattr(self, "__globals__") or self.__globals__ == None:
            self.__globals__ = sys._getframe(len(inspect.stack()) -
                                             1).f_globals
        if ipython_globals == None:
            myf = self.__globals__
        else:
            myf = ipython_globals

        a = odict()
        a['subarray'] = 1
        a['is_loop_mode'] = True
        a['start_time'] = ''
        a['end_time'] = ''
        a['task_type'] = ''
        a['time_average'] = ''
        a['time_interval'] = None
        a['debug'] = globalpy.muser_global_debug

        ### This function sets the default values but also will return the list of
        ### parameters or the default value of a given parameter
        if (param == None):
            myf['__set_default_parameters'](a)
        elif (param == 'paramkeys'):
            return a.keys()
        else:
            if (paramvalue == None and subparam == None):
                if (a.has_key(param)):
                    return a[param]
                else:
                    return self.itsdefault(param)
            else:
                retval = a[param]
                if (type(a[param]) == dict):
                    for k in range(len(a[param])):
                        valornotval = 'value'
                        if (a[param][k].has_key('notvalue')):
                            valornotval = 'notvalue'
                        if ((a[param][k][valornotval]) == paramvalue):
                            retval = a[param][k].copy()
                            retval.pop(valornotval)
                            if (subparam != None):
                                if (retval.has_key(subparam)):
                                    retval = retval[subparam]
                                else:
                                    retval = self.itsdefault(subparam)
                        else:
                            retval = self.itsdefault(subparam)
                return retval
Пример #49
0
    def __init__(self):
        self.nsReader = 'Internal.Metadata.NativeFormat'
        
        self.Ty = TypeContainer()
        PublishWellKnownTypes(self.Ty)
            
        self.Ty.MetadataRecord = StructDef('MetadataRecord', flags = AccessFlags.Public | TypeFlags.Partial)
        self.Ty.Handle = self.Ty.MetadataRecord

        self.Ty.NativeWriter = ClassDef('NativeWriter')

        self.records = odict([(rName, self.CreateRecord(rName, rMembers)) for (rName,rMembers) in sd.recordSchema.iteritems()])
Пример #50
0
def pointcal_defaults(param=None):
    a = inspect.stack()
    stacklevel = 0
    for k in range(len(a)):
        if (string.find(a[k][1], 'ipython console') > 0):
            stacklevel = k
    myf = sys._getframe(stacklevel).f_globals
    a = odict()
    a['vis'] = ''
    a['model'] = ''
    a['caltable'] = ''
    a['field'] = ''
    a['spw'] = ''
    a['selectdata'] = {
        1: {
            'value': False
        },
        0:
        odict([{
            'value': True
        }, {
            'timerange': ''
        }, {
            'uvrange': ''
        }, {
            'antenna': ''
        }, {
            'scan': ''
        }, {
            'msselect': ''
        }])
    }
    a['solint'] = 0.0
    if (param == None):
        myf['__set_default_parameters'](a)
    elif (param == 'paramkeys'):
        return a.keys()
    else:
        if (a.has_key(param)):
            return a[param]
Пример #51
0
    def test_compound_blueprint_value_callbacks(self):
        # Check compound with value callbacks
        def val(widget, data):
            return 'val F1'

        value = {
            'f1': val,
        }
        compound = factory('compound', 'comp', value=value)
        compound['f1'] = factory('text')
        self.assertEqual(
            compound(),
            ('<input class="text" id="input-comp-f1" name="comp.f1" '
             'type="text" value="val F1" />'))

        data = compound.extract({'comp.f1': 'New val 1'})
        self.assertEqual(data.name, 'comp')
        self.assertEqual(data.value, {'f1': val})
        expected = odict()
        expected['f1'] = 'New val 1'
        self.assertEqual(data.extracted, expected)
        self.assertEqual(data.errors, [])

        def value(widget, data):
            return {'f1': 'F1 Val'}

        compound = factory('compound', 'comp', value=value)
        compound['f1'] = factory('text')
        self.assertEqual(
            compound(),
            ('<input class="text" id="input-comp-f1" name="comp.f1" '
             'type="text" value="F1 Val" />'))

        data = compound.extract({'comp.f1': 'New val 1'})
        self.assertEqual(data.name, 'comp')
        self.assertEqual(data.value, {'f1': 'F1 Val'})
        expected = odict()
        expected['f1'] = 'New val 1'
        self.assertEqual(data.extracted, expected)
        self.assertEqual(data.errors, [])
Пример #52
0
def parse_init_constructor(myclasses_array_dict):
	# parse 1-times, process self
	for class_name, one_myclass in myclasses_array_dict.iteritems():
		'''
		  - if no init, append one
		  - if mult-init, rename as: init, init2, init3, ...
		  - re-construct init as dict: "init":{ "scope":"public", "paremeter":"", "argument":{"para1":"arg1","para2":"arg2"}
		  - Also append this info into vtable of supers for init
		'''
		if len(one_myclass[const.m_dict['init']]) == 0:
			member_init = copy.deepcopy(const.member_init)
			member_init[const.func.name] = class_name
			one_myclass[const.m_dict['init']].append(member_init)

		for method in one_myclass[const.m_dict['init']]:
			method_setter = odict([('scope', method[const.func.scope]), \
				('name', method[const.func.name]), \
				('params', method[const.func.params]), \
				('args', method[const.func.args]), \
				('setters', odict())])
			one_myclass[const.m_dict['init_setter']].append(method_setter)

			# if have params, try match with vars (no-static)
			if method[const.func.params]:
				params,args = parse_parameters(method[const.func.params])
				for arg in args:
					for variable in one_myclass[const.m_dict['var']]:
						if variable[const.func.static] != 'True' \
							and (variable[const.func.name].lower() == arg \
								or variable[const.func.name].lower() == '_' + arg \
								or variable[const.func.name].lower() == arg + '_'):
							method_setter['setters'][variable[const.func.name]] = arg
							break # exit find first var
			
	# parse 2-times, process supers
	for class_name, one_myclass in myclasses_array_dict.iteritems():
		super_setter = one_myclass[const.m_dict['super_setter']]
		for super_name,superclass in one_myclass[const.m_dict['super']].iteritems():
			super_class = convert_to_class(myclasses_array_dict, super_name)
			super_setter[super_name] = super_class[const.m_dict['init_setter']]
Пример #53
0
 def __init__(self, fic_log=None, fic_sql=None, tipo_log=0, tipo_sql=0):
     self.__contador = 0
     self.__error = None
     self.__cam_valor = odict()
     self.__log = None
     self.__sql = None
     self.__ficlog = fic_log
     self.__ficsql = fic_sql
     self.__tipo_log = tipo_log
     self.__tipo_sql = tipo_sql
     self.db = DbPostgres()
     self.db.auto_commit = False
     self.__cam_filtros = dict()
Пример #54
0
 def renderEpisodeColumn(self, myRenderToken, myGroup):
     results = odict.odict()
     for (listItem, program) in myGroup.programsByListItem.items()[:]:
         if self.closed or xbmc.abortRequested or myRenderToken != self.activeRenderToken:
             return
         try:
             season, episode = self.fanArt.getSeasonAndEpisode(program)
             if season and episode:
                 results[listItem] = '%sx%s' % (season, episode)
                 self.updateListItemProperty(listItem, 'episode', results[listItem])
         except:
             log.exception('Rendering season and episode for program %s' % safe_str(program.fullTitle()))
     myGroup.episodesDone = True
Пример #55
0
def _read_all_giss_struct(fname):
    topo = odict.odict()
    for rec in giss.gissfile.reader(fname):
        val = np.zeros(rec.data.shape)  # Promote to double
        name = rec.var.lower()
        val[:] = rec.data[:]
        topo[name] = giutil.Struct({
            'name': name,
            'val': val,
            'sdims': (u'jm', u'im'),
            'dtype': 'f8'
        })
    return topo
Пример #56
0
    def create(self):
        body = MessageBody(
            self, {
                'area': None,
                'klines': odict.odict(),
                'seenby': [],
                'text': '',
                'body': '',
            })

        body.__struct__ = self

        return body
Пример #57
0
    def defaults(self,
                 param=None,
                 ipython_globals=None,
                 paramvalue=None,
                 subparam=None):
        if not hasattr(self, "__globals__") or self.__globals__ == None:
            self.__globals__ = sys._getframe(len(inspect.stack()) -
                                             1).f_globals
        if ipython_globals == None:
            myf = self.__globals__
        else:
            myf = ipython_globals

        a = odict()
        a['cdate'] = '2013-12-23'
        a['ctime'] = '0:0:0'
        a['cplate'] = 'sun'
        a['ra'] = 0.
        a['dec'] = 0.
        a['debug'] = globalpy.muser_global_debug

        ### This function sets the default values but also will return the list of
        ### parameters or the default value of a given parameter
        if (param == None):
            myf['__set_default_parameters'](a)
        elif (param == 'paramkeys'):
            return a.keys()
        else:
            if (paramvalue == None and subparam == None):
                if (a.has_key(param)):
                    return a[param]
                else:
                    return self.itsdefault(param)
            else:
                retval = a[param]
                if (type(a[param]) == dict):
                    for k in range(len(a[param])):
                        valornotval = 'value'
                        if (a[param][k].has_key('notvalue')):
                            valornotval = 'notvalue'
                        if ((a[param][k][valornotval]) == paramvalue):
                            retval = a[param][k].copy()
                            retval.pop(valornotval)
                            if (subparam != None):
                                if (retval.has_key(subparam)):
                                    retval = retval[subparam]
                                else:
                                    retval = self.itsdefault(subparam)
                        else:
                            retval = self.itsdefault(subparam)
                return retval
Пример #58
0
class CheckForDupesIn(object):
    """
    RecordingDupInType:
       kDupsInRecorded     = 0x01,  1
       kDupsInOldRecorded  = 0x02,  2
       kDupsInAll          = 0x0F,  15
    """

    CURRENT_RECORDINGS = 1
    PREVIOUS_RECORDINGS = 2
    ALL_RECORDINGS = 15

    translations = odict([(ALL_RECORDINGS, 153), (CURRENT_RECORDINGS, 149),
                          (PREVIOUS_RECORDINGS, 150)])
Пример #59
0
    def __init__(self, *args, **kwargs):
        BaseWindow.__init__(self, *args, **kwargs)
        [setattr(self,k,v) for k,v in kwargs.iteritems() if k in ('settings', 'translator', 'platform', 'fanArt', 'cachesByName',)]
        [setattr(self,k,v) for k,v in self.cachesByName.iteritems() if k in ('mythChannelIconCache', 'domainCache')]
         
        self.channels = None                     # Channels sorted and merged (if multiple tuners)
        self.channelsById = None                 # {int channelId:Channel}
        self.programs = None                     # [TVProgram]
        self.listItemsByChannel = odict()        # {Channel:ListItem}
        self.lastSelected = int(self.settings.get('livetv_last_selected'))

        self.activeRenderToken = None
        self.tvQueue = collections.deque()       # Channels showing a tv program that needs poster lookup
        self.movieQueue = collections.deque()    # Channels showing a movie that needs poster lookup
    def get_converted_json_schema_for_angular(self):

        def convert_type(type_name):
            type_map = {
                'textfield': 'string',
                'checkbox': 'string',
                'button': 'string',
                'radio': 'string'
            }
            return type_map.get(type_name, type_name)

        def convert_widget(input_type_name):
            input_type_map = {
                'text': 'string',
                'checkbox': 'checkbox',
                'radio': 'radio',
                'button': 'button'
            }
            return input_type_map.get(input_type_name, input_type_name)
        schema_json_new = {"properties": odict()}
        if self.schema_json:
            schema_json = json.loads(self.schema_json)
            for field in schema_json.get('components'):
                field_dict = {
                    "type": convert_type(field.get('type')),
                    "title": field.get('label', ''),
                    "widget": convert_widget(field.get('inputType', field.get('type'))),
                    "description": field.get('description', ''),
                    "placeholder": field.get('placeholder', '')
                }

                if field.get('type') == 'radio':
                    field_dict["oneOf"] = []
                    for option in field.get('values'):
                        field_dict["oneOf"].append({
                            "description": option.get('label'),
                            "enum": [option.get('value')]
                        })

                if field.get('type') == 'button':
                    if schema_json_new.has_key('buttons'):
                        field_dict['label'] = field_dict['title']
                        schema_json_new['buttons'].append(field_dict)
                    else:
                        schema_json_new['buttons'] = [field_dict]
                else:
                    schema_json_new["properties"][field['key'].replace('undefined', '')] = field_dict
            # import pdb;pdb.set_trace()
            # schema_json_new["required"] = ["email", "password", "rememberMe"]
        return schema_json_new