code: def align(
      df,
      other,
      join: str = "outer",
      axis: Union[int, str, None] = None,
      level: Union[int, str, None] = None,
      copy: bool = True,
      fill_value: Any = None,
      method: str = None,
      limit: Optional[int] = None,
      fill_axis: Union[int, str] = 0,
      broadcast_axis: Union[int, str] = None,
  ):
      """
      Align two objects on their axes with the specified join method.
  
      Join method is specified for each axis Index.
  
      Parameters
      ----------
      other : DataFrame or Series
      join : {'outer', 'inner', 'left', 'right'}, default 'outer'
      axis : allowed axis of the other object, default None
          Align on index (0), columns (1), or both (None).
      level : int or level name, default None
          Broadcast across a level, matching Index values on the
          passed MultiIndex level.
      copy : bool, default True
          Always returns new objects. If copy=False and no reindexing is
          required then original objects are returned.
      fill_value : scalar, default np.NaN
          Value to use for missing values. Defaults to NaN, but can be any
          "compatible" value.
      method : {'backfill', 'bfill', 'pad', 'ffill', None}, default None
          Method to use for filling holes in reindexed Series:
  
          - pad / ffill: propagate last valid observation forward to next valid.
          - backfill / bfill: use NEXT valid observation to fill gap.
  
      limit : int, default None
          If method is specified, this is the maximum number of consecutive
          NaN values to forward/backward fill. In other words, if there is
          a gap with more than this number of consecutive NaNs, it will only
          be partially filled. If method is not specified, this is the
          maximum number of entries along the entire axis where NaNs will be
          filled. Must be greater than 0 if not None.
      fill_axis : {0 or 'index', 1 or 'columns'}, default 0
          Filling axis, method and limit.
      broadcast_axis : {0 or 'index', 1 or 'columns'}, default None
          Broadcast values along this axis, if aligning two objects of
          different dimensions.
  
      Notes
      -----
      Currently argument `level` is not supported.
  
      Returns
      -------
      (left, right) : (DataFrame, type of other)
          Aligned objects.
  
      Examples
      --------
      >>> import mars.tensor as mt
      >>> import mars.dataframe as md
      >>> df = md.DataFrame(
      ...     [[1, 2, 3, 4], [6, 7, 8, 9]], columns=["D", "B", "E", "A"], index=[1, 2]
      ... )
      >>> other = md.DataFrame(
      ...     [[10, 20, 30, 40], [60, 70, 80, 90], [600, 700, 800, 900]],
      ...     columns=["A", "B", "C", "D"],
      ...     index=[2, 3, 4],
      ... )
      >>> df.execute()
         D  B  E  A
      1  1  2  3  4
      2  6  7  8  9
      >>> other.execute()
          A    B    C    D
      2   10   20   30   40
      3   60   70   80   90
      4  600  700  800  900
  
      Align on columns:
  
      >>> left, right = df.align(other, join="outer", axis=1)
      >>> left.execute()
         A  B   C  D  E
      1  4  2 NaN  1  3
      2  9  7 NaN  6  8
      >>> right.execute()
          A    B    C    D   E
      2   10   20   30   40 NaN
      3   60   70   80   90 NaN
      4  600  700  800  900 NaN
  
      We can also align on the index:
  
      >>> left, right = df.align(other, join="outer", axis=0)
      >>> left.execute()
          D    B    E    A
      1  1.0  2.0  3.0  4.0
      2  6.0  7.0  8.0  9.0
      3  NaN  NaN  NaN  NaN
      4  NaN  NaN  NaN  NaN
      >>> right.execute()
          A      B      C      D
      1    NaN    NaN    NaN    NaN
      2   10.0   20.0   30.0   40.0
      3   60.0   70.0   80.0   90.0
      4  600.0  700.0  800.0  900.0
  
      Finally, the default `axis=None` will align on both index and columns:
  
      >>> left, right = df.align(other, join="outer", axis=None)
      >>> left.execute()
           A    B   C    D    E
      1  4.0  2.0 NaN  1.0  3.0
      2  9.0  7.0 NaN  6.0  8.0
      3  NaN  NaN NaN  NaN  NaN
      4  NaN  NaN NaN  NaN  NaN
      >>> right.execute()
             A      B      C      D   E
      1    NaN    NaN    NaN    NaN NaN
      2   10.0   20.0   30.0   40.0 NaN
      3   60.0   70.0   80.0   90.0 NaN
      4  600.0  700.0  800.0  900.0 NaN
      """
      axis = validate_axis(axis) if axis is not None else None
      fill_axis = (
          validate_axis(fill_axis) if fill_axis is not None else None
      )
      broadcast_axis = (
          validate_axis(broadcast_axis)
          if broadcast_axis is not None
          else None
      )
  
      if level is not None:
          raise NotImplementedError(f"Argument `level` not supported")
      if df.ndim != other.ndim and axis is None:
          raise ValueError("Must specify axis=0 or 1")
  
      op = DataFrameAlign(
          join=join,
          axis=axis,
          level=level,
          copy=copy,
          fill_value=fill_value,
          method=method,
          limit=limit,
          fill_axis=fill_axis,
          broadcast_axis=broadcast_axis,
      )
      return op(df, other)
  
imports: from typing import Any, Optional, Union
  import numpy
  from ...None import opcodes
  from ...core import get_output_types, recursive_tile, OutputType
  from ...serialization.serializables import AnyField, KeyField, StringField, Int16Field, Int64Field
  from ...typing import TileableType
  from ..operands import DataFrameOperand, DataFrameOperandMixin
  from ..align import align_dataframe_dataframe, align_dataframe_series, align_series_series
  from ..core import IndexValue
  from ..utils import validate_axis, parse_index, build_empty_df
label_desc: Use image node_id 1 for calling a global function with example usage: align(df, other, join, axis, level, copy, fill_value, method, limit, fill_axis, broadcast_axis) and returns: op