def merge_ordered(left, right, on=None,<EOL>left_on=None, right_on=None,<EOL>left_by=None, right_by=None,<EOL>fill_method=None, suffixes=('<STR_LIT>', '<STR_LIT>'),<EOL>how='<STR_LIT>'):
def _merger(x, y):<EOL><INDENT>op = _OrderedMerge(x, y, on=on, left_on=left_on, right_on=right_on,<EOL>suffixes=suffixes, fill_method=fill_method,<EOL>how=how)<EOL>return op.get_result()<EOL><DEDENT>if left_by is not None and right_by is not None:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>elif left_by is not None:<EOL><INDENT>result, _ = _groupby_and_merge(left_by, on, left, right,<EOL>lambda x, y: _merger(x, y),<EOL>check_duplicates=False)<EOL><DEDENT>elif right_by is not None:<EOL><INDENT>result, _ = _groupby_and_merge(right_by, on, right, left,<EOL>lambda x, y: _merger(y, x),<EOL>check_duplicates=False)<EOL><DEDENT>else:<EOL><INDENT>result = _merger(left, right)<EOL><DEDENT>return result<EOL>
Perform merge with optional filling/interpolation designed for ordered
    data like time series data. Optionally perform group-wise merge (see
    examples)

    Parameters
    ----------
    left : DataFrame
    right : DataFrame
    on : label or list
        Field names to join on. Must be found in both DataFrames.
    left_on : label or list, or array-like
        Field names to join on in left DataFrame. Can be a vector or list of
        vectors of the length of the DataFrame to use a particular vector as
        the join key instead of columns
    right_on : label or list, or array-like
        Field names to join on in right DataFrame or vector/list of vectors per
        left_on docs
    left_by : column name or list of column names
        Group left DataFrame by group columns and merge piece by piece with
        right DataFrame
    right_by : column name or list of column names
        Group right DataFrame by group columns and merge piece by piece with
        left DataFrame
    fill_method : {'ffill', None}, default None
        Interpolation method for data
    suffixes : Sequence, default is ("_x", "_y")
        A length-2 sequence where each element is optionally a string
        indicating the suffix to add to overlapping column names in
        `left` and `right` respectively. Pass a value of `None` instead
        of a string to indicate that the column name from `left` or
        `right` should be left as-is, with no suffix. At least one of the
        values must not be None.

        .. versionchanged:: 0.25.0
    how : {'left', 'right', 'outer', 'inner'}, default 'outer'
        * left: use only keys from left frame (SQL: left outer join)
        * right: use only keys from right frame (SQL: right outer join)
        * outer: use union of keys from both frames (SQL: full outer join)
        * inner: use intersection of keys from both frames (SQL: inner join)

        .. versionadded:: 0.19.0

    Returns
    -------
    merged : DataFrame
        The output type will the be same as 'left', if it is a subclass
        of DataFrame.

    See Also
    --------
    merge
    merge_asof

    Examples
    --------
    >>> A                      >>> B
          key  lvalue group        key  rvalue
    0   a       1     a        0     b       1
    1   c       2     a        1     c       2
    2   e       3     a        2     d       3
    3   a       1     b
    4   c       2     b
    5   e       3     b

    >>> merge_ordered(A, B, fill_method='ffill', left_by='group')
      group key  lvalue  rvalue
    0     a   a       1     NaN
    1     a   b       1     1.0
    2     a   c       2     2.0
    3     a   d       2     3.0
    4     a   e       3     3.0
    5     b   a       1     NaN
    6     b   b       1     1.0
    7     b   c       2     2.0
    8     b   d       2     3.0
    9     b   e       3     3.0