Python attrdict.AttrDict类代码示例

def BuildSurprise(hist_times,t_before,base_rate,maxbin,surpmax,surpmin):
        
    # hist_times:         the array of spiketimes for each whisker and direction relative to stim
    # t_before & t_after: how long we want to compute the psths bins (all 1 msec)
    # base_rate:          rate of a 1ms bin of the blank psth
    # maxbin:             the number of binning sizes where we compute the surprise, from 1 to maxbin
    # blankw:             the blank whisker number (changes depending on the experiment)
    # surpmax:            up to what time we compute surprise (tipically 55ms)
    # nsizeth:            how many consecutive bins are required to be responsive (tipically 2)
    # surpmin:            is from the time we consider to look for a response (tipically over 5ms)
    
    # we save all in this variable as attr dictionary
    Surprise = dict()
    #-------------------------------------
    # here computing the surprise (from surpmin to surpmax in ms)
    SurpriseW = {}
   
    for w in np.arange(25):
        Surprisefixbin = {}  #here we store the 25 whiskers
        
        for binsize in np.arange(maxbin)+1:
            Surprisefixbin[binsize] = BuildSingleSurprise(hist_times[w],base_rate,binsize,surpmax,t_before)
        
        SurpriseW[w] = Surprisefixbin
            
    Surprise = AttrDict({'Data' : SurpriseW})
    Surprise.update({'logic_tree_data': '[whiskers][binsizes][direction][values] = 25x20x2x'+ str(surpmax-surpmin)})

    return Surprise    

 def add_template_from_json(self, template, basename, version):
     new_tpl = AttrDict(template.copy())
     new_tpl.name = '{}_v{}'.format(basename, version)
     
     # copy old template directory
     tpl_dir = app.config['UPLOADED_TEMPLATES_DEST']
     src = os.path.join(tpl_dir, template.name)
     dst = os.path.join(tpl_dir, new_tpl.name)
     shutil.copytree(src, dst)
     #old_tpl = os.path.join(tpl_dir, 'template', 'template.xml')
     #if os.path.exists(old_tpl):
         #os.remove(old_tpl) # old xml is obsolete
     
     # genericize the template
     def visit(path, key, value):
         if key in set(['cr_date']):
             return False
         elif key in set(['id', 'template_id', 'type_id', 'attr_id']):
             return key, None            
         return key, value
     new_tpl = remap(dict(new_tpl), visit=visit)
     
     new_template = self.call('add_template', {'tmpl': new_tpl})
     
     return new_template

    def search(self, title):
        log.debug("Searching IMDb for '{}'", title)
        results = self.imdb.search_for_title(title)

        print("Results:")
        for i, movie in enumerate(results):
            print("%s: %s (%s)" % (i, movie['title'], movie['year']))

        while True:
            choice = input('Select number or enter an alternate'
                           ' search term: [0-%s, 0 default] ' %
                           (len(results) - 1))
            try:
                choice = int(choice)
            except ValueError:
                if choice:
                    return self.search(choice)
                choice = 0

            try:
                result = results[choice]
            except IndexError:
                pass
            else:
                imdb_id = result['imdb_id']
                log.debug("Found IMDb item {}", imdb_id)
                movie = AttrDict(self.imdb.get_title(imdb_id))
                movie.credits = self.imdb.get_title_credits(imdb_id)['credits']
                movie.genres = self.imdb.get_title_genres(imdb_id)['genres']
                return ImdbResult(movie)

