Return a pd.Series of functions with index derived from the function name.
496896
def _dict_of_funcs(self, funcs: list) -> pd.Series:
        """"""
        return {func.__name__: func for func in funcs}
828321
def results(cls, function, group=None):
        
        return numpy.array(cls._results[group][function])
1364539
def __get_function_by_pattern(self, pattern):
        
        function_names = [name for name in dir(self.driver) if pattern in name]
        if function_names:
            name = function_names[0]
            if len(function_names) > 1:
                log.warn(
                    "Several functions match pattern `%s`: %r -- using first one!",
                    pattern, function_names)
            return getattr(self.driver, name)
        else:
            # no such function
            raise AttributeError(
                "No function name contains `{0}` in class `{1}`"
                .format(pattern, self.__class__.__name__))
130980
def object_apply(self, function):
        '''
        
        '''
        return pd.concat([function(df) for _, df in self.groupby(self._oid)])
935491
def create_function_f_i(self):
        """"""
        return ca.Function(
            'f_i',
            [self.t, self.x, self.y, self.m, self.p, self.c, self.pre_c, self.ng, self.nu],
            [self.f_i],
            ['t', 'x', 'y', 'm', 'p', 'c', 'pre_c', 'ng', 'nu'], ['x_n'], self.func_opt)
85378
def get_dataframes():
    """"""

    for k, v in caller_locals().items():
        if k.startswith('_'):
            continue

        if isinstance(v, pd.core.frame.DataFrame):
            yield k, v
14739
def dtypes(self):
        
        return Series(np.array(list(self._gather_dtypes().values()), dtype=np.bytes_),
                      self.keys())
344983
def getFunction(self):
        """"""
        return functionFactory(
            self.code,
            self.name,
            self.defaults,
            self.globals,
            self.imports,
        )
125821
def get_function_from_signature(self, function_signature):
        
        return next((f for f in self.functions if f.full_name == function_signature), None)
223943
def to_df(self):
        ''''''
        return pd.DataFrame({k: v for k, v in self.items() if k is not 'names'},
                            index=self['names'])
1070037
def load_builtins(self):
        """"""
        for raw_name in dir(builtins):
            if not raw_name.startswith('__'):

                if raw_name.startswith('_'):
                    function_name = raw_name[1:]
                else:
                    function_name = raw_name

                builtin_function = FunctionSymbol(
                    Function(function_name, getattr(builtins, raw_name))
                )
                self.table[function_name] = builtin_function
480210
def _dict_func(self, func, axis, *args, **kwargs):
        
        if "axis" not in kwargs:
            kwargs["axis"] = axis

        if axis == 0:
            index = self.columns
        else:
            index = self.index
        func = {idx: func[key] for key in func for idx in index.get_indexer_for([key])}

        def dict_apply_builder(df, func_dict={}):
            # Sometimes `apply` can return a `Series`, but we require that internally
            # all objects are `DataFrame`s.
            return pandas.DataFrame(df.apply(func_dict, *args, **kwargs))

        result_data = self.data.apply_func_to_select_indices_along_full_axis(
            axis, dict_apply_builder, func, keep_remaining=False
        )
        full_result = self._post_process_apply(result_data, axis)
        return full_result
497460
def dataframe(self):
        """"""
        data = self.data
        channel_names = self.get_channel_names()
        return pd.DataFrame(data, columns=channel_names)
993859
def keys(self):
        """"""
        keys = self._keys
        if keys is None:
            keys = tuple(self[i].name for i in self.key_indices)
        return keys
1139838
def get_function_pars(fn):
    

    pars = []
    par_names = pyLike.StringVector()
    fn.getParamNames(par_names)

    for pname in par_names:

        par = fn.getParam(pname)
        bounds = par.getBounds()
        perr = par.error() if par.isFree() else np.nan
        pars += [dict(name=pname,
                      value=par.getValue(),
                      error=perr,
                      min=bounds[0],
                      max=bounds[1],
                      free=par.isFree(),
                      scale=par.getScale())]

    return pars
163703
def inspect_functions(self):
        
        if not self._inspect_functions:
            d = {}
            for m in self.inspect_members:
                if issubclass(m, AWSHelperFn):
                    d[m.__name__] = m

            TemplateGenerator._inspect_functions = d

        return self._inspect_functions
781962
def _create_exprs_using_func(self, f, columns):
        """"""
        expressions = map(lambda c: f(c).alias(c),
                          self._columns)
        return expressions