Iterates over all units

        Returns: generator of Unit
966679
def units(self) -> typing.Iterator['BaseUnit']:
        
        for group in self.groups:
            for unit in group.units:

                yield unit
237403
def get_units(self,*args,**kwargs):
        
        if len(args) == 1:
            return self.spike_times.get_label(args[0]).units
        return [self.spike_times.get_label(a).units for a in args]
606819
def yieldOutput(self):
        
        width = self.__width
        if width:
            num_cols = len(width)
            fmt = ['%%%ds' % -w for w in width]
            if width[-1] > 0:
                fmt[-1] = '%s'
            fmt = self.__sep.join(fmt)
            for row in self.__cols:
                row.extend( [''] * (num_cols - len(row)) )
                yield fmt % tuple(row)
1196407
def generator(self, t):
        """"""
        a = (np.exp(-self.theta * t) - 1) / (np.exp(-self.theta) - 1)
        return -np.log(a)
1065493
def iteritems(self):
        
        for key, val in self.properties.iteritems():
            yield (key, val.value)
659519
def iteritems(self):
        ''''''
        for x in range(len(self.keys)):
            yield (self.keys[x], self.values[x])
310437
def list_units(self):
        
        for page in self._request('Units.List'):
            for unit in page.get('units', []):
                yield Unit(client=self, data=unit)
805107
def _get_wx_units(self, params, name):
        
        units = ""
        for param in params:
            if str(name) == str(param['name']):
                units = param['units']
        return units
104263
def all_generators(self):
        
        for arg_gen in self.arg_gens:
            yield arg_gen

        for kwarg_gen in self.kwarg_gens.values():
            yield kwarg_gen
444645
def GetOutputClasses(cls):
    
    for _, output_class in iter(cls._output_classes.items()):
      yield output_class.NAME, output_class
651639
def chain(cls, *iterables):
    

    def generator():
      for it in iterables:
        for element in it:
          yield element
    return cls(generator())
1295095
def as_base_units(self):
        
        b = collections.defaultdict(int)
        factor = 1
        for k, v in self.items():
            derived = False
            for d in DERIVED_UNITS.values():
                if k in d:
                    for k2, v2 in d[k].items():
                        if isinstance(k2, Number):
                            factor *= k2 ** (v2 * v)
                        else:
                            b[k2] += v2 * v
                    derived = True
                    break
            if not derived:
                si, f = _get_si_unit(k)
                b[si] += v
                factor *= f ** v
        return {k: v for k, v in b.items() if v != 0}, factor
1142094
def _numbers_units(N):
    
    lst = range(1, N + 1)
    return "".join(list(map(lambda i: str(i % 10), lst)))
594495
def values(self):
    
    if self._data:
      for key in xrange(self.order + 1):
        yield self[key]
1324390
def iterpws(self, n):
        
        for _id in np.argsort(self._freq_list)[::-1][:n]:
            pw = self._T.restore_key(_id)
            if self._min_pass_len <= len(pw) <= self._max_pass_len:
                yield _id, pw, self._freq_list[_id]
438052
def units(self, val):
        """"""
        if isinstance(val, units.Unit):
            self._unit = val
        else:
            self._unit = units(val)
409135
def each(unit, options = {}, &block)
      iterate(unit, options.merge(:map_result => false), &block)
    end