Parameters
        ----------
        X: pandas.DataFrame, the dataset features
        Y: pandas.Series, the dataset targets
        column_types: Dict[str, str], dict from column name to column type as
            "NUMERIC" or "CATEGORICAL" or "TEXT", must include Y column
        metafeature_ids: list, the metafeatures to compute. default of None
            indicates to compute all metafeatures
        exclude: list, default None. The metafeatures to be excluded from computation.
            Must be None if metafeature_ids is not None.
        sample_shape: tuple, the shape of X after sampling (X,Y) uniformly.
            Default is (None, None), indicate not to sample rows or columns.
        seed: int, the seed used to generate pseudo-random numbers. when None
            is given, a seed will be generated pseudo-randomly. this can be
            used for reproducibility of metafeatures. a generated seed can be
            accessed through the 'seed' property, after calling this method.
        n_folds: int, the number of cross validation folds used by the
            landmarking metafeatures. also affects the sample_shape validation
        verbose: bool, default False. When True, prints the ID of each
            metafeature right before it is about to be computed.
        timeout: float, default None. If timeout is None, compute_metafeatures
            will be run to completion. Otherwise, execution will halt after
            approximately timeout seconds. Any metafeatures that have not been
            computed will be labeled 'TIMEOUT'.

        Returns
        -------
        A dictionary mapping the metafeature id to another dictionary containing
        the `value` and `compute_time` (if requested) of the referencing
        metafeature. The value is typically a number, but can be a string
        indicating a reason why the value could not be computed.

def compute(
        self, X: DataFrame, Y: Series=None,
        column_types: Dict[str, str]=None, metafeature_ids: List=None,
        exclude: List=None, sample_shape=None, seed=None, n_folds=2,
        verbose=False, timeout=None
    ) -> dict:
        """
        Parameters
        ----------
        X: pandas.DataFrame, the dataset features
        Y: pandas.Series, the dataset targets
        column_types: Dict[str, str], dict from column name to column type as
            "NUMERIC" or "CATEGORICAL" or "TEXT", must include Y column
        metafeature_ids: list, the metafeatures to compute. default of None
            indicates to compute all metafeatures
        exclude: list, default None. The metafeatures to be excluded from computation.
            Must be None if metafeature_ids is not None.
        sample_shape: tuple, the shape of X after sampling (X,Y) uniformly.
            Default is (None, None), indicate not to sample rows or columns.
        seed: int, the seed used to generate pseudo-random numbers. when None
            is given, a seed will be generated pseudo-randomly. this can be
            used for reproducibility of metafeatures. a generated seed can be
            accessed through the 'seed' property, after calling this method.
        n_folds: int, the number of cross validation folds used by the
            landmarking metafeatures. also affects the sample_shape validation
        verbose: bool, default False. When True, prints the ID of each
            metafeature right before it is about to be computed.
        timeout: float, default None. If timeout is None, compute_metafeatures
            will be run to completion. Otherwise, execution will halt after
            approximately timeout seconds. Any metafeatures that have not been
            computed will be labeled 'TIMEOUT'.

        Returns
        -------
        A dictionary mapping the metafeature id to another dictionary containing
        the `value` and `compute_time` (if requested) of the referencing
        metafeature. The value is typically a number, but can be a string
        indicating a reason why the value could not be computed.
        """
        start_time = time.time()
        self._validate_compute_arguments(
            X, Y, column_types, metafeature_ids, exclude, sample_shape, seed,
            n_folds, verbose
        )
        if timeout is None:
            def check_time():
                pass
        else:
            def check_time():
                if time.time() - start_time > timeout:
                    raise TimeoutError()
        self._check_timeout = check_time

        if column_types is None:
            column_types = self._infer_column_types(X, Y)
        if metafeature_ids is None:
            metafeature_ids = self._get_metafeature_ids(exclude)
            exclude = None
        if sample_shape is None:
            sample_shape = (None, None)
        if seed is None:
            seed = np.random.randint(np.iinfo(np.int32).max)
        self._validate_compute_arguments(
            X, Y, column_types, metafeature_ids, exclude, sample_shape, seed,
            n_folds, verbose
        )

        self._init_resources(
            X, Y, column_types, sample_shape, seed, n_folds
        )

        computed_metafeatures = {name: {self.VALUE_KEY: self.TIMEOUT, self.COMPUTE_TIME_KEY: 0}
                                 for name in metafeature_ids}
        try:
            for metafeature_id in metafeature_ids:
                self._check_timeout()
                if verbose:
                    print(metafeature_id)
                if self._resource_is_target_dependent(metafeature_id) and (
                    Y is None or column_types[Y.name] == self.NUMERIC
                ):
                    if Y is None:
                        value = self.NO_TARGETS
                    else:
                        value = self.NUMERIC_TARGETS
                    compute_time = None
                else:
                    value, compute_time = self._get_resource(metafeature_id)

                computed_metafeatures[metafeature_id] = {
                    self.VALUE_KEY: value,
                    self.COMPUTE_TIME_KEY: compute_time
                }
        except TimeoutError:
            pass

        return computed_metafeatures