GroupByRefiner Class Reference

Inheritance diagram for GroupByRefiner:

Public Member Functions
def	__init__ (self, wrapped_refiner, by=None, exclude_by=None)
def	refine (self, harvesting_module, crops, groupby_part_name=None, groupby_value=None, *args, **kwds)

Public Attributes
	wrapped_refiner
	cached value of the wrapped refiner
	by
	cached value of the group-by classifier
	exclude_by
	cached value of the exclude-by classifier

Static Public Attributes
bool	default_exclude_by = True
	default value of the exclude-by classifier

Detailed Description

Refiner for grouping

Definition at line 939 of file refiners.py.

Constructor & Destructor Documentation

__init__()

def __init__	(		self,
			wrapped_refiner,
			by = None,
			exclude_by = None
	)

Constructor for this refiner

Reimplemented from Refiner.

Definition at line 945 of file refiners.py.

                 exclude_by=None):
        """Constructor for this refiner"""
        if by is None:
            by = []
        
        self.wrapped_refiner = wrapped_refiner
        
        self.by = by
        
        self.exclude_by = exclude_by if exclude_by is not None else self.default_exclude_by
 

Member Function Documentation

refine()

def refine	(		self,
			harvesting_module,
			crops,
			groupby_part_name = None,
			groupby_value = None,
		*	args,
		**	kwds
	)

Process this grouping

Reimplemented from Refiner.

Definition at line 959 of file refiners.py.

               **kwds):
        """Process this grouping"""
 
        by = self.by
 
        # A single name to do the group by
        if isinstance(by, str) or by is None:
            part_name = by
            # Wrap it into a list an continue with the general case
            by = [part_name, ]
 
        for groupby_spec in by:
            if groupby_spec is None:
                # Using empty string as groupby_value to indicate that all values have been selected
                value = None
                self.wrapped_refiner(harvesting_module,
                                     crops,
                                     groupby_part_name=None,
                                     groupby_value=value,
                                     *args,
                                     **kwds)
                continue
 
            elif isinstance(groupby_spec, str):
                part_name = groupby_spec
                groupby_parts = crops[part_name]
                unique_values, index_of_values = np.unique(groupby_parts, return_inverse=True)
                groupby_values = [f" = {value}]" for value in unique_values]
 
            elif isinstance(groupby_spec, tuple):
                part_name = groupby_spec[0]
                cuts = groupby_spec[1]
 
                groupby_parts = crops[part_name]
 
                # Take care of nans
                digitization_cuts = list(np.sort(cuts))
                if digitization_cuts[-1] != np.inf:
                    digitization_cuts.append(np.inf)
                index_of_values = np.digitize(groupby_parts, digitization_cuts, right=True)
 
                groupby_values = [f"below {digitization_cuts[0]}"]
                bin_bounds = list(zip(digitization_cuts[0:], digitization_cuts[1:]))
                for lower_bound, upper_bound in bin_bounds:
                    if lower_bound == upper_bound:
                        # degenerated bin case
                        groupby_values.append(f"= {lower_bound}")
                    elif upper_bound == np.inf:
                        groupby_values.append(f"above {lower_bound}")
                    else:
                        groupby_values.append(f"between {lower_bound} and {upper_bound}")
                groupby_values.append("is nan")
                assert len(groupby_values) == len(digitization_cuts) + 1
 
            else:
                raise ValueError(f"Unknown groupby specification {groupby_spec}")
 
            # Exclude the groupby variable if desired
            selected_crops = select_crop_parts(crops, exclude=part_name if self.exclude_by else None)
            for index_of_value, groupby_value in enumerate(groupby_values):
                indices_for_value = index_of_values == index_of_value
                if not np.any(indices_for_value):
                    continue
 
                filtered_crops = filter_crops(selected_crops, indices_for_value)
 
                self.wrapped_refiner(harvesting_module,
                                     filtered_crops,
                                     groupby_part_name=part_name,
                                     groupby_value=groupby_value,
                                     *args,
                                     **kwds)
 
 

Member Data Documentation

by

by

cached value of the group-by classifier

Definition at line 955 of file refiners.py.

default_exclude_by

bool default_exclude_by = True

static

default value of the exclude-by classifier

Definition at line 943 of file refiners.py.

exclude_by

exclude_by

cached value of the exclude-by classifier

Definition at line 957 of file refiners.py.

wrapped_refiner

wrapped_refiner

cached value of the wrapped refiner

Definition at line 953 of file refiners.py.

---

The documentation for this class was generated from the following file:

• tracking/scripts/tracking/harvest/refiners.py