this should take a variable or a function and turn it into a list by evaluating on each planet
169267
def _set_axis(self, param, unit):
        
        axisValues = []
        for astroObject in self.objectList:
            try:
                value = eval('astroObject.{0}'.format(param))
            except ac.HierarchyError:  # ie trying to call planet.star and one planet is a lone ranger
                value = np.nan

            if unit is None:  # no unit to rescale (a aq.unitless quanitity would otherwise fail with ValueError)
                axisValues.append(value)
            else:
                try:
                    axisValues.append(value.rescale(unit))
                except AttributeError:  # either nan or unitless
                    axisValues.append(value)

        return axisValues
1204370
def functions(self):
        
        return [v for v in self.globals.values()
                if isinstance(v, values.Function)]
520350
def _transform(self, var):
        '''  '''
        self.collection.variables.pop(var.name)
        return var.values
1274813
def cli(obj):
    """"""
    for k, v in obj.items():
        if isinstance(v, list):
            v = ', '.join(v)
        click.echo('{:20}: {}'.format(k, v))
1368615
def pointlist(points, sr):
    """"""
    assert all(isinstance(pt, Point) or len(pt) == 2 
               for pt in points), "Point(s) not in [x, y] form"
    return [coord if isinstance(coord, Point) 
                  else Point(coord[0], coord[1], sr)
            for coord in points]
485562
def slithir_variables(self):
        '''
            
        '''
        slithir_variables = [f.slithir_variables for f in self.functions + self.modifiers]
        slithir_variables = [item for sublist in slithir_variables for item in sublist]
        return list(set(slithir_variables))
411944
def _replace_variables(data, variables):
    """"""
    formatter = string.Formatter()
    return [formatter.vformat(item, [], variables) for item in data]
716285
def as_list(self, fs_type=None):
        """"""
        entries = self._entries
        if fs_type:
            entries = filter(lambda a: a.fs_type == fs_type, entries)
        return entries
1029213
def plotted_data(self):
        """"""
        return InteractiveList(
            [arr for arr, val in zip(self.iter_data,
                                     cycle(slist(self.value)))
             if val is not None])
424342
def each(self, func):
        
        if self._clean.isTuple() or self._clean.isList():
            for index, value in enumerate(self.obj):
                r = func(value, index, self.obj)
                if r is "breaker":
                    break
        else:
            for index, key in enumerate(self.obj):
                r = func(self.obj[key], key, self.obj, index)
                if r is "breaker":
                    break
        return self._wrap(self)
1308216
def _to_list(var):
    
    if isinstance(var, list):
        return var
    elif var is None:
        return []
    elif isinstance(var, str) or isinstance(var, dict):
        # We dont want to make a list out of those via the default constructor
        return [var]
    else:
        try:
            return list(var)
        except TypeError:
            return [var]
862065
def _multi(fun, lons, lats, chunk_size, cores=1):
    
    pool = Pool(processes=cores)

    splits = get_scene_splits(lons.shape[0], chunk_size, cores)

    lons_parts = np.vsplit(lons, splits)
    lats_parts = np.vsplit(lats, splits)

    results = [pool.apply_async(fun,
                                (lons_parts[i],
                                 lats_parts[i]))
               for i in range(len(lons_parts))]

    pool.close()
    pool.join()

    lons, lats = zip(*(res.get() for res in results))

    return np.vstack(lons), np.vstack(lats)
453060
def evaluate_list(molecules, ensemble_lookup, options):
    

    # create stats dictionaries to store results from each ensemble
    stats = {}  # {file name : metric_List}

    # print progress messages
    if options.write_roc:
        print(" Determining virtual screening performance and writing ROC data ... ")
        print('')
    else:
        print(" Determining virtual screening performance ...")
        print('')

    for filename in sorted(ensemble_lookup.keys()):
        metric_List = calculate_metrics(molecules, ensemble_lookup, filename, options)
        stats[filename] = metric_List

    # write results summary
    output.write_summary(stats, options, fw_type = None)

    # plot
    if options.plot:
        print(" Making plots ... ")
        print
        plotter(molecules, ensemble_lookup, options)
476174
def p_GlobalVaribleList(p):
    '''
    
    '''
    if len(p) > 2:
        p[0] = GlobalVaribleList(p[1], p[3])
    else:
        p[0] = GlobalVaribleList(None, p[1])
658810
def local_variables(self):
        
        return list(set(self.variables) - set(self.returns) - set(self.parameters))
613254
def extract_indexes(coords):
    """"""
    for name, variable in coords.items():
        variable = as_variable(variable, name=name)
        if variable.dims == (name,):
            yield name, variable.to_index()
969999
def map(self, fn):
        """"""
        return TimeSeries([(x, fn(y)) for x, y in self.points])