def parse_thread_page(el: bs4.element.Tag) -> AttrDict:
    out = AttrDict()
    out.user = el.select('.postprofile dt')[0].text.strip()
    out.body_html = str(el.select('.content')[0]).strip()
    out.body_text = el.select('.content')[0].text.strip()
    out.date = el.select('.postbody .author')[0].text.strip()
    return out

    def test_len(self):
        """
        Test that len works properly.
        """
        from attrdict import AttrDict

        # empty
        adict = AttrDict()
        self.assertEqual(len(adict), 0)

        # added via key
        adict['key'] = 1
        self.assertEqual(len(adict), 1)

        adict['key'] = 2
        self.assertEqual(len(adict), 1)

        # added via attribute
        adict.attribute = 3
        self.assertEqual(len(adict), 2)

        adict.key = 3
        self.assertEqual(len(adict), 2)

        # deleted
        del adict.key
        self.assertEqual(len(adict), 1)

    def test_setattr(self):
        """
        Test that key-value pairs can be added/changes as attributes
        """
        from attrdict import AttrDict

        adict = AttrDict({'foo': 'bar'})

        adict.foo = 'baz'
        self.assertEqual(adict.foo, 'baz')
        self.assertEqual(adict['foo'], 'baz')

        adict.lorem = 'ipsum'
        self.assertEqual(adict.lorem, 'ipsum')
        self.assertEqual(adict['lorem'], 'ipsum')

        adict.alpha = {'beta': 1, 'bravo': 2}
        self.assertEqual(adict.alpha, {'beta': 1, 'bravo': 2})
        self.assertEqual(adict.alpha.beta, 1)
        self.assertEqual(adict['alpha'], {'beta': 1, 'bravo': 2})

        # with self.assertRaises(TypeError):
        try:
            adict._no = "Won't work"
        except TypeError:
            pass  # expected
        else:
            raise AssertionError("Exception not thrown")

    def __init__(self, response):
        self.raw = response
        self.name = response["name"]
        self.version = response["version"]
        self.description = response["description"]
        self.preseeds = response["preseeds"]

        AttrDict.__init__(self)

def test_pop_removes_attr():
    d = AttrDict(k=True)
    try:
        d.k
    except AttributeError:
        assert False, "AttributeError shouldn't be raised yet"
    d.pop('k')
    d.k

def test_pop_removes_item():
    d = AttrDict(k=True)
    try:
        d['k']
    except KeyError:
        assert False, "KeyError shouldn't be raised yet"
    d.pop('k')
    d['k']

