GroupByRefiner Class Reference

Inheritance diagram for GroupByRefiner:

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

Public Attributes
	wrapped_refiner = wrapped_refiner
	cached value of the wrapped refiner
	by = by
	cached value of the group-by classifier
bool	exclude_by = exclude_by if exclude_by is not None else self.default_exclude_by
	cached value of the exclude-by classifier
	refiner_function = refiner_function
	cached copy of the instance's refiner function

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__()

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

Constructor for this refiner

Definition at line 945 of file refiners.py.

                 exclude_by=None):
        """Constructor for this refiner"""
        if by is None:
            by = []
        ## cached value of the wrapped refiner
        self.wrapped_refiner = wrapped_refiner
        ## cached value of the group-by classifier
        self.by = by
        ## cached value of the exclude-by classifier
        self.exclude_by = exclude_by if exclude_by is not None else self.default_exclude_by
 

Member Function Documentation

__call__()

__call__ ( self, harvesting_module, crops = None, * args, ** kwds )

inherited

implementation of the function-call of the Refiner instance
     r = Refiner()
     r(harvester) # decoration
     r(harvester, crops, args, keywords) # refinement

Definition at line 55 of file refiners.py.

    def __call__(self, harvesting_module, crops=None, *args, **kwds):
        """implementation of the function-call of the Refiner instance
             r = Refiner()
             r(harvester) # decoration
             r(harvester, crops, args, keywords) # refinement
        """
        if crops is None:
            # Decoration mode
            harvesting_module.refiners.append(self)
            return harvesting_module
        else:
            # Refining mode
            return self.refine(harvesting_module, crops, *args, **kwds)
 

__get__()

__get__ ( self, harvesting_module, cls = None )

inherited

Getter of the Refiner instance

Definition at line 42 of file refiners.py.

    def __get__(self, harvesting_module, cls=None):
        """Getter of the Refiner instance"""
        if harvesting_module is None:
            # Class access
            return self
        else:
            # Instance access
            refine = self.refine
 
            def bound_call(*args, **kwds):
                return refine(harvesting_module, *args, **kwds)
            return bound_call
 

refine()

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 = 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

bool exclude_by = exclude_by if exclude_by is not None else self.default_exclude_by

cached value of the exclude-by classifier

Definition at line 957 of file refiners.py.

refiner_function

refiner_function = refiner_function

inherited

cached copy of the instance's refiner function

Definition at line 40 of file refiners.py.

wrapped_refiner

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