Calculates a matrix for a given set of instance ids and calculation times. Args: features (list[:class:`.FeatureBase`]): Feature definiti

Add a DataFrame to the EntitySet with Woodwork typing information. Args: dataframe (pandas.DataFrame) : Dataframe contai

Calculates a feature matrix and features given a dictionary of dataframes and a list of relationships. Args: dataframes (dict[str ->

Automatically builds feature definitions for target dataframe using Deep Feature Synthesis algorithm Args: return_typ

Gets the cache entry, if enabled and defined Args: cache_type (CacheType): type of cache hashkey (int): hash key

Combine entityset with another to create a new entityset with the combined data of both entitysets.

Calculate values of features for the given instances of the target dataframe. Summary of algorithm: 1. Construct a t

Adds an entry to the cache, if enabled Args: cache_type (CacheType): type of cache hashkey (int): hash key

Get the sub-trie at the given path. If it does not yet exist initialize it with the default value. Examples: >>>

Replace the internal dataframe of an EntitySet table, keeping Woodwork typing information the same. Optionally makes sure that data is sorted,

Create a new dataframe and relationship from unique values of an existing column. Args: base_dataframe_name (str) : Dataframe nam

Calculates the last time index values for each dataframe (the last time an instance or children of that instance were observed). Use

Generates an English language description of a feature. Args: feature (FeatureBase) : Feature to describe feature_descriptions (d

Add a new relationship between dataframes in the entityset. Relationships can be specified by passing dataframe and columns names or by passin

Returns features that are used to calculate this feature ..note:: If you only want the features that make up the input to the fe

Rename Feature, returns copy. Will reset any custom feature column names to their default value.

Checks if a candidate schema should be considered a match for a template schema

Provide rolling window calculations where the windows are determined using both a gap parameter that indicates the amount of time between each ins

Encode categorical features Args: feature_matrix (pd.DataFrame): Dataframe of features. features (list[PrimitiveBase]): Feature d

build a dictionary with the data necessary to construct the given primitive

Find or set interesting values for categorical columns, to be used to generate "where" clauses Args: max_values (int) : Maximum n

Create a backward RelationshipPath through the given dataframes. Assumes only one such path is possible.

Convert strings to Timedelta objects Allows for both shortform and longform units, as well as any form of capitalization '2 Minutes'

Checks if features in inputs can be used with supplied primitive using the stacking rules. Returns True if stacking is possible, and Fals

Extract the numeric element of a potential offset string. Args: offset (int, str): If offset is an integer, that value is returned. If of

Gets a DataFrame's semantic tags without index or time index tags for Woodwork init

Get relationships where dataframe "dataframe_name" is the child Args: dataframe_name (str): Name of dataframe to get relationship

Generates a feature lineage graph for the given feature Args: feature (FeatureBase) : Feature to generate lineage graph for to_fi

Applies the gap offset_string to the rolled window, returning a window that is the correct length of time away from the original instance. Ar

Returns depth of feature

Returns two lists of primitives (transform and aggregation) containing primitives that can be applied to the specific target dataframe to cre

Saves the features list as JSON to a specified filepath/S3 path, writes to an open file, or returns the serialized features as a JSON string. If n

Applies a given aggregation function to a rolled series. Args: series (Series): The series over which rolling windows will be created. Th

** EXPERIMENTAL ** Calculates all Features for a given input of features and a list of primitives. Args: origin_features (List[L

Loads the features from a filepath, S3 path, URL, an open file, or a JSON formatted string. Args: features (str or :class:`.FileObject`):

Set new values for the feature column names, overriding the default values. Number of names provided must match the number of output columns d

Set the secondary time index for a dataframe in the EntitySet using its dataframe name. Args: dataframe_name (str) : nam

Query instances that have column with given value Args: dataframe_name (str): The id of the dataframe to query instan

Takes in a series to which an offset gap will be applied, removing however many rows fall under the gap before applying the reducing function.

Returns all transform primitives

Removes columns in feature matrix that are highly correlated with another column. Note: We make the assumption that, for a pair of featur

Attempts to import the requested library. If the import fails, raises an ImportErorr with the supplied Args: library (str): the

Converts a time specified in seconds to a time in the given units Args: secs (integer): number of seconds. This function will conver

Recursively transforms a LiteFeature object into a Featurebase object Args: feature (LiteFeature) base_features (List[Featur

Checks if the given string is a s3 path. Returns a boolean.

Get a set of recommended skew numeric primitives given an entity set. Description: Given woodwork initialized dataframe of origin feature

Create a forward RelationshipPath through the given dataframes. Assumes only one such path is possible.

Returns all aggregation primitives

Removes columns from a feature matrix that have higher than a set threshold of null values. Args: feature_matrix (:class:`pd.Dat

** EXPERIMENTAL ** Convert a Woodwork Schema object to a list of LiteFeatures. Args: schema (TableSchema): Woodwork