def BuildPSTH(Stims, Spikes, sampling_freq, exp, meas):
    
    stimtimes = {}
    stim_samp = 1/.0009997575757
    # make an 'output dict'
    # the PSTH will be built on -tbefore:tafter
    PSTH_times = {}
    
    # Loop each neuron and get the spikes.
    for neuron in list(Spikes.keys()): 
        codename = 'exp'+ str(exp) + '_' + str(meas) + '_c' + str(neuron)
        psth = AttrDict({'clusnum': neuron,'exp' : int(exp) , 'meas': int(meas[1]) , 'shank': int(meas[3])})
        psth.update(AttrDict({'psth_counts': [] , 'psth_times': []}))
        
        histo= build_hist_dict()
        spikes = Spikes[neuron].spike_times*1000 #(want them in ms)
        
        #loop episodes and stims_per_episode, and populate the histograms
        for ep in np.arange(Stims.episodes)[:]:
            if ep<30:
                stims = 82
            else:
                stims = 28

            #print('Episode: ',ep)
            
            stims=8
            for se in np.arange(stims):#np.arange(Stims.stims_ep):
                #print('se     :',se)
                code = str(int(Stims.st_ctrl[ep][se]))
                c = str(Stims.st_logic.ctrl[code])
                                
                if code=='0':
                    t_after=500
                    start = Stims.st_times[ep][se]
                    if len(spikes[(start <= spikes) * (spikes <= start + t_after)])>0:
                        histo[c].extend(spikes[(start <= spikes) * (spikes <= start + t_after)]-start)
                        histo['Counts'][c] +=  len(spikes[(start <= spikes) * (spikes <= start + t_after)])
                else:
                    code = str(int(Stims.st_types[ep][se]))                                                
                    t = str(Stims.st_logic.types[code])
                
                    code = str(int(Stims.st_pad[ep][se]))
                    p = Stims.st_logic.pad[code]
                    
                    r = Stims.st_rep[ep][se]
                    i = Stims.st_isi[ep][se]
                    start = Stims.st_times[ep][se]
                              
                    t_after = 500*r
                    
                    if len(spikes[(start <= spikes) * (spikes <= start + t_after)])>0:
                        histo[c][t][p][r][i].extend(spikes[(start <= spikes) * (spikes <= start + t_after)]-start)
                        histo['Counts'][c][t][p][r][i]  += len((spikes[(start <= spikes) * (spikes <= start + t_after)]))
                                                       
        PSTH_times[codename] = histo
       
    return PSTH_times

    def test_valid_name(self):
        """
        Test that valid_name works.
        """
        from attrdict import AttrDict

        self.assertTrue(AttrDict._valid_name('valid'))
        self.assertFalse(AttrDict._valid_name('_invalid'))
        self.assertFalse(AttrDict._valid_name('get'))

    def test_build(self):
        """
        Test that build works.
        """
        from attrdict import AttrDict

        self.assertTrue(isinstance(AttrDict._build({}), AttrDict))
        self.assertTrue(isinstance(AttrDict._build([]), list))
        self.assertTrue(isinstance(AttrDict._build(AttrDict()), AttrDict))
        self.assertTrue(isinstance(AttrDict._build(1), int))

 def __init__(self, id, parent):
   """ Inits a new widget.
   The constructor should never be called directly. To add a sub-widgegt use
   _add_widget. To create a root widget see report.py
   """
   self.id = id
   self.parent = parent
   self.unique_counter = 0
   self.widgets = AttrDict()
   self.values = AttrDict()
   self.value_name_to_cache_key = {}

    def test_delattr(self):
        """
        Test that key-value pairs can be deleted as attributes.
        """
        from attrdict import AttrDict

        adict = AttrDict({'foo': 'bar', '_set': 'shadows', 'get': 'shadows'})

        del adict.foo

        # with self.assertRaises(AttributeError):
        try:
            adict.foo
        except AttributeError:
            pass  # expected
        else:
            raise AssertionError("Exception not thrown")

        # with self.assertRaises(KeyError):
        try:
            adict['foo']
        except KeyError:
            pass  # expected
        else:
            raise AssertionError("Exception not thrown")

        # with self.assertRaises(TypeError):
        try:
            del adict.lorem
        except TypeError:
            pass  # expected
        else:
            raise AssertionError("Exception not thrown")

        # with self.assertRaises(TypeError):
        try:
            del adict._set
        except TypeError:
            pass  # expected
        else:
            raise AssertionError("Exception not thrown")

        # with self.assertRaises(TypeError):
        try:
            del adict.get
        except TypeError:
            pass  # expected
        else:
            raise AssertionError("Exception not thrown")

        # make sure things weren't deleted
        adict._set
        self.assertEqual(adict.get('get'), 'shadows')
        self.assertEqual(adict, {'_set': 'shadows', 'get': 'shadows'})

    def __init__(self, env='prod'):

        self.env = os.environ.get('NETKI_ENV', env)

        config_file = ConfigManager.find_config_file(self.env)

        if not config_file or not os.path.isfile(config_file):
            raise Exception('Cannot Find Config File app.%s.config' % self.env)

        log.info('Loading Configuration [ENV: %s | FILE: %s]' % (self.env, config_file))

        with open(config_file,'r') as file:
            config = ConfigParser.ConfigParser()
            config.readfp(file)

            pre_transform_dict = AttrDict(config._sections)
            for k,v in pre_transform_dict.iteritems():
                if isinstance(v, dict):
                    is_changed = False
                    for key,value in v.items():

                        # Convert Bools
                        if value.strip().lower() == 'true':
                            v[key] = True
                            is_changed = True
                            continue

                        if value.strip().lower() == 'false':
                            v[key] = False
                            is_changed = True
                            continue

                        # Convert Floats
                        try:
                            if '.' in value:
                                v[key] = float(value)
                                is_changed = True
                                continue
                        except ValueError:
                            pass

                        # Convert Ints
                        try:
                            v[key] = int(value)
                            is_changed = True
                            continue
                        except ValueError:
                            pass

                    if is_changed:
                        pre_transform_dict.__setattr__(k,v)

            self.config_dict = pre_transform_dict