def make_column_list( df: Optional[pd.DataFrame] = None, columns: Optional[Union[List[str], str]] = None, prefixes: Optional[Union[List[str], str]] = None, suffixes: Optional[Union[List[str], str]] = None, mask: Optional[Union[List[bool]]] = None) -> None: """Dynamically creates a new column list from a list of columns, lists of prefixes, and/or boolean mask. This method serves as the basis for the 'column_lists' decorator which allows users to pass 'prefixes', 'columns', and 'mask' to a wrapped method with a 'columns' argument. Those three arguments are then combined into the final 'columns' argument. Args: df (DataFrame): pandas object. columns (list or str): column names to be included. prefixes (list or str): list of prefixes for columns to be included. suffixes (list or str): list of suffixes for columns to be included. mask (numpy array, list, or Series, of booleans): mask for columns to be included. Returns: column_names (list): column names created from 'columns', 'prefixes', and 'mask'. """ column_names = [] try: for boolean, feature in zip(mask, list(df.columns)): if boolean: column_names.append(feature) except TypeError: pass try: temp_list = [] for prefix in utilities.listify(prefixes, default_null = True): temp_list = [col for col in df if col.startswith(prefix)] column_names.extend(temp_list) except TypeError: pass try: temp_list = [] for prefix in utilities.listify(suffixes, default_null = True): temp_list = [col for col in df if col.endswith(suffix)] column_names.extend(temp_list) except TypeError: pass try: column_names.extend(utilities.listify(columns, default_null = True)) except TypeError: pass return deduplicate(iterable = column_names)
def _create_mask(self, arguments: Dict[str, Union[List[str], str]]) -> Dict[str, List[str]]: try: arguments['columns'] = utilities.listify(arguments['columns']) except KeyError: arguments['columns'] = [] return arguments
def wrapper(*args, **kwargs): new_arguments = {} parameters = dict(call_signature.parameters) arguments = dict(call_signature.bind(*args, **kwargs).arguments) unpassed = list(parameters.keys() - arguments.keys()) if 'columns' in unpassed: columns = [] else: columns = utilities.listify(arguments['columns']) try: columns.extend( make_column_list(prefixes = arguments['prefixes'])) del arguments['prefixes'] except KeyError: pass try: columns.extend( make_column_list(suffixes = arguments['suffixes'])) del arguments['suffixes'] except KeyError: pass try: columns.extend( make_column_list(mask = arguments['mask'])) del arguments['mask'] except KeyError: pass if not columns: columns = list(columns.keys()) arguments['columns'] = deduplicate(columns) # method.__signature__ = Signature(arguments) return method(**arguments)
def add(self, techniques: Union[ List['Technique'], 'Technique', List[Tuple[str, str]], Tuple[str, str]]) -> None: """Combines 'techniques' with 'steps' or 'techniques' attribute. If a tuple or list of tuples is passed, 'techniques' are added to the 'steps' attribute. Otherwise, they are added to the 'techniques' attribute. Args: techniques (Union[List['Technique'], 'Technique', List[Tuple[str, str]], Tuple[str, str]]): a 'Technique' instance or tuple used to create one. """ if isinstance(utilities.listify(techniques)[0], Tuple): self.steps.extend(utilities.listify(techniques)) else: self.techniques.extend(utilities.listify(techniques)) return self