teradataml 17.20.0.7__py3-none-any.whl → 20.0.0.1__py3-none-any.whl

teradataml/plot/axis.py

@@ -1,1388 +1,1388 @@
-# ##################################################################
-#
-# Copyright 2023 Teradata. All rights reserved.
-# TERADATA CONFIDENTIAL AND TRADE SECRET
-#
-# Primary Owner: Pradeep Garre (pradeep.garre@teradata.com)
-# Secondary Owner:
-#
-# This file implements Axis, which is used for plotting. Axis holds all
-# the properties related to axis such as grid color, x-axis label, y-axis
-# label etc.
-#
-# ##################################################################
-
-from teradataml.common.exceptions import TeradataMlException
-from teradataml.common.messages import Messages
-from teradataml.common.messagecodes import MessageCodes
-from teradataml.common.utils import UtilFuncs
-from teradataml.dataframe.sql import ColumnExpression
-from teradataml.plot.constants import MapType
-from teradataml.utils.validators import _Validators
-
-class Axis:
-    def __init__(self, **kwargs):
-        """
-        Constructor for Axis.
-
-        PARAMETERS:
-            cmap:
-                Optional Argument.
-                Specifies the name of the colormap to be used for plotting.
-                Notes:
-                     * Significant only when corresponding type of plots is mesh or geometry.
-                     * Ignored for other type of plots.
-                Permitted Values:
-                    * All the colormaps mentioned in below URL's are supported.
-                        * https://matplotlib.org/stable/tutorials/colors/colormaps.html
-                        * https://matplotlib.org/cmocean/
-                Types: str
-
-            color:
-                Optional Argument.
-                Specifies the color for the plot.
-                Note:
-                    Hexadecimal color codes are not supported.
-                Permitted Values:
-                    * blue
-                    * orange
-                    * green
-                    * red
-                    * purple
-                    * brown
-                    * pink
-                    * gray
-                    * olive
-                    * cyan
-                    * Apart from above mentioned colors, the colors mentioned in
-                      https://xkcd.com/color/rgb are also supported.
-                Default Value: blue
-                Types: str OR list of str
-
-            grid_color:
-                Optional Argument.
-                Specifies the color of the grid. By default, grid is generated with
-                Gray69(#b0b0b0) color.
-                Note:
-                    Hexadecimal color codes are not supported.
-                Permitted Values:
-                    * 'blue'
-                    * 'orange'
-                    * 'green'
-                    * 'red'
-                    * 'purple'
-                    * 'brown'
-                    * 'pink'
-                    * 'gray'
-                    * 'olive'
-                    * 'cyan'
-                    * Apart from above mentioned colors, the colors mentioned in
-                      https://xkcd.com/color/rgb are also supported.
-                Default Value: 'gray'
-                Types: str
-
-            grid_format:
-                Optional Argument.
-                Specifies the format for the grid.
-                Types: str
-
-            grid_linestyle:
-                Optional Argument.
-                Specifies the line style of the grid.
-                Default Value: -
-                Permitted Values:
-                    * -
-                    * --
-                    * -.
-                Types: str
-
-            grid_linewidth:
-                Optional Argument.
-                Specifies the line width of the grid.
-                Note:
-                    Valid range for "grid_linewidth" is: 0.5 <= grid_linewidth <= 10.
-                Default Value: 0.8
-                Types: int OR float
-
-            legend:
-                Optional Argument.
-                Specifies the legend(s) for the Plot.
-                Types: str OR list of str
-
-            legend_style:
-                Optional Argument.
-                Specifies the location for legend to display on Plot image. By default,
-                legend is displayed at upper right corner.
-                    * 'upper right'
-                    * 'upper left'
-                    * 'lower right'
-                    * 'lower left'
-                    * 'right'
-                    * 'center left'
-                    * 'center right'
-                    * 'lower center'
-                    * 'upper center'
-                    * 'center'
-                Default Value: 'upper right'
-                Types: str
-
-            linestyle:
-                Optional Argument.
-                Specifies the line style for the plot.
-                Permitted Values:
-                    * -
-                    * --
-                    * -.
-                    * :
-                Default Value: -
-                Types: str OR list of str
-
-            linewidth:
-                Optional Argument.
-                Specifies the line width for the plot.
-                Note:
-                    Valid range for "linewidth" is: 0.5 <= linewidth <= 10.
-                Default Value: 0.8
-                Types: int OR float OR list of int OR list of float
-
-            marker:
-                Optional Argument.
-                Specifies the type of the marker to be used.
-                Permitted Values:
-                    All the markers mentioned in https://matplotlib.org/stable/api/markers_api.html
-                    are supported.
-                Types: str OR list of str
-
-            markersize:
-                Optional Argument.
-                Specifies the size of the marker.
-                Note:
-                    Valid range for "markersize" is: 1 <= markersize <= 20.
-                Default Value: 6
-                Types: int OR float OR list of int OR list of float
-
-            position:
-                Optional Argument.
-                Specifies the position of the axis in the Figure. 1st element
-                represents the row and second element represents column.
-                Default Value: (1, 1)
-                Types: tuple
-
-            reverse_xaxis:
-                Optional Argument.
-                Specifies whether to reverse tick values on x-axis or not.
-                Default Value: False
-                Types: bool
-
-            reverse_yaxis:
-                Optional Argument.
-                Specifies whether to reverse tick values on y-axis or not.
-                Default Value: False
-                Types: bool
-
-            span:
-                Optional Argument.
-                Specifies the span of the axis in the Figure. 1st element
-                represents the row and second element represents column.
-                For Example,
-                    Span of (2, 1) specifies the Axis occupies 2 rows and 1 column
-                    in Figure.
-                Default Value: (1, 1)
-                Types: tuple
-
-            series_identifier:
-                Optional Argument.
-                Specifies the teradataml GeoDataFrame Column which represents the
-                identifier for the data. As many plots as distinct "series_identifier"
-                are generated in a single Axis.
-                For example:
-                    consider the below data in teradataml GeoDataFrame.
-                           ID   x   y
-                        0  1    1   1
-                        1  1    2   2
-                        2  2   10  10
-                        3  2   20  20
-                    If "series_identifier" is not specified, simple plot is
-                    generated where every 'y' is plotted against 'x' in a
-                    single plot. However, specifying "series_identifier" as 'ID'
-                    generates two plots in a single axis. One plot is for ID 1
-                    and another plot is for ID 2.
-                Types: teradataml GeoDataFrame Column.
-
-            title:
-                Optional Argument.
-                Specifies the title for the Axis.
-                Types: str
-
-            xlabel:
-                Optional Argument.
-                Specifies the label for x-axis.
-                Notes:
-                     * When set to empty string, label is not displayed for x-axis.
-                     * When set to None, name of the x-axis column is displayed as
-                       label.
-                Types: str
-
-            xlim:
-                Optional Argument.
-                Specifies the range for xtick values.
-                Types: tuple
-
-            xtick_format:
-                Optional Argument.
-                Specifies how to format tick values for x-axis.
-                Types: str
-
-            ylabel:
-                Optional Argument.
-                Specifies the label for y-axis.
-                Notes:
-                     * When set to empty string, label is not displayed for y-axis.
-                     * When set to None, name of the y-axis column(s) is displayed as
-                       label.
-                Types: str
-
-            ylim:
-                Optional Argument.
-                Specifies the range for ytick values.
-                Types: tuple
-
-            ytick_format:
-                Optional Argument.
-                Specifies how to format tick values for y-axis.
-                Types: str
-
-            vmin:
-                Optional Argument.
-                Specifies the lower range of the color map. By default, the range
-                is derived from data and color codes are assigned accordingly.
-                Note:
-                    "vmin" significant only for Mesh and Geometry Plot.
-                Types: int OR float
-
-            vmax:
-                Optional Argument.
-                Specifies the upper range of the color map. By default, the range is
-                derived from data and color codes are assigned accordingly.
-                Note:
-                    "vmax" significant only for Mesh and Geometry Plot.
-                For example:
-                    Assuming user wants to use colormap 'matter' and derive the colors for
-                    values which are in between 1 and 100.
-                    Note:
-                        Colormap 'matter' starts with Pale Yellow and ends with Violet.
-                    * If "colormap_range" is not specified, then range is derived from
-                      existing values. Thus, colors are represented as below in the whole range:
-                      * 1 as Pale Yellow.
-                      * 100 as Violet.
-                    * If "colormap_range" is specified as -100 and 100, the value 1 is at middle of
-                      the specified range. Thus, colors are represented as below in the whole range:
-                      * -100 as Pale Yellow.
-                      * 1 as Orange.
-                      * 100 as Violet.
-                Types: int OR float
-
-        EXAMPLES:
-            # Example 1: Create an Axis with marker as 'Pentagon'.
-            >>> from teradataml import Axis
-            >>> ax = Axis(marker="p")
-
-            # Example 2: Create an Axis which does not have x-tick values
-            #            and y-tick values but it should have grid.
-            #            Note that the grid lines should be in the format of '-.'
-            >>> from teradataml import Axis
-            >>> ax = Axis(xtick_format="", ytick_format="", grid_linestyle="-.")
-
-            # Example 3: Create an Axis which should plot only for the values
-            #            between -10 to 100 on x-axis.
-            >>> from teradataml import Axis
-            >>> ax = Axis(xlim=(-10, 100))
-
-            # Example 4: Create an Axis which should display legend at upper left
-            #            corner and it should disable both x and y axis labels.
-            >>> from teradataml import Axis
-            >>> ax = Axis(legend_style="upper left", xlabel="", ylabel="")
-
-            # Example 5: Create an Axis to format the y-axis tick values to
-            #            display up to two decimal points. Also, use the color
-            #            'dark green' for plotting.
-            #            Note: Consider y-axis data has 5 digit floating numbers.
-            >>> from teradataml import Axis
-            >>> ax = Axis(ytick_format="99999.99", color='dark green')
-
-        RAISES:
-            TeradataMlException
-        """
-        self.__params = {**kwargs}
-
-        self.__x_axis_data = []
-        self.__y_axis_data = []
-        self.__scale_data = []
-
-        arg_info_matrix = []
-
-        # Retrieve arg value from corresponding property.
-        arg_info_matrix.append((["ignore_nulls", self.ignore_nulls, True, bool]))
-
-        arg_info_matrix.append((["cmap", self.cmap, True, (str), True]))
-
-        arg_info_matrix.append((["grid_color", self.grid_color, True, (str), True]))
-
-        arg_info_matrix.append((["grid_format", self.grid_format, True, (str), True]))
-
-        arg_info_matrix.append((["grid_linestyle", self.grid_linestyle, True, (str),
-                                 True, ['-', '--', '-.']]))
-
-        arg_info_matrix.append((["grid_linewidth", self.grid_linewidth, True, (int, float)]))
-
-        arg_info_matrix.append((["legend", self.legend, True, (str, list), True]))
-
-        permitted_legend_style = ['upper right', 'upper left', 'lower right',
-                                  'lower left', 'right', 'center left',
-                                  'center right', 'lower center',
-                                  'upper center', 'center']
-        arg_info_matrix.append((["legend_style", self.legend_style, True,
-                                 (str), True, permitted_legend_style]))
-
-        arg_info_matrix.append((["linestyle", self.linestyle, True, (str, list),
-                                 True, ['-', '--', '-.', ':']]))
-
-        arg_info_matrix.append((["linewidth", self.linewidth, True, (int, float, list), True]))
-
-        arg_info_matrix.append((["marker", self.marker, True, (str, list), True]))
-
-        arg_info_matrix.append((["markersize", self.markersize, True, (int, float, list)]))
-
-        arg_info_matrix.append((["position", self.position, True, (tuple)]))
-
-        arg_info_matrix.append((["span", self.span, True, (tuple)]))
-
-        arg_info_matrix.append((["reverse_xaxis", self.reverse_xaxis, True, (bool)]))
-
-        arg_info_matrix.append((["reverse_yaxis", self.reverse_yaxis, True, (bool)]))
-
-        series_identifier = kwargs.get("series_identifier")
-        arg_info_matrix.append((["series_identifier", series_identifier, True,
-                                 (ColumnExpression)]))
-
-        arg_info_matrix.append((["color", self.color, True, (str, list), True]))
-
-        arg_info_matrix.append((["title", self.title, True, (str), True]))
-
-        arg_info_matrix.append((["xlabel", self.xlabel, True, (str), False]))
-
-        arg_info_matrix.append((["ylabel", self.ylabel, True, (str), False]))
-
-        arg_info_matrix.append((["xlim", self.xlim, True, (tuple)]))
-
-        arg_info_matrix.append((["ylim", self.ylim, True, (tuple)]))
-
-        arg_info_matrix.append((["xtick_format", self.xtick_format, True, (str)]))
-
-        arg_info_matrix.append((["ytick_format", self.ytick_format, True, (str)]))
-
-        arg_info_matrix.append((["vmin", self.vmin, True, (int, float)]))
-        arg_info_matrix.append((["vmax", self.vmax, True, (int, float)]))
-
-        # 'vmin' and 'vmax' is applicable only for Mesh and Geometry plot.
-        if self.kind.lower() not in ['geometry', 'mesh']:
-            if self.vmin is not None:
-                _Validators._validate_dependent_argument("vmin", self.vmin,
-                                                         "kind", None, "'geometry' or 'mesh'")
-            if self.vmax is not None:
-                _Validators._validate_dependent_argument("vmax", self.vmax,
-                                                        "kind", None, "'geometry' or 'mesh'")
-
-        # Argument validations.
-        # Skip empty check for 'xlabel', 'ylabel'.
-        _Validators._validate_function_arguments(
-            arg_info_matrix,
-            skip_empty_check={"xlabel": [''], "ylabel": ['']}
-        )
-
-        # Argument range check.
-        _Validators._validate_argument_range(self.grid_linewidth, "grid_linewidth",
-                                             0.5, lbound_inclusive=True,
-                                             ubound=10, ubound_inclusive=True)
-        # Convert linewidth to list
-        linewidth = UtilFuncs._as_list(self.linewidth)
-        [_Validators._validate_argument_range(lw, "linewidth",
-                                              0.5, lbound_inclusive=True,
-                                              ubound=10, ubound_inclusive=True)
-         for lw in linewidth]
-
-        # Convert markersize to list
-        markersize = UtilFuncs._as_list(self.markersize)
-        [_Validators._validate_argument_range(ms, "markersize",
-                                              1, lbound_inclusive=True,
-                                              ubound=20, ubound_inclusive=True)
-         for ms in markersize]
-
-        self.__series_options = kwargs.get("series_options")  # Specifies SQL element - ID_SEQUENCE
-
-        # Get the series identifier. If it is a column expression, get the column name from it.
-        self.__series_identifier = kwargs.get("series_identifier")
-        if not isinstance(self.__series_identifier, str) and self.__series_identifier is not None:
-            self.__series_identifier = self.__series_identifier.name
-
-    def __get_param(self, param):
-        """
-        DESCRIPTION:
-            Internal function to get the parameter from private variable __params.
-
-        PARAMETERS:
-            param:
-                Required Argument.
-                Specifies the name of the parameter.
-                Types: str
-
-        RETURNS:
-            str OR int OR float OR list
-
-        RAISES:
-            None.
-
-        EXAMPLES:
-            self.__get_param("xlim")
-        """
-        return self.__params.get(param)
-
-    def __set_param(self, param_name, param_value):
-        """
-        DESCRIPTION:
-            Internal function to set the parameter.
-
-        PARAMETERS:
-            param_name:
-                Required Argument.
-                Specifies the name of the parameter.
-                Types: str
-
-            param_value:
-                Required Argument.
-                Specifies the value for the parameter mentioned in "param_name".
-                Types: str OR int OR float OR list
-
-        RETURNS:
-            bool
-
-        RAISES:
-            None.
-
-        EXAMPLES:
-            self.__set_param("xlim", (1, 100))
-        """
-        self.__params[param_name] = param_value
-        return True
-
-    @property
-    def ignore_nulls(self):
-        """ Getter for argument "ignore_nulls". """
-        return self.__get_param("ignore_nulls")
-
-    @ignore_nulls.setter
-    def ignore_nulls(self, value):
-        """ Setter for argument "ignore_nulls". """
-        return self.__set_param("ignore_nulls", value)
-
-    @property
-    def cmap(self):
-        """ Getter for argument "cmap". """
-        return self.__get_param("cmap")
-
-    @cmap.setter
-    def cmap(self, value):
-        """ Setter for argument "cmap". """
-        return self.__set_param("cmap", value)
-
-    @property
-    def vmin(self):
-        """ Getter for argument "vmin". """
-        return self.__get_param("vmin")
-
-    @vmin.setter
-    def vmin(self, value):
-        """ Setter for argument "vmin". """
-        return self.__set_param("vmin", value)
-
-    @property
-    def vmax(self):
-        """ Getter for argument "vmax". """
-        return self.__get_param("vmax")
-
-    @vmax.setter
-    def vmax(self, value):
-        """ Setter for argument "vmax". """
-        return self.__set_param("vmax", value)
-
-    @property
-    def grid_color(self):
-        """ Getter for argument "grid_color". """
-        return self.__get_param("grid_color")
-
-    @grid_color.setter
-    def grid_color(self, value):
-        """ Setter for argument "grid_color". """
-        return self.__set_param("grid_color", value)
-
-    @property
-    def grid_format(self):
-        """ Getter for argument "grid_format". """
-        return self.__get_param("grid_format")
-
-    @grid_format.setter
-    def grid_format(self, value):
-        """ Setter for argument "grid_format". """
-        return self.__set_param("grid_format", value)
-
-    @property
-    def grid_linestyle(self):
-        """ Getter for argument "grid_linestyle". """
-        return self.__get_param("grid_linestyle")
-
-    @grid_linestyle.setter
-    def grid_linestyle(self, value):
-        """ Setter for argument "grid_linestyle". """
-        return self.__set_param("grid_linestyle", value)
-
-    @property
-    def grid_linewidth(self):
-        """ Getter for argument "grid_linewidth". """
-        return self.__get_param("grid_linewidth")
-
-    @grid_linewidth.setter
-    def grid_linewidth(self, value):
-        """ Setter for argument "grid_linewidth". """
-        return self.__set_param("grid_linewidth", value)
-
-    @property
-    def legend(self):
-        """ Getter for argument "legend". """
-        return self.__get_param("legend")
-
-    @legend.setter
-    def legend(self, value):
-        """ Setter for argument "legend". """
-        return self.__set_param("legend", value)
-
-    @property
-    def legend_style(self):
-        """ Getter for argument "legend_style". """
-        return self.__get_param("legend_style")
-
-    @legend_style.setter
-    def legend_style(self, value):
-        """ Setter for argument "legend_style". """
-        return self.__set_param("legend_style", value)
-
-    @property
-    def linestyle(self):
-        """ Getter for argument "linestyle". """
-        return self.__get_param("linestyle")
-
-    @linestyle.setter
-    def linestyle(self, value):
-        """ Setter for argument "linestyle". """
-        return self.__set_param("linestyle", value)
-
-    @property
-    def linewidth(self):
-        """ Getter for argument "linewidth". """
-        return self.__get_param("linewidth")
-
-    @linewidth.setter
-    def linewidth(self, value):
-        """ Setter for argument "linewidth". """
-        return self.__set_param("linewidth", value)
-
-    @property
-    def marker(self):
-        """ Getter for argument "marker". """
-        return self.__get_param("marker")
-
-    @marker.setter
-    def marker(self, value):
-        """ Setter for argument "marker". """
-        return self.__set_param("marker", value)
-
-    @property
-    def markersize(self):
-        """ Getter for argument "markersize". """
-        return self.__get_param("markersize")
-
-    @markersize.setter
-    def markersize(self, value):
-        """ Setter for argument "markersize". """
-        return self.__set_param("markersize", value)
-
-    @property
-    def reverse_xaxis(self):
-        """ Getter for argument "reverse_xaxis". """
-        return self.__get_param("reverse_xaxis")
-
-    @reverse_xaxis.setter
-    def reverse_xaxis(self, value):
-        """ Setter for argument "reverse_xaxis". """
-        return self.__set_param("reverse_xaxis", value)
-
-    @property
-    def reverse_yaxis(self):
-        """ Getter for argument "reverse_yaxis". """
-        return self.__get_param("reverse_yaxis")
-
-    @reverse_yaxis.setter
-    def reverse_yaxis(self, value):
-        """ Setter for argument "reverse_yaxis". """
-        return self.__set_param("reverse_yaxis", value)
-
-    @property
-    def color(self):
-        """ Getter for argument "color". """
-        return self.__get_param("color")
-
-    @color.setter
-    def color(self, value):
-        """ Setter for argument "color". """
-        return self.__set_param("color", value)
-
-    @property
-    def xlabel(self):
-        """ Getter for argument "xlabel". """
-        return self.__get_param("xlabel")
-
-    @xlabel.setter
-    def xlabel(self, value):
-        """ Setter for argument "xlabel". """
-        return self.__set_param("xlabel", value)
-
-    @property
-    def xlim(self):
-        """ Getter for argument "xlim". """
-        return self.__get_param("xlim")
-
-    @xlim.setter
-    def xlim(self, value):
-        """ Setter for argument "xlim". """
-        return self.__set_param("xlim", value)
-
-    @property
-    def xtick_format(self):
-        """ Getter for argument "xtick_format". """
-        return self.__get_param("xtick_format")
-
-    @xtick_format.setter
-    def xtick_format(self, value):
-        """ Setter for argument "xtick_format". """
-        return self.__set_param("xtick_format", value)
-
-    @property
-    def ylabel(self):
-        """ Getter for argument "ylabel". """
-        return self.__get_param("ylabel")
-
-    @ylabel.setter
-    def ylabel(self, value):
-        """ Setter for argument "ylabel". """
-        return self.__set_param("ylabel", value)
-
-    @property
-    def ylim(self):
-        """ Getter for argument "ylim". """
-        return self.__get_param("ylim")
-
-    @ylim.setter
-    def ylim(self, value):
-        """ Setter for argument "ylim". """
-        return self.__set_param("ylim", value)
-
-    @property
-    def ytick_format(self):
-        """ Getter for argument "ytick_format". """
-        return self.__get_param("ytick_format")
-
-    @ytick_format.setter
-    def ytick_format(self, value):
-        """ Setter for argument "ytick_format". """
-        return self.__set_param("ytick_format", value)
-
-    @property
-    def title(self):
-        """ Getter for argument "title". """
-        return self.__get_param("title")
-
-    @title.setter
-    def title(self, value):
-        """ Setter for argument "title". """
-        return self.__set_param("title", value)
-
-    @property
-    def kind(self):
-        """ Getter for argument "kind". """
-        _k = self.__get_param("kind")
-        return _k if _k is not None else "line"
-
-    @kind.setter
-    def kind(self, value):
-        """ Setter for argument "kind". """
-        return self.__set_param("kind", value)
-
-    @property
-    def position(self):
-        """ Getter for argument "position". """
-        _p = self.__get_param("position")
-        return (1, 1) if _p is None else _p
-
-    @position.setter
-    def position(self, value):
-        """ Setter for argument "position". """
-        return self.__set_param("position", value)
-
-    @property
-    def span(self):
-        """ Getter for argument "span". """
-        _s = self.__get_param("span")
-        return (1, 1) if _s is None else _s
-
-    @span.setter
-    def span(self, value):
-        """ Setter for argument "span". """
-        return self.__set_param("span", value)
-
-    def set_params(self, **kwargs):
-        """
-        DESCRIPTION:
-            Function to set the parameters for Axis object.
-
-        PARAMETERS:
-            **kwargs:
-                Keyword arguments passed to the method, i.e., set_params.
-                All the arguments supported for Axis object are supported here.
-                Refer to 'Axis' documentation for arguments supported by it.
-
-        RETURNS:
-             True, if successful.
-
-        EXAMPLES:
-            # Create a default Axis object.
-            >>> from teradataml import Axis
-            >>> ax = Axis()
-
-            # Example 1: Disable x-axis label for an existing Axis object.
-            >>> ax.set_params(xlabel="")
-
-            # Example 2: Set the title for an existing Axis object. Also, disable
-            #            x-tick values.
-            >>> ax.set_params(title="Title", xtick_values="")
-        """
-        self.__params.update(kwargs)
-        return True
-
-    def _set_data(self, x, y, scale=None):
-        """
-        DESCRIPTION:
-            Internal function to set the x-axis and y-axis data to Axis object.
-
-        PARAMETERS:
-            x:
-                Required Argument.
-                Specifies the x-axis data.
-                Types: teradataml DataFrame Column
-
-            y:
-                Required Argument.
-                Specifies the y-axis data.
-                Types: teradataml DataFrame Column OR list of teradataml DataFrame Column.
-
-            scale:
-                Optional Argument.
-                Specifies the scale data which is required for wiggle and mesh plots.
-                Note:
-                    "scale" is significant for wiggle and mesh plots. Ignored for other
-                    type of plots.
-                Types: teradataml DataFrame Column OR list of teradataml DataFrame Column.
-
-        EXAMPLES:
-            >>> ax = Axis()
-            >>> ax._set_data(df.col1, [df.col2, df.col3])
-        """
-        # Before setting the data, clear it first.
-        self.__clear_axis_data()
-
-        y = UtilFuncs._as_list(y)
-
-        # Make sure number of columns mentioned in x-axis is
-        # same as number of columns mentioned in y-axis.
-        x = UtilFuncs._as_list(x)
-        if len(x) != len(y):
-            x = x * len(y)
-
-        scale = UtilFuncs._as_list(scale)
-
-        self.__x_axis_data.extend(x)
-        self.__y_axis_data.extend(y)
-        self.__scale_data.extend(scale)
-
-    def __clear_axis_data(self):
-        """
-        DESCRIPTION:
-            Internal function to clear the axis data.
-
-        RETURNS:
-            bool
-
-        EXAMPLES:
-            >>> ax = Axis()
-            >>> ax._Axis__clear_axis_data()
-        """
-        self.__x_axis_data.clear()
-        self.__y_axis_data.clear()
-        self.__scale_data.clear()
-
-        return True
-
-    def _has_data(self):
-        """
-        DESCRIPTION:
-            Internal function to check whether axis is associated with data or not.
-
-        RETURNS:
-            bool
-
-        EXAMPLES:
-            >>> ax = Axis()
-            >>> ax._has_data()
-        """
-        return bool(self.__x_axis_data)
-
-    def __repr__(self):
-        """
-        DESCRIPTION:
-            String representation of Axis Object.
-
-        RETURNS:
-            str.
-
-        RAISES:
-            None.
-
-        EXAMPLES:
-            # Create an Axis Object.
-            >>> from teradataml import Axis
-            >>> axis = Axis()
-            >>> print(axis)
-        """
-        return "{}(position={}, span={})".format(self.__class__.__name__, self.position, self.span)
-
-    def _get_plot_data(self):
-        """
-        DESCRIPTION:
-            Internal function to get the plot data. The function, which is called from Plot object
-            gets all the corresponding information to generate the plot.
-
-        RETURNS:
-            tuple, with 3 elements.
-                * element 1 represents again a tuple - 2nd element represents a SELECT statement
-                  and 1st element represents a string which is the alias table name of SELECT
-                  statement. It is necessary to get the alias table name also as series spec
-                  references alias table names.
-                * element 2 represents either a series spec or matrix spec in string format.
-                * element 3 represents a dictionary with all the parameters for Plot.
-
-        RAISES:
-            None.
-
-        EXAMPLES:
-            >>> from teradataml import Axis
-            >>> axis = Axis()
-            >>> axis._get_plot_data()
-        """
-
-        # TODO: Run only once and store this information. Also, df.concat is a costly operation.
-        #  Will be implemented with ELE-5803.
-        _virtual_table, _spec = self.__get_matrix_spec() if self.kind in (MapType.MESH.value, MapType.WIGGLE.value) \
-            else self.__get_series_spec()
-
-        return (_virtual_table, _spec, self._get_params())
-
-    def __get_series_spec(self):
-        """
-        DESCRIPTION:
-            Internal function to generate TDSeries Spec.
-            * If user pass 'series_id' by using the argument "series_identifier", then consider 'series_id'
-              as "series_identifier", x-axis data for 'row_axis' and y-axis data for 'payload_field' in
-              TDSeries object. Both, 'row_index_style' and 'payload_content' can be derived
-              programatically using __get_index_style() and __get_payload_content() respectively.
-            * If user do not pass 'series_id', then the function constructs the series spec as below:
-              * walk through x-axis and y-axis data.
-              * Construct a new teradataml DataFrame by generating a new column for ID field
-                along with x and y axis columns.
-                * ID Column value can be either str or float or int. Since the column will be
-                  used as legend if user do not specify the legend, make sure ID Column value
-                  is Y-Axis column name. This makes a very good user experience in Composite plots.
-                * For geometry and corr plot, y axis can be a tuple. In such cases, make sure to generate
-                  the ID Column Value with all the columns mentioned in tuple.
-                  * Note that, if it is tuple, Columns mentioned in tuple can have same name. Make
-                    sure to generate the ID Column value as a unique value.
-                * With the above information, i.e, ID Column, x-axis data and y-axis data, construct a
-                  new teradataml DataFrame.
-              * Repeat the above process if user pass multiple ColumnExpression(s) for y-axis data and
-                concatenate the generated DataFrame with previously generated DataFrame vertically.
-
-        RAISES:
-            TeradatamlException - If all the ColumnExpression(s) mentioned in y-axis are of not same type.
-
-        RETURNS:
-            tuple
-
-        EXAMPLES:
-            >>> from teradataml import Axis
-            >>> Axis()._Axis__get_series_spec()
-        """
-        from teradataml.dataframe.dataframe import TDSeries
-
-        if self.__series_identifier:
-            # Remove null values from DataFrame
-            if self.ignore_nulls:
-                _df = self.__x_axis_data[0]._parent_df
-                _subset = [column_name.name for column_name in self.__y_axis_data]
-                _subset.append(self.__x_axis_data[0].name)
-                _df = _df.dropna(how='any', subset=_subset)
-
-            # Execute the node and create the table in Vantage.
-            if self.__y_axis_data[0]._parent_df._table_name is None:
-                # Assuming all the columns are from same DataFrame.
-                repr(self.__y_axis_data[0]._parent_df)
-
-            series = TDSeries(data=_df if self.ignore_nulls else self.__x_axis_data[0]._parent_df,
-                              id=self.__series_identifier,
-                              row_index=self.__x_axis_data[0].name,
-                              row_index_style=self.__get_index_style(self.__x_axis_data[0]),
-                              payload_field=self.__y_axis_data[0].name,
-                              payload_content=self.__get_payload_content(self.__y_axis_data[0]))
-            return "", series._get_sql_repr(True)
-
-        # Since user does not pass series identifier, convert the data in to TDSeries spec.
-        _index = 1
-        _previous_df = None
-
-        # Loop through every element and concatenate the dataframes vertically, i.e.,
-        # using UNION ALL clause.
-        for index, (_x, _y) in enumerate(zip(self.__x_axis_data, self.__y_axis_data)):
-            _df = _y._parent_df if not isinstance(_y, tuple) else _y[0]._parent_df
-            # For correlated and geometry graph, user can pass two params for PAYLOAD FIELD.
-            if isinstance(_y, tuple):
-                # Generate the id_column name programatically. This appears at legend
-                # if legend is shown. So, build it meaningfully.
-                _id_column = "{}_{}_{}".format(_y[0].compile(), _y[1].compile(), _index)
-                columns = {"y_identifier":UtilFuncs._replace_special_chars(_id_column), "id":index, "x":_x, "y1":_y[0], "y2":_y[1]}
-                payload_field = ["y1", "y2"]
-            else:
-                columns = {"y_identifier":UtilFuncs._replace_special_chars(_y.compile()), "id":index, "x":_x, "y":_y}
-                payload_field = "y"
-
-            _df = _df.assign(**columns, drop_columns=True)
-            # Concatenate with previous DataFrame.
-            if _previous_df:
-                # TODO: Note that concat is a very costly operation. Infact, it is very very slow.
-                #  Consider generating VIRTUAL tables or UNPIVOT.
-                #  Will be addressed with ELE-5808.
-                _df = _previous_df.concat(_df)
-
-            _previous_df = _df
-            # Flatten the DataFrame.
-            _index = _index + 1
-        # Remove null values from DataFrame
-        if self.ignore_nulls:
-            _df = _df.dropna()
-        repr(_df)
-        series = TDSeries(data=_df,
-                          id="id",
-                          row_index="x",
-                          row_index_style=self.__get_index_style(_df.x),
-                          payload_field=payload_field,
-                          payload_content=self.__get_payload_content(self.__y_axis_data[0]))
-
-        # TODO: Should return a virtual table at first element if required.
-        #  Will be addressed with ELE-5808.
-        return "", series._get_sql_repr(True)
-
-    def __get_matrix_spec(self):
-        """
-        DESCRIPTION:
-            Internal function to generate TDMatrix Spec.
-            * If user pass 'matrix_id' by using the argument "series_identifier", then consider 'matrix_id'
-              as "series_identifier", x-axis data for 'row_axis' and y-axis data for 'column_axis' and
-              scale data for 'payload_field' in TDMatrix object. Both, 'row_index_style' and 'payload_content'
-              can be derived programatically using __get_index_style() and __get_payload_content()
-              respectively.
-            * If user do not pass 'matrix_id', then the function constructs the matrix spec as below:
-              * walk through x-axis, y-axis and scale data.
-              * Construct a new teradataml DataFrame by generating a new column for ID field
-                * ID Column value can be either str or float or int. Since the column will be
-                  used as legend if user do not specify the legend, make sure ID Column value
-                  is Y-Axis column name. This makes a very good user experience in Composite plots.
-                * With the above information, i.e, ID Column, x-axis data, y-axis data and scale data,
-                  construct a new teradataml DataFrame.
-              * Repeat the above process if user pass multiple ColumnExpression(s) for y-axis data and
-                concatenate the generated DataFrame with previously generated DataFrame vertically.
-
-        RAISES:
-            TeradatamlException - If all the ColumnExpression(s) mentioned in y-axis are of not same type.
-
-        RETURNS:
-            tuple
-
-        EXAMPLES:
-            >>> from teradataml import Axis
-            >>> Axis()._Axis__get_matrix_spec()
-        """
-        from teradataml.dataframe.dataframe import TDMatrix
-
-        if self.__series_identifier:
-            # Remove null values from DataFrame
-            if self.ignore_nulls:
-                _df = self.__x_axis_data[0]._parent_df
-                _subset = [column_name.name for column_name in self.__y_axis_data]
-                _subset.append(self.__x_axis_data[0].name)
-                _subset.extend(column_name.name for column_name in self.__scale_data)
-                _df = _df.dropna(how='any', subset=_subset)
-
-            # Execute the node and create the table/view in Vantage.
-            if self.__y_axis_data[0]._parent_df._table_name is None:
-                repr(self.__y_axis_data[0]._parent_df)
-
-            matrix = TDMatrix(data=_df if self.ignore_nulls else self.__x_axis_data[0]._parent_df,
-                              id=self.__series_identifier,
-                              row_index=self.__x_axis_data[0].name,
-                              row_index_style=self.__get_index_style(self.__x_axis_data[0]),
-                              column_index=self.__y_axis_data[0].name,
-                              column_index_style=self.__get_index_style(self.__y_axis_data[0]),
-                              payload_field=self.__scale_data[0].name,
-                              payload_content=self.__get_payload_content(self.__scale_data[0]))
-            return "", matrix._get_sql_repr(True)
-
-        # Since user do not pass matrix identifier, convert the data in to TDMatrix spec.
-        _previous_df = None
-        for index, (_x, _y, _data) in enumerate(zip(self.__x_axis_data, self.__y_axis_data, self.__scale_data)):
-            _df = _x._parent_df
-            columns = {"y_identifier": UtilFuncs._replace_special_chars(_y.compile()), "id":index, "x": _x, "y": _y, "data": _data}
-            _df = _df.assign(**columns, drop_columns=True)
-            if _previous_df:
-                # TODO: Note that concat is a very costly operation. Infact, it is very very slow.
-                #  Consider generating VIRTUAL tables or UNPIVOT.
-                #  Will be addressed with ELE-5808.
-                _df = _previous_df.concat(_df)
-
-            _previous_df = _df
-        # Remove null values from DataFrame
-        if self.ignore_nulls:
-            _df = _df.dropna()
-        repr(_df)
-        matrix = TDMatrix(data=_df,
-                          id="id",
-                          row_index="x",
-                          row_index_style=self.__get_index_style(_df.x),
-                          column_index="y",
-                          column_index_style=self.__get_index_style(_df.y),
-                          payload_field="data",
-                          payload_content="REAL")
-
-        # TODO: Should return a virtual table at first element if required.
-        #  Will be addressed with ELE-5808.
-        return "", matrix._get_sql_repr(True)
-
-    def __get_index_style(self, _x):
-        """
-        DESCRIPTION:
-            Internal function to generate the value for argument "row_index_style"
-            in TDSeries/TDMatrix objects.
-
-        PARAMETERS:
-            _x:
-               Required Argument.
-               Specifies the ColumnExpression of x-axis data.
-               Types: teradataml ColumnExpression.
-
-        RETURNS:
-            str
-
-        EXAMPLES:
-            >>> from teradataml import Axis
-            >>> Axis()._Axis__get_index_style()
-        """
-        if UtilFuncs._teradata_type_to_python_type(_x.type) in ('int', 'float', 'str'):
-            return "SEQUENCE"
-        return "TIMECODE"
-
-    def __get_payload_content(self, _y):
-        """
-        DESCRIPTION:
-            Internal function to generate the value for argument "payload_content"
-            in TDSeries/TDMatrix objects.
-
-        PARAMETERS:
-            _y:
-               Required Argument.
-               Specifies the ColumnExpression of y-axis data.
-               Note that y-axis can be a list of ColumnExpression(s) also.
-               Since all the Columns are concatenated vertically, every column
-               type should be same. So, deriving "payload_content" value for 1st
-               element is suffice.
-               Types: teradataml ColumnExpression.
-
-        RETURNS:
-            str
-
-        EXAMPLES:
-            >>> from teradataml import Axis
-            >>> Axis()._Axis__get_payload_content()
-        """
-        # If y-axis is a tuple, return MULTIVAR_ANYTYPE.
-        if self.kind == MapType.GEOMETRY.value:
-            return "MULTIVAR_ANYTYPE"
-
-        if self.kind == MapType.CORR.value:
-            return "MULTIVAR_REAL" if isinstance(_y, tuple) else "REAL"
-
-        return "REAL"
-
-    @staticmethod
-    def __get_color_code(color):
-        """
-        DESCRIPTION:
-            Internal function to get the string for a color which is recognised by TD_PLOT.
-
-        RETURNS:
-            str
-
-        EXAMPLES:
-            >>> from teradataml import Axis
-            >>> Axis()._Axis__get_color_code("orange")
-        """
-        default_colors = {'blue', 'orange', 'green', 'red', 'purple', 'brown', 'pink', 'gray', 'olive', 'cyan'}
-        return "tab:{}".format(color) if color in default_colors else "xkcd:{}".format(color)
-
-    def __get_series_parameters(self):
-        """
-        DESCRIPTION:
-            Internal function to generate the parameters for individual Series.
-
-        RETURNS:
-            list
-
-        EXAMPLES:
-            >>> from teradataml import Axis
-            >>> Axis()._Axis__get_series_parameters()
-        """
-        _series_params = []
-        for index in range(len(self.__y_axis_data)):
-            _series_param = {"ID": index+1}
-            color = self._get_series_param(self.color, index)
-            if color:
-                _series_param["COLOR"] = "'{}'".format(self.__get_color_code(color))
-
-            line_style = self._get_series_param(self.linestyle, index)
-            self.__update_plot_params(_series_param, "LINESTYLE", line_style)
-
-            line_width = self._get_series_param(self.linewidth, index)
-            self.__update_plot_params(_series_param, "LINEWIDTH", line_width)
-
-            marker = self._get_series_param(self.marker, index)
-            self.__update_plot_params(_series_param, "MARKER", marker)
-
-            marker_size = self._get_series_param(self.markersize, index)
-            self.__update_plot_params(_series_param, "MARKERSIZE", marker_size)
-
-            # If user pass legend name use it. Else, derive it from Y-Axis.
-            # Legend is not applicable for wiggle and mesh plots.
-            if self.kind not in (MapType.MESH.value, MapType.WIGGLE.value):
-                legend_name = self._get_series_param(self.legend, index)
-                if legend_name:
-                    _series_param["NAME"] = "'{}'".format(legend_name)
-                else:
-                    columns = self.__y_axis_data[index] if isinstance(self.__y_axis_data[index], tuple) else \
-                        [self.__y_axis_data[index]]
-                    columns = [UtilFuncs._replace_special_chars(col.compile()) for col in columns]
-                    _series_param["NAME"] = "'{}'".format(" / ".join(columns))
-
-            _series_params.append(_series_param)
-        return _series_params
-
-    def _get_params(self):
-        """
-        DESCRIPTION:
-            Internal function to generate the parameters for the plot.
-
-        RETURNS:
-            dict
-
-        EXAMPLES:
-            >>> from teradataml import Axis
-            >>> Axis()._Axis_get_params()
-        """
-        func_params = {"CELL": (self.position[1], self.position[0]),
-                       "SPAN": (self.span[1], self.span[0]),
-                       "TYPE": "'{}'".format(self.kind),
-                       "XLABEL": "'{}'".format(self.get_xaxis_label()),
-                       "YLABEL": "'{}'".format(self.get_yaxis_label()),
-                       "SERIES": self.__get_series_parameters()
-                       }
-
-        self.__update_plot_params(func_params, "TITLE", self.title)
-        self.__update_plot_params(func_params, "XFORMAT", self.xtick_format)
-        self.__update_plot_params(func_params, "YFORMAT", self.ytick_format)
-        self.__update_plot_params(func_params, "XRANGE", self.xlim)
-        self.__update_plot_params(func_params, "YRANGE", self.ylim)
-
-        if self.reverse_xaxis is True:
-            func_params["FLIPX"] = 1
-
-        if self.reverse_yaxis is True:
-            func_params["FLIPY"] = 1
-
-        # For subplot or multiple series, make sure to populate legend.
-        # For mainplot, leave it to user's choice.
-        if self._is_sub_plot() or self.__series_identifier or (len(self.__y_axis_data) > 1) and \
-                self.kind not in (MapType.MESH.value, MapType.WIGGLE.value):
-            func_params["LEGEND"] = "'{}'".format("best" if not self.legend_style else self.legend_style)
-        else:
-            self.__update_plot_params(func_params, "LEGEND", self.legend_style)
-
-        # Populate GRID parameters.
-        if self.grid_format or self.grid_color or self.grid_linestyle or self.grid_linewidth:
-            _grid_params = {}
-            self.__update_plot_params(_grid_params, "COLOR", self.__get_color_code(self.grid_color))
-            self.__update_plot_params(_grid_params, "FORMAT", self.grid_format)
-            self.__update_plot_params(_grid_params, "LINESTYLE", self.grid_linestyle)
-            self.__update_plot_params(_grid_params, "LINEWIDTH", self.grid_linewidth)
-            func_params["GRID"] = _grid_params
-
-        # Populate color map parameters.
-        if self.cmap or self.vmin:
-            # TODO: User should control the COLORBAR. Expose a parameter to user.
-            _color_map_params = {"COLORBAR": 1}
-            self.__update_plot_params(_color_map_params, "RANGE", None if self.vmin is None else (self.vmin, self.vmax))
-            self.__update_plot_params(_color_map_params, "NAME", self.cmap)
-            func_params["COLORMAP"] = _color_map_params
-
-        return func_params
-
-    @staticmethod
-    def __update_plot_params(func_params, plot_param, value):
-        """
-        DESCRIPTION:
-            Internal function to update the Plot parameter.
-            The function check whether "value" is None or not. If None,
-            no action from this function on "func_params". Else, "func_params"
-            is updated with "plot_param".
-
-        EXAMPLES:
-            >>> from teradataml import Axis
-            >>> Axis()._Axis__update_plot_params({}, "a", "b")
-        """
-        if value is not None:
-            func_params[plot_param] = "'{}'".format(value) if isinstance(value, str) else value
-
-    @staticmethod
-    def _get_series_param(param, index):
-        """
-        DESCRIPTION:
-            Internal function to get the series parameter.
-            User can pass a list of values or a single value for series parameter's.
-            The function get's the corresponding element based on the index. If
-            element is not found, the function returns a None.
-
-        EXAMPLES:
-            >>> from teradataml import Axis
-            >>> Axis()._Axis_get_series_param(["a"], 1)
-        """
-        try:
-            return UtilFuncs._as_list(param)[index]
-        except IndexError:
-            return None
-
-    def get_xaxis_label(self):
-        """
-        DESCRIPTION:
-            The function generates the x-axis label based on user input. If user specifies x-axis
-            label, the function returns the same. Otherwise, the function generates the x-axis
-            label from x-axis Column Name.
-
-        RETURNS:
-            str
-
-        EXAMPLES:
-            >>> from teradataml import Axis
-            >>> Axis().get_xaxis_label()
-        """
-        return self.xlabel if self.xlabel is not None else self.__get_label([self.__x_axis_data[0]])
-
-    def get_yaxis_label(self):
-        """
-        DESCRIPTION:
-            The function generates the y-axis label based on user input. If user specifies y-axis
-            label, the function returns the same. Otherwise, the function generates the y-axis
-            label from y-axis Column Name.
-
-        RETURNS:
-            str
-
-        EXAMPLES:
-            >>> from teradataml import Axis
-            >>> Axis().get_yaxis_label()
-        """
-        return self.ylabel if self.ylabel is not None else self.__get_label(self.__y_axis_data)
-
-    @staticmethod
-    def __get_label(data):
-        """
-        DESCRIPTION:
-            Internal function to generate the label.
-
-        RETURNS:
-            str
-
-        EXAMPLES:
-            >>> from teradataml import Axis
-            >>> Axis()._Axis__get_label()
-        """
-        _rpl_spcl_chars = UtilFuncs._replace_special_chars
-        # For correlation graph and GeoSpatial, user can pass a tuple of columns. Basically,
-        # the SERIES_SPEC accepts 2 values for FIELD column.
-        if isinstance(data[0], tuple):
-            # If it is a tuple, it has only two elements, both represents DataFrame columns.
-            # Generate the label based on two column names.
-            return " / ".join(
-                ("{} - {}".format(_rpl_spcl_chars(c[0].compile()), _rpl_spcl_chars(c[1].compile())) for c in data))
-
-        return " / ".join((_rpl_spcl_chars(c_name.compile()) for c_name in data))
-
-    def _is_sub_plot(self):
-        """
-        DESCRIPTION:
-            Internal function to check if the Axis is for subplot or not.
-
-        RETURNS:
-            bool
-
-        EXAMPLES:
-            >>> from teradataml import Axis
-            >>> Axis()._is_sub_plot()
-        """
-        return False
-
-
-class AxesSubplot(Axis):
-    def _is_sub_plot(self):
-        """
-        DESCRIPTION:
-            Internal function to check if the Axis is for subplot or not.
-
-        RETURNS:
-            bool
-
-        EXAMPLES:
-            >>> from teradataml import Axis
-            >>> Axis()._is_sub_plot()
-        """
-        return True
+# ##################################################################
+#
+# Copyright 2023 Teradata. All rights reserved.
+# TERADATA CONFIDENTIAL AND TRADE SECRET
+#
+# Primary Owner: Pradeep Garre (pradeep.garre@teradata.com)
+# Secondary Owner:
+#
+# This file implements Axis, which is used for plotting. Axis holds all
+# the properties related to axis such as grid color, x-axis label, y-axis
+# label etc.
+#
+# ##################################################################
+
+from teradataml.common.exceptions import TeradataMlException
+from teradataml.common.messages import Messages
+from teradataml.common.messagecodes import MessageCodes
+from teradataml.common.utils import UtilFuncs
+from teradataml.dataframe.sql import ColumnExpression
+from teradataml.plot.constants import MapType
+from teradataml.utils.validators import _Validators
+
+class Axis:
+    def __init__(self, **kwargs):
+        """
+        Constructor for Axis.
+
+        PARAMETERS:
+            cmap:
+                Optional Argument.
+                Specifies the name of the colormap to be used for plotting.
+                Notes:
+                     * Significant only when corresponding type of plots is mesh or geometry.
+                     * Ignored for other type of plots.
+                Permitted Values:
+                    * All the colormaps mentioned in below URL's are supported.
+                        * https://matplotlib.org/stable/tutorials/colors/colormaps.html
+                        * https://matplotlib.org/cmocean/
+                Types: str
+
+            color:
+                Optional Argument.
+                Specifies the color for the plot.
+                Note:
+                    Hexadecimal color codes are not supported.
+                Permitted Values:
+                    * blue
+                    * orange
+                    * green
+                    * red
+                    * purple
+                    * brown
+                    * pink
+                    * gray
+                    * olive
+                    * cyan
+                    * Apart from above mentioned colors, the colors mentioned in
+                      https://xkcd.com/color/rgb are also supported.
+                Default Value: blue
+                Types: str OR list of str
+
+            grid_color:
+                Optional Argument.
+                Specifies the color of the grid. By default, grid is generated with
+                Gray69(#b0b0b0) color.
+                Note:
+                    Hexadecimal color codes are not supported.
+                Permitted Values:
+                    * 'blue'
+                    * 'orange'
+                    * 'green'
+                    * 'red'
+                    * 'purple'
+                    * 'brown'
+                    * 'pink'
+                    * 'gray'
+                    * 'olive'
+                    * 'cyan'
+                    * Apart from above mentioned colors, the colors mentioned in
+                      https://xkcd.com/color/rgb are also supported.
+                Default Value: 'gray'
+                Types: str
+
+            grid_format:
+                Optional Argument.
+                Specifies the format for the grid.
+                Types: str
+
+            grid_linestyle:
+                Optional Argument.
+                Specifies the line style of the grid.
+                Default Value: -
+                Permitted Values:
+                    * -
+                    * --
+                    * -.
+                Types: str
+
+            grid_linewidth:
+                Optional Argument.
+                Specifies the line width of the grid.
+                Note:
+                    Valid range for "grid_linewidth" is: 0.5 <= grid_linewidth <= 10.
+                Default Value: 0.8
+                Types: int OR float
+
+            legend:
+                Optional Argument.
+                Specifies the legend(s) for the Plot.
+                Types: str OR list of str
+
+            legend_style:
+                Optional Argument.
+                Specifies the location for legend to display on Plot image. By default,
+                legend is displayed at upper right corner.
+                    * 'upper right'
+                    * 'upper left'
+                    * 'lower right'
+                    * 'lower left'
+                    * 'right'
+                    * 'center left'
+                    * 'center right'
+                    * 'lower center'
+                    * 'upper center'
+                    * 'center'
+                Default Value: 'upper right'
+                Types: str
+
+            linestyle:
+                Optional Argument.
+                Specifies the line style for the plot.
+                Permitted Values:
+                    * -
+                    * --
+                    * -.
+                    * :
+                Default Value: -
+                Types: str OR list of str
+
+            linewidth:
+                Optional Argument.
+                Specifies the line width for the plot.
+                Note:
+                    Valid range for "linewidth" is: 0.5 <= linewidth <= 10.
+                Default Value: 0.8
+                Types: int OR float OR list of int OR list of float
+
+            marker:
+                Optional Argument.
+                Specifies the type of the marker to be used.
+                Permitted Values:
+                    All the markers mentioned in https://matplotlib.org/stable/api/markers_api.html
+                    are supported.
+                Types: str OR list of str
+
+            markersize:
+                Optional Argument.
+                Specifies the size of the marker.
+                Note:
+                    Valid range for "markersize" is: 1 <= markersize <= 20.
+                Default Value: 6
+                Types: int OR float OR list of int OR list of float
+
+            position:
+                Optional Argument.
+                Specifies the position of the axis in the Figure. 1st element
+                represents the row and second element represents column.
+                Default Value: (1, 1)
+                Types: tuple
+
+            reverse_xaxis:
+                Optional Argument.
+                Specifies whether to reverse tick values on x-axis or not.
+                Default Value: False
+                Types: bool
+
+            reverse_yaxis:
+                Optional Argument.
+                Specifies whether to reverse tick values on y-axis or not.
+                Default Value: False
+                Types: bool
+
+            span:
+                Optional Argument.
+                Specifies the span of the axis in the Figure. 1st element
+                represents the row and second element represents column.
+                For Example,
+                    Span of (2, 1) specifies the Axis occupies 2 rows and 1 column
+                    in Figure.
+                Default Value: (1, 1)
+                Types: tuple
+
+            series_identifier:
+                Optional Argument.
+                Specifies the teradataml GeoDataFrame Column which represents the
+                identifier for the data. As many plots as distinct "series_identifier"
+                are generated in a single Axis.
+                For example:
+                    consider the below data in teradataml GeoDataFrame.
+                           ID   x   y
+                        0  1    1   1
+                        1  1    2   2
+                        2  2   10  10
+                        3  2   20  20
+                    If "series_identifier" is not specified, simple plot is
+                    generated where every 'y' is plotted against 'x' in a
+                    single plot. However, specifying "series_identifier" as 'ID'
+                    generates two plots in a single axis. One plot is for ID 1
+                    and another plot is for ID 2.
+                Types: teradataml GeoDataFrame Column.
+
+            title:
+                Optional Argument.
+                Specifies the title for the Axis.
+                Types: str
+
+            xlabel:
+                Optional Argument.
+                Specifies the label for x-axis.
+                Notes:
+                     * When set to empty string, label is not displayed for x-axis.
+                     * When set to None, name of the x-axis column is displayed as
+                       label.
+                Types: str
+
+            xlim:
+                Optional Argument.
+                Specifies the range for xtick values.
+                Types: tuple
+
+            xtick_format:
+                Optional Argument.
+                Specifies how to format tick values for x-axis.
+                Types: str
+
+            ylabel:
+                Optional Argument.
+                Specifies the label for y-axis.
+                Notes:
+                     * When set to empty string, label is not displayed for y-axis.
+                     * When set to None, name of the y-axis column(s) is displayed as
+                       label.
+                Types: str
+
+            ylim:
+                Optional Argument.
+                Specifies the range for ytick values.
+                Types: tuple
+
+            ytick_format:
+                Optional Argument.
+                Specifies how to format tick values for y-axis.
+                Types: str
+
+            vmin:
+                Optional Argument.
+                Specifies the lower range of the color map. By default, the range
+                is derived from data and color codes are assigned accordingly.
+                Note:
+                    "vmin" significant only for Mesh and Geometry Plot.
+                Types: int OR float
+
+            vmax:
+                Optional Argument.
+                Specifies the upper range of the color map. By default, the range is
+                derived from data and color codes are assigned accordingly.
+                Note:
+                    "vmax" significant only for Mesh and Geometry Plot.
+                For example:
+                    Assuming user wants to use colormap 'matter' and derive the colors for
+                    values which are in between 1 and 100.
+                    Note:
+                        Colormap 'matter' starts with Pale Yellow and ends with Violet.
+                    * If "colormap_range" is not specified, then range is derived from
+                      existing values. Thus, colors are represented as below in the whole range:
+                      * 1 as Pale Yellow.
+                      * 100 as Violet.
+                    * If "colormap_range" is specified as -100 and 100, the value 1 is at middle of
+                      the specified range. Thus, colors are represented as below in the whole range:
+                      * -100 as Pale Yellow.
+                      * 1 as Orange.
+                      * 100 as Violet.
+                Types: int OR float
+
+        EXAMPLES:
+            # Example 1: Create an Axis with marker as 'Pentagon'.
+            >>> from teradataml import Axis
+            >>> ax = Axis(marker="p")
+
+            # Example 2: Create an Axis which does not have x-tick values
+            #            and y-tick values but it should have grid.
+            #            Note that the grid lines should be in the format of '-.'
+            >>> from teradataml import Axis
+            >>> ax = Axis(xtick_format="", ytick_format="", grid_linestyle="-.")
+
+            # Example 3: Create an Axis which should plot only for the values
+            #            between -10 to 100 on x-axis.
+            >>> from teradataml import Axis
+            >>> ax = Axis(xlim=(-10, 100))
+
+            # Example 4: Create an Axis which should display legend at upper left
+            #            corner and it should disable both x and y axis labels.
+            >>> from teradataml import Axis
+            >>> ax = Axis(legend_style="upper left", xlabel="", ylabel="")
+
+            # Example 5: Create an Axis to format the y-axis tick values to
+            #            display up to two decimal points. Also, use the color
+            #            'dark green' for plotting.
+            #            Note: Consider y-axis data has 5 digit floating numbers.
+            >>> from teradataml import Axis
+            >>> ax = Axis(ytick_format="99999.99", color='dark green')
+
+        RAISES:
+            TeradataMlException
+        """
+        self.__params = {**kwargs}
+
+        self.__x_axis_data = []
+        self.__y_axis_data = []
+        self.__scale_data = []
+
+        arg_info_matrix = []
+
+        # Retrieve arg value from corresponding property.
+        arg_info_matrix.append((["ignore_nulls", self.ignore_nulls, True, bool]))
+
+        arg_info_matrix.append((["cmap", self.cmap, True, (str), True]))
+
+        arg_info_matrix.append((["grid_color", self.grid_color, True, (str), True]))
+
+        arg_info_matrix.append((["grid_format", self.grid_format, True, (str), True]))
+
+        arg_info_matrix.append((["grid_linestyle", self.grid_linestyle, True, (str),
+                                 True, ['-', '--', '-.']]))
+
+        arg_info_matrix.append((["grid_linewidth", self.grid_linewidth, True, (int, float)]))
+
+        arg_info_matrix.append((["legend", self.legend, True, (str, list), True]))
+
+        permitted_legend_style = ['upper right', 'upper left', 'lower right',
+                                  'lower left', 'right', 'center left',
+                                  'center right', 'lower center',
+                                  'upper center', 'center']
+        arg_info_matrix.append((["legend_style", self.legend_style, True,
+                                 (str), True, permitted_legend_style]))
+
+        arg_info_matrix.append((["linestyle", self.linestyle, True, (str, list),
+                                 True, ['-', '--', '-.', ':']]))
+
+        arg_info_matrix.append((["linewidth", self.linewidth, True, (int, float, list), True]))
+
+        arg_info_matrix.append((["marker", self.marker, True, (str, list), True]))
+
+        arg_info_matrix.append((["markersize", self.markersize, True, (int, float, list)]))
+
+        arg_info_matrix.append((["position", self.position, True, (tuple)]))
+
+        arg_info_matrix.append((["span", self.span, True, (tuple)]))
+
+        arg_info_matrix.append((["reverse_xaxis", self.reverse_xaxis, True, (bool)]))
+
+        arg_info_matrix.append((["reverse_yaxis", self.reverse_yaxis, True, (bool)]))
+
+        series_identifier = kwargs.get("series_identifier")
+        arg_info_matrix.append((["series_identifier", series_identifier, True,
+                                 (ColumnExpression)]))
+
+        arg_info_matrix.append((["color", self.color, True, (str, list), True]))
+
+        arg_info_matrix.append((["title", self.title, True, (str), True]))
+
+        arg_info_matrix.append((["xlabel", self.xlabel, True, (str), False]))
+
+        arg_info_matrix.append((["ylabel", self.ylabel, True, (str), False]))
+
+        arg_info_matrix.append((["xlim", self.xlim, True, (tuple)]))
+
+        arg_info_matrix.append((["ylim", self.ylim, True, (tuple)]))
+
+        arg_info_matrix.append((["xtick_format", self.xtick_format, True, (str)]))
+
+        arg_info_matrix.append((["ytick_format", self.ytick_format, True, (str)]))
+
+        arg_info_matrix.append((["vmin", self.vmin, True, (int, float)]))
+        arg_info_matrix.append((["vmax", self.vmax, True, (int, float)]))
+
+        # 'vmin' and 'vmax' is applicable only for Mesh and Geometry plot.
+        if self.kind.lower() not in ['geometry', 'mesh']:
+            if self.vmin is not None:
+                _Validators._validate_dependent_argument("vmin", self.vmin,
+                                                         "kind", None, "'geometry' or 'mesh'")
+            if self.vmax is not None:
+                _Validators._validate_dependent_argument("vmax", self.vmax,
+                                                        "kind", None, "'geometry' or 'mesh'")
+
+        # Argument validations.
+        # Skip empty check for 'xlabel', 'ylabel'.
+        _Validators._validate_function_arguments(
+            arg_info_matrix,
+            skip_empty_check={"xlabel": [''], "ylabel": ['']}
+        )
+
+        # Argument range check.
+        _Validators._validate_argument_range(self.grid_linewidth, "grid_linewidth",
+                                             0.5, lbound_inclusive=True,
+                                             ubound=10, ubound_inclusive=True)
+        # Convert linewidth to list
+        linewidth = UtilFuncs._as_list(self.linewidth)
+        [_Validators._validate_argument_range(lw, "linewidth",
+                                              0.5, lbound_inclusive=True,
+                                              ubound=10, ubound_inclusive=True)
+         for lw in linewidth]
+
+        # Convert markersize to list
+        markersize = UtilFuncs._as_list(self.markersize)
+        [_Validators._validate_argument_range(ms, "markersize",
+                                              1, lbound_inclusive=True,
+                                              ubound=20, ubound_inclusive=True)
+         for ms in markersize]
+
+        self.__series_options = kwargs.get("series_options")  # Specifies SQL element - ID_SEQUENCE
+
+        # Get the series identifier. If it is a column expression, get the column name from it.
+        self.__series_identifier = kwargs.get("series_identifier")
+        if not isinstance(self.__series_identifier, str) and self.__series_identifier is not None:
+            self.__series_identifier = self.__series_identifier.name
+
+    def __get_param(self, param):
+        """
+        DESCRIPTION:
+            Internal function to get the parameter from private variable __params.
+
+        PARAMETERS:
+            param:
+                Required Argument.
+                Specifies the name of the parameter.
+                Types: str
+
+        RETURNS:
+            str OR int OR float OR list
+
+        RAISES:
+            None.
+
+        EXAMPLES:
+            self.__get_param("xlim")
+        """
+        return self.__params.get(param)
+
+    def __set_param(self, param_name, param_value):
+        """
+        DESCRIPTION:
+            Internal function to set the parameter.
+
+        PARAMETERS:
+            param_name:
+                Required Argument.
+                Specifies the name of the parameter.
+                Types: str
+
+            param_value:
+                Required Argument.
+                Specifies the value for the parameter mentioned in "param_name".
+                Types: str OR int OR float OR list
+
+        RETURNS:
+            bool
+
+        RAISES:
+            None.
+
+        EXAMPLES:
+            self.__set_param("xlim", (1, 100))
+        """
+        self.__params[param_name] = param_value
+        return True
+
+    @property
+    def ignore_nulls(self):
+        """ Getter for argument "ignore_nulls". """
+        return self.__get_param("ignore_nulls")
+
+    @ignore_nulls.setter
+    def ignore_nulls(self, value):
+        """ Setter for argument "ignore_nulls". """
+        return self.__set_param("ignore_nulls", value)
+
+    @property
+    def cmap(self):
+        """ Getter for argument "cmap". """
+        return self.__get_param("cmap")
+
+    @cmap.setter
+    def cmap(self, value):
+        """ Setter for argument "cmap". """
+        return self.__set_param("cmap", value)
+
+    @property
+    def vmin(self):
+        """ Getter for argument "vmin". """
+        return self.__get_param("vmin")
+
+    @vmin.setter
+    def vmin(self, value):
+        """ Setter for argument "vmin". """
+        return self.__set_param("vmin", value)
+
+    @property
+    def vmax(self):
+        """ Getter for argument "vmax". """
+        return self.__get_param("vmax")
+
+    @vmax.setter
+    def vmax(self, value):
+        """ Setter for argument "vmax". """
+        return self.__set_param("vmax", value)
+
+    @property
+    def grid_color(self):
+        """ Getter for argument "grid_color". """
+        return self.__get_param("grid_color")
+
+    @grid_color.setter
+    def grid_color(self, value):
+        """ Setter for argument "grid_color". """
+        return self.__set_param("grid_color", value)
+
+    @property
+    def grid_format(self):
+        """ Getter for argument "grid_format". """
+        return self.__get_param("grid_format")
+
+    @grid_format.setter
+    def grid_format(self, value):
+        """ Setter for argument "grid_format". """
+        return self.__set_param("grid_format", value)
+
+    @property
+    def grid_linestyle(self):
+        """ Getter for argument "grid_linestyle". """
+        return self.__get_param("grid_linestyle")
+
+    @grid_linestyle.setter
+    def grid_linestyle(self, value):
+        """ Setter for argument "grid_linestyle". """
+        return self.__set_param("grid_linestyle", value)
+
+    @property
+    def grid_linewidth(self):
+        """ Getter for argument "grid_linewidth". """
+        return self.__get_param("grid_linewidth")
+
+    @grid_linewidth.setter
+    def grid_linewidth(self, value):
+        """ Setter for argument "grid_linewidth". """
+        return self.__set_param("grid_linewidth", value)
+
+    @property
+    def legend(self):
+        """ Getter for argument "legend". """
+        return self.__get_param("legend")
+
+    @legend.setter
+    def legend(self, value):
+        """ Setter for argument "legend". """
+        return self.__set_param("legend", value)
+
+    @property
+    def legend_style(self):
+        """ Getter for argument "legend_style". """
+        return self.__get_param("legend_style")
+
+    @legend_style.setter
+    def legend_style(self, value):
+        """ Setter for argument "legend_style". """
+        return self.__set_param("legend_style", value)
+
+    @property
+    def linestyle(self):
+        """ Getter for argument "linestyle". """
+        return self.__get_param("linestyle")
+
+    @linestyle.setter
+    def linestyle(self, value):
+        """ Setter for argument "linestyle". """
+        return self.__set_param("linestyle", value)
+
+    @property
+    def linewidth(self):
+        """ Getter for argument "linewidth". """
+        return self.__get_param("linewidth")
+
+    @linewidth.setter
+    def linewidth(self, value):
+        """ Setter for argument "linewidth". """
+        return self.__set_param("linewidth", value)
+
+    @property
+    def marker(self):
+        """ Getter for argument "marker". """
+        return self.__get_param("marker")
+
+    @marker.setter
+    def marker(self, value):
+        """ Setter for argument "marker". """
+        return self.__set_param("marker", value)
+
+    @property
+    def markersize(self):
+        """ Getter for argument "markersize". """
+        return self.__get_param("markersize")
+
+    @markersize.setter
+    def markersize(self, value):
+        """ Setter for argument "markersize". """
+        return self.__set_param("markersize", value)
+
+    @property
+    def reverse_xaxis(self):
+        """ Getter for argument "reverse_xaxis". """
+        return self.__get_param("reverse_xaxis")
+
+    @reverse_xaxis.setter
+    def reverse_xaxis(self, value):
+        """ Setter for argument "reverse_xaxis". """
+        return self.__set_param("reverse_xaxis", value)
+
+    @property
+    def reverse_yaxis(self):
+        """ Getter for argument "reverse_yaxis". """
+        return self.__get_param("reverse_yaxis")
+
+    @reverse_yaxis.setter
+    def reverse_yaxis(self, value):
+        """ Setter for argument "reverse_yaxis". """
+        return self.__set_param("reverse_yaxis", value)
+
+    @property
+    def color(self):
+        """ Getter for argument "color". """
+        return self.__get_param("color")
+
+    @color.setter
+    def color(self, value):
+        """ Setter for argument "color". """
+        return self.__set_param("color", value)
+
+    @property
+    def xlabel(self):
+        """ Getter for argument "xlabel". """
+        return self.__get_param("xlabel")
+
+    @xlabel.setter
+    def xlabel(self, value):
+        """ Setter for argument "xlabel". """
+        return self.__set_param("xlabel", value)
+
+    @property
+    def xlim(self):
+        """ Getter for argument "xlim". """
+        return self.__get_param("xlim")
+
+    @xlim.setter
+    def xlim(self, value):
+        """ Setter for argument "xlim". """
+        return self.__set_param("xlim", value)
+
+    @property
+    def xtick_format(self):
+        """ Getter for argument "xtick_format". """
+        return self.__get_param("xtick_format")
+
+    @xtick_format.setter
+    def xtick_format(self, value):
+        """ Setter for argument "xtick_format". """
+        return self.__set_param("xtick_format", value)
+
+    @property
+    def ylabel(self):
+        """ Getter for argument "ylabel". """
+        return self.__get_param("ylabel")
+
+    @ylabel.setter
+    def ylabel(self, value):
+        """ Setter for argument "ylabel". """
+        return self.__set_param("ylabel", value)
+
+    @property
+    def ylim(self):
+        """ Getter for argument "ylim". """
+        return self.__get_param("ylim")
+
+    @ylim.setter
+    def ylim(self, value):
+        """ Setter for argument "ylim". """
+        return self.__set_param("ylim", value)
+
+    @property
+    def ytick_format(self):
+        """ Getter for argument "ytick_format". """
+        return self.__get_param("ytick_format")
+
+    @ytick_format.setter
+    def ytick_format(self, value):
+        """ Setter for argument "ytick_format". """
+        return self.__set_param("ytick_format", value)
+
+    @property
+    def title(self):
+        """ Getter for argument "title". """
+        return self.__get_param("title")
+
+    @title.setter
+    def title(self, value):
+        """ Setter for argument "title". """
+        return self.__set_param("title", value)
+
+    @property
+    def kind(self):
+        """ Getter for argument "kind". """
+        _k = self.__get_param("kind")
+        return _k if _k is not None else "line"
+
+    @kind.setter
+    def kind(self, value):
+        """ Setter for argument "kind". """
+        return self.__set_param("kind", value)
+
+    @property
+    def position(self):
+        """ Getter for argument "position". """
+        _p = self.__get_param("position")
+        return (1, 1) if _p is None else _p
+
+    @position.setter
+    def position(self, value):
+        """ Setter for argument "position". """
+        return self.__set_param("position", value)
+
+    @property
+    def span(self):
+        """ Getter for argument "span". """
+        _s = self.__get_param("span")
+        return (1, 1) if _s is None else _s
+
+    @span.setter
+    def span(self, value):
+        """ Setter for argument "span". """
+        return self.__set_param("span", value)
+
+    def set_params(self, **kwargs):
+        """
+        DESCRIPTION:
+            Function to set the parameters for Axis object.
+
+        PARAMETERS:
+            **kwargs:
+                Keyword arguments passed to the method, i.e., set_params.
+                All the arguments supported for Axis object are supported here.
+                Refer to 'Axis' documentation for arguments supported by it.
+
+        RETURNS:
+             True, if successful.
+
+        EXAMPLES:
+            # Create a default Axis object.
+            >>> from teradataml import Axis
+            >>> ax = Axis()
+
+            # Example 1: Disable x-axis label for an existing Axis object.
+            >>> ax.set_params(xlabel="")
+
+            # Example 2: Set the title for an existing Axis object. Also, disable
+            #            x-tick values.
+            >>> ax.set_params(title="Title", xtick_values="")
+        """
+        self.__params.update(kwargs)
+        return True
+
+    def _set_data(self, x, y, scale=None):
+        """
+        DESCRIPTION:
+            Internal function to set the x-axis and y-axis data to Axis object.
+
+        PARAMETERS:
+            x:
+                Required Argument.
+                Specifies the x-axis data.
+                Types: teradataml DataFrame Column
+
+            y:
+                Required Argument.
+                Specifies the y-axis data.
+                Types: teradataml DataFrame Column OR list of teradataml DataFrame Column.
+
+            scale:
+                Optional Argument.
+                Specifies the scale data which is required for wiggle and mesh plots.
+                Note:
+                    "scale" is significant for wiggle and mesh plots. Ignored for other
+                    type of plots.
+                Types: teradataml DataFrame Column OR list of teradataml DataFrame Column.
+
+        EXAMPLES:
+            >>> ax = Axis()
+            >>> ax._set_data(df.col1, [df.col2, df.col3])
+        """
+        # Before setting the data, clear it first.
+        self.__clear_axis_data()
+
+        y = UtilFuncs._as_list(y)
+
+        # Make sure number of columns mentioned in x-axis is
+        # same as number of columns mentioned in y-axis.
+        x = UtilFuncs._as_list(x)
+        if len(x) != len(y):
+            x = x * len(y)
+
+        scale = UtilFuncs._as_list(scale)
+
+        self.__x_axis_data.extend(x)
+        self.__y_axis_data.extend(y)
+        self.__scale_data.extend(scale)
+
+    def __clear_axis_data(self):
+        """
+        DESCRIPTION:
+            Internal function to clear the axis data.
+
+        RETURNS:
+            bool
+
+        EXAMPLES:
+            >>> ax = Axis()
+            >>> ax._Axis__clear_axis_data()
+        """
+        self.__x_axis_data.clear()
+        self.__y_axis_data.clear()
+        self.__scale_data.clear()
+
+        return True
+
+    def _has_data(self):
+        """
+        DESCRIPTION:
+            Internal function to check whether axis is associated with data or not.
+
+        RETURNS:
+            bool
+
+        EXAMPLES:
+            >>> ax = Axis()
+            >>> ax._has_data()
+        """
+        return bool(self.__x_axis_data)
+
+    def __repr__(self):
+        """
+        DESCRIPTION:
+            String representation of Axis Object.
+
+        RETURNS:
+            str.
+
+        RAISES:
+            None.
+
+        EXAMPLES:
+            # Create an Axis Object.
+            >>> from teradataml import Axis
+            >>> axis = Axis()
+            >>> print(axis)
+        """
+        return "{}(position={}, span={})".format(self.__class__.__name__, self.position, self.span)
+
+    def _get_plot_data(self):
+        """
+        DESCRIPTION:
+            Internal function to get the plot data. The function, which is called from Plot object
+            gets all the corresponding information to generate the plot.
+
+        RETURNS:
+            tuple, with 3 elements.
+                * element 1 represents again a tuple - 2nd element represents a SELECT statement
+                  and 1st element represents a string which is the alias table name of SELECT
+                  statement. It is necessary to get the alias table name also as series spec
+                  references alias table names.
+                * element 2 represents either a series spec or matrix spec in string format.
+                * element 3 represents a dictionary with all the parameters for Plot.
+
+        RAISES:
+            None.
+
+        EXAMPLES:
+            >>> from teradataml import Axis
+            >>> axis = Axis()
+            >>> axis._get_plot_data()
+        """
+
+        # TODO: Run only once and store this information. Also, df.concat is a costly operation.
+        #  Will be implemented with ELE-5803.
+        _virtual_table, _spec = self.__get_matrix_spec() if self.kind in (MapType.MESH.value, MapType.WIGGLE.value) \
+            else self.__get_series_spec()
+
+        return (_virtual_table, _spec, self._get_params())
+
+    def __get_series_spec(self):
+        """
+        DESCRIPTION:
+            Internal function to generate TDSeries Spec.
+            * If user pass 'series_id' by using the argument "series_identifier", then consider 'series_id'
+              as "series_identifier", x-axis data for 'row_axis' and y-axis data for 'payload_field' in
+              TDSeries object. Both, 'row_index_style' and 'payload_content' can be derived
+              programatically using __get_index_style() and __get_payload_content() respectively.
+            * If user do not pass 'series_id', then the function constructs the series spec as below:
+              * walk through x-axis and y-axis data.
+              * Construct a new teradataml DataFrame by generating a new column for ID field
+                along with x and y axis columns.
+                * ID Column value can be either str or float or int. Since the column will be
+                  used as legend if user do not specify the legend, make sure ID Column value
+                  is Y-Axis column name. This makes a very good user experience in Composite plots.
+                * For geometry and corr plot, y axis can be a tuple. In such cases, make sure to generate
+                  the ID Column Value with all the columns mentioned in tuple.
+                  * Note that, if it is tuple, Columns mentioned in tuple can have same name. Make
+                    sure to generate the ID Column value as a unique value.
+                * With the above information, i.e, ID Column, x-axis data and y-axis data, construct a
+                  new teradataml DataFrame.
+              * Repeat the above process if user pass multiple ColumnExpression(s) for y-axis data and
+                concatenate the generated DataFrame with previously generated DataFrame vertically.
+
+        RAISES:
+            TeradatamlException - If all the ColumnExpression(s) mentioned in y-axis are of not same type.
+
+        RETURNS:
+            tuple
+
+        EXAMPLES:
+            >>> from teradataml import Axis
+            >>> Axis()._Axis__get_series_spec()
+        """
+        from teradataml.dataframe.dataframe import TDSeries
+
+        if self.__series_identifier:
+            # Remove null values from DataFrame
+            if self.ignore_nulls:
+                _df = self.__x_axis_data[0]._parent_df
+                _subset = [column_name.name for column_name in self.__y_axis_data]
+                _subset.append(self.__x_axis_data[0].name)
+                _df = _df.dropna(how='any', subset=_subset)
+
+            # Execute the node and create the table in Vantage.
+            if self.__y_axis_data[0]._parent_df._table_name is None:
+                # Assuming all the columns are from same DataFrame.
+                repr(self.__y_axis_data[0]._parent_df)
+
+            series = TDSeries(data=_df if self.ignore_nulls else self.__x_axis_data[0]._parent_df,
+                              id=self.__series_identifier,
+                              row_index=self.__x_axis_data[0].name,
+                              row_index_style=self.__get_index_style(self.__x_axis_data[0]),
+                              payload_field=self.__y_axis_data[0].name,
+                              payload_content=self.__get_payload_content(self.__y_axis_data[0]))
+            return "", series._get_sql_repr(True)
+
+        # Since user does not pass series identifier, convert the data in to TDSeries spec.
+        _index = 1
+        _previous_df = None
+
+        # Loop through every element and concatenate the dataframes vertically, i.e.,
+        # using UNION ALL clause.
+        for index, (_x, _y) in enumerate(zip(self.__x_axis_data, self.__y_axis_data)):
+            _df = _y._parent_df if not isinstance(_y, tuple) else _y[0]._parent_df
+            # For correlated and geometry graph, user can pass two params for PAYLOAD FIELD.
+            if isinstance(_y, tuple):
+                # Generate the id_column name programatically. This appears at legend
+                # if legend is shown. So, build it meaningfully.
+                _id_column = "{}_{}_{}".format(_y[0].compile(), _y[1].compile(), _index)
+                columns = {"y_identifier":UtilFuncs._replace_special_chars(_id_column), "id":index, "x":_x, "y1":_y[0], "y2":_y[1]}
+                payload_field = ["y1", "y2"]
+            else:
+                columns = {"y_identifier":UtilFuncs._replace_special_chars(_y.compile()), "id":index, "x":_x, "y":_y}
+                payload_field = "y"
+
+            _df = _df.assign(**columns, drop_columns=True)
+            # Concatenate with previous DataFrame.
+            if _previous_df:
+                # TODO: Note that concat is a very costly operation. Infact, it is very very slow.
+                #  Consider generating VIRTUAL tables or UNPIVOT.
+                #  Will be addressed with ELE-5808.
+                _df = _previous_df.concat(_df)
+
+            _previous_df = _df
+            # Flatten the DataFrame.
+            _index = _index + 1
+        # Remove null values from DataFrame
+        if self.ignore_nulls:
+            _df = _df.dropna()
+        repr(_df)
+        series = TDSeries(data=_df,
+                          id="id",
+                          row_index="x",
+                          row_index_style=self.__get_index_style(_df.x),
+                          payload_field=payload_field,
+                          payload_content=self.__get_payload_content(self.__y_axis_data[0]))
+
+        # TODO: Should return a virtual table at first element if required.
+        #  Will be addressed with ELE-5808.
+        return "", series._get_sql_repr(True)
+
+    def __get_matrix_spec(self):
+        """
+        DESCRIPTION:
+            Internal function to generate TDMatrix Spec.
+            * If user pass 'matrix_id' by using the argument "series_identifier", then consider 'matrix_id'
+              as "series_identifier", x-axis data for 'row_axis' and y-axis data for 'column_axis' and
+              scale data for 'payload_field' in TDMatrix object. Both, 'row_index_style' and 'payload_content'
+              can be derived programatically using __get_index_style() and __get_payload_content()
+              respectively.
+            * If user do not pass 'matrix_id', then the function constructs the matrix spec as below:
+              * walk through x-axis, y-axis and scale data.
+              * Construct a new teradataml DataFrame by generating a new column for ID field
+                * ID Column value can be either str or float or int. Since the column will be
+                  used as legend if user do not specify the legend, make sure ID Column value
+                  is Y-Axis column name. This makes a very good user experience in Composite plots.
+                * With the above information, i.e, ID Column, x-axis data, y-axis data and scale data,
+                  construct a new teradataml DataFrame.
+              * Repeat the above process if user pass multiple ColumnExpression(s) for y-axis data and
+                concatenate the generated DataFrame with previously generated DataFrame vertically.
+
+        RAISES:
+            TeradatamlException - If all the ColumnExpression(s) mentioned in y-axis are of not same type.
+
+        RETURNS:
+            tuple
+
+        EXAMPLES:
+            >>> from teradataml import Axis
+            >>> Axis()._Axis__get_matrix_spec()
+        """
+        from teradataml.dataframe.dataframe import TDMatrix
+
+        if self.__series_identifier:
+            # Remove null values from DataFrame
+            if self.ignore_nulls:
+                _df = self.__x_axis_data[0]._parent_df
+                _subset = [column_name.name for column_name in self.__y_axis_data]
+                _subset.append(self.__x_axis_data[0].name)
+                _subset.extend(column_name.name for column_name in self.__scale_data)
+                _df = _df.dropna(how='any', subset=_subset)
+
+            # Execute the node and create the table/view in Vantage.
+            if self.__y_axis_data[0]._parent_df._table_name is None:
+                repr(self.__y_axis_data[0]._parent_df)
+
+            matrix = TDMatrix(data=_df if self.ignore_nulls else self.__x_axis_data[0]._parent_df,
+                              id=self.__series_identifier,
+                              row_index=self.__x_axis_data[0].name,
+                              row_index_style=self.__get_index_style(self.__x_axis_data[0]),
+                              column_index=self.__y_axis_data[0].name,
+                              column_index_style=self.__get_index_style(self.__y_axis_data[0]),
+                              payload_field=self.__scale_data[0].name,
+                              payload_content=self.__get_payload_content(self.__scale_data[0]))
+            return "", matrix._get_sql_repr(True)
+
+        # Since user do not pass matrix identifier, convert the data in to TDMatrix spec.
+        _previous_df = None
+        for index, (_x, _y, _data) in enumerate(zip(self.__x_axis_data, self.__y_axis_data, self.__scale_data)):
+            _df = _x._parent_df
+            columns = {"y_identifier": UtilFuncs._replace_special_chars(_y.compile()), "id":index, "x": _x, "y": _y, "data": _data}
+            _df = _df.assign(**columns, drop_columns=True)
+            if _previous_df:
+                # TODO: Note that concat is a very costly operation. Infact, it is very very slow.
+                #  Consider generating VIRTUAL tables or UNPIVOT.
+                #  Will be addressed with ELE-5808.
+                _df = _previous_df.concat(_df)
+
+            _previous_df = _df
+        # Remove null values from DataFrame
+        if self.ignore_nulls:
+            _df = _df.dropna()
+        repr(_df)
+        matrix = TDMatrix(data=_df,
+                          id="id",
+                          row_index="x",
+                          row_index_style=self.__get_index_style(_df.x),
+                          column_index="y",
+                          column_index_style=self.__get_index_style(_df.y),
+                          payload_field="data",
+                          payload_content="REAL")
+
+        # TODO: Should return a virtual table at first element if required.
+        #  Will be addressed with ELE-5808.
+        return "", matrix._get_sql_repr(True)
+
+    def __get_index_style(self, _x):
+        """
+        DESCRIPTION:
+            Internal function to generate the value for argument "row_index_style"
+            in TDSeries/TDMatrix objects.
+
+        PARAMETERS:
+            _x:
+               Required Argument.
+               Specifies the ColumnExpression of x-axis data.
+               Types: teradataml ColumnExpression.
+
+        RETURNS:
+            str
+
+        EXAMPLES:
+            >>> from teradataml import Axis
+            >>> Axis()._Axis__get_index_style()
+        """
+        if UtilFuncs._teradata_type_to_python_type(_x.type) in ('int', 'float', 'str'):
+            return "SEQUENCE"
+        return "TIMECODE"
+
+    def __get_payload_content(self, _y):
+        """
+        DESCRIPTION:
+            Internal function to generate the value for argument "payload_content"
+            in TDSeries/TDMatrix objects.
+
+        PARAMETERS:
+            _y:
+               Required Argument.
+               Specifies the ColumnExpression of y-axis data.
+               Note that y-axis can be a list of ColumnExpression(s) also.
+               Since all the Columns are concatenated vertically, every column
+               type should be same. So, deriving "payload_content" value for 1st
+               element is suffice.
+               Types: teradataml ColumnExpression.
+
+        RETURNS:
+            str
+
+        EXAMPLES:
+            >>> from teradataml import Axis
+            >>> Axis()._Axis__get_payload_content()
+        """
+        # If y-axis is a tuple, return MULTIVAR_ANYTYPE.
+        if self.kind == MapType.GEOMETRY.value:
+            return "MULTIVAR_ANYTYPE"
+
+        if self.kind == MapType.CORR.value:
+            return "MULTIVAR_REAL" if isinstance(_y, tuple) else "REAL"
+
+        return "REAL"
+
+    @staticmethod
+    def __get_color_code(color):
+        """
+        DESCRIPTION:
+            Internal function to get the string for a color which is recognised by TD_PLOT.
+
+        RETURNS:
+            str
+
+        EXAMPLES:
+            >>> from teradataml import Axis
+            >>> Axis()._Axis__get_color_code("orange")
+        """
+        default_colors = {'blue', 'orange', 'green', 'red', 'purple', 'brown', 'pink', 'gray', 'olive', 'cyan'}
+        return "tab:{}".format(color) if color in default_colors else "xkcd:{}".format(color)
+
+    def __get_series_parameters(self):
+        """
+        DESCRIPTION:
+            Internal function to generate the parameters for individual Series.
+
+        RETURNS:
+            list
+
+        EXAMPLES:
+            >>> from teradataml import Axis
+            >>> Axis()._Axis__get_series_parameters()
+        """
+        _series_params = []
+        for index in range(len(self.__y_axis_data)):
+            _series_param = {"ID": index+1}
+            color = self._get_series_param(self.color, index)
+            if color:
+                _series_param["COLOR"] = "'{}'".format(self.__get_color_code(color))
+
+            line_style = self._get_series_param(self.linestyle, index)
+            self.__update_plot_params(_series_param, "LINESTYLE", line_style)
+
+            line_width = self._get_series_param(self.linewidth, index)
+            self.__update_plot_params(_series_param, "LINEWIDTH", line_width)
+
+            marker = self._get_series_param(self.marker, index)
+            self.__update_plot_params(_series_param, "MARKER", marker)
+
+            marker_size = self._get_series_param(self.markersize, index)
+            self.__update_plot_params(_series_param, "MARKERSIZE", marker_size)
+
+            # If user pass legend name use it. Else, derive it from Y-Axis.
+            # Legend is not applicable for wiggle and mesh plots.
+            if self.kind not in (MapType.MESH.value, MapType.WIGGLE.value):
+                legend_name = self._get_series_param(self.legend, index)
+                if legend_name:
+                    _series_param["NAME"] = "'{}'".format(legend_name)
+                else:
+                    columns = self.__y_axis_data[index] if isinstance(self.__y_axis_data[index], tuple) else \
+                        [self.__y_axis_data[index]]
+                    columns = [UtilFuncs._replace_special_chars(col.compile()) for col in columns]
+                    _series_param["NAME"] = "'{}'".format(" / ".join(columns))
+
+            _series_params.append(_series_param)
+        return _series_params
+
+    def _get_params(self):
+        """
+        DESCRIPTION:
+            Internal function to generate the parameters for the plot.
+
+        RETURNS:
+            dict
+
+        EXAMPLES:
+            >>> from teradataml import Axis
+            >>> Axis()._Axis_get_params()
+        """
+        func_params = {"CELL": (self.position[1], self.position[0]),
+                       "SPAN": (self.span[1], self.span[0]),
+                       "TYPE": "'{}'".format(self.kind),
+                       "XLABEL": "'{}'".format(self.get_xaxis_label()),
+                       "YLABEL": "'{}'".format(self.get_yaxis_label()),
+                       "SERIES": self.__get_series_parameters()
+                       }
+
+        self.__update_plot_params(func_params, "TITLE", self.title)
+        self.__update_plot_params(func_params, "XFORMAT", self.xtick_format)
+        self.__update_plot_params(func_params, "YFORMAT", self.ytick_format)
+        self.__update_plot_params(func_params, "XRANGE", self.xlim)
+        self.__update_plot_params(func_params, "YRANGE", self.ylim)
+
+        if self.reverse_xaxis is True:
+            func_params["FLIPX"] = 1
+
+        if self.reverse_yaxis is True:
+            func_params["FLIPY"] = 1
+
+        # For subplot or multiple series, make sure to populate legend.
+        # For mainplot, leave it to user's choice.
+        if self._is_sub_plot() or self.__series_identifier or (len(self.__y_axis_data) > 1) and \
+                self.kind not in (MapType.MESH.value, MapType.WIGGLE.value):
+            func_params["LEGEND"] = "'{}'".format("best" if not self.legend_style else self.legend_style)
+        else:
+            self.__update_plot_params(func_params, "LEGEND", self.legend_style)
+
+        # Populate GRID parameters.
+        if self.grid_format or self.grid_color or self.grid_linestyle or self.grid_linewidth:
+            _grid_params = {}
+            self.__update_plot_params(_grid_params, "COLOR", self.__get_color_code(self.grid_color))
+            self.__update_plot_params(_grid_params, "FORMAT", self.grid_format)
+            self.__update_plot_params(_grid_params, "LINESTYLE", self.grid_linestyle)
+            self.__update_plot_params(_grid_params, "LINEWIDTH", self.grid_linewidth)
+            func_params["GRID"] = _grid_params
+
+        # Populate color map parameters.
+        if self.cmap or self.vmin:
+            # TODO: User should control the COLORBAR. Expose a parameter to user.
+            _color_map_params = {"COLORBAR": 1}
+            self.__update_plot_params(_color_map_params, "RANGE", None if self.vmin is None else (self.vmin, self.vmax))
+            self.__update_plot_params(_color_map_params, "NAME", self.cmap)
+            func_params["COLORMAP"] = _color_map_params
+
+        return func_params
+
+    @staticmethod
+    def __update_plot_params(func_params, plot_param, value):
+        """
+        DESCRIPTION:
+            Internal function to update the Plot parameter.
+            The function check whether "value" is None or not. If None,
+            no action from this function on "func_params". Else, "func_params"
+            is updated with "plot_param".
+
+        EXAMPLES:
+            >>> from teradataml import Axis
+            >>> Axis()._Axis__update_plot_params({}, "a", "b")
+        """
+        if value is not None:
+            func_params[plot_param] = "'{}'".format(value) if isinstance(value, str) else value
+
+    @staticmethod
+    def _get_series_param(param, index):
+        """
+        DESCRIPTION:
+            Internal function to get the series parameter.
+            User can pass a list of values or a single value for series parameter's.
+            The function get's the corresponding element based on the index. If
+            element is not found, the function returns a None.
+
+        EXAMPLES:
+            >>> from teradataml import Axis
+            >>> Axis()._Axis_get_series_param(["a"], 1)
+        """
+        try:
+            return UtilFuncs._as_list(param)[index]
+        except IndexError:
+            return None
+
+    def get_xaxis_label(self):
+        """
+        DESCRIPTION:
+            The function generates the x-axis label based on user input. If user specifies x-axis
+            label, the function returns the same. Otherwise, the function generates the x-axis
+            label from x-axis Column Name.
+
+        RETURNS:
+            str
+
+        EXAMPLES:
+            >>> from teradataml import Axis
+            >>> Axis().get_xaxis_label()
+        """
+        return self.xlabel if self.xlabel is not None else self.__get_label([self.__x_axis_data[0]])
+
+    def get_yaxis_label(self):
+        """
+        DESCRIPTION:
+            The function generates the y-axis label based on user input. If user specifies y-axis
+            label, the function returns the same. Otherwise, the function generates the y-axis
+            label from y-axis Column Name.
+
+        RETURNS:
+            str
+
+        EXAMPLES:
+            >>> from teradataml import Axis
+            >>> Axis().get_yaxis_label()
+        """
+        return self.ylabel if self.ylabel is not None else self.__get_label(self.__y_axis_data)
+
+    @staticmethod
+    def __get_label(data):
+        """
+        DESCRIPTION:
+            Internal function to generate the label.
+
+        RETURNS:
+            str
+
+        EXAMPLES:
+            >>> from teradataml import Axis
+            >>> Axis()._Axis__get_label()
+        """
+        _rpl_spcl_chars = UtilFuncs._replace_special_chars
+        # For correlation graph and GeoSpatial, user can pass a tuple of columns. Basically,
+        # the SERIES_SPEC accepts 2 values for FIELD column.
+        if isinstance(data[0], tuple):
+            # If it is a tuple, it has only two elements, both represents DataFrame columns.
+            # Generate the label based on two column names.
+            return " / ".join(
+                ("{} - {}".format(_rpl_spcl_chars(c[0].compile()), _rpl_spcl_chars(c[1].compile())) for c in data))
+
+        return " / ".join((_rpl_spcl_chars(c_name.compile()) for c_name in data))
+
+    def _is_sub_plot(self):
+        """
+        DESCRIPTION:
+            Internal function to check if the Axis is for subplot or not.
+
+        RETURNS:
+            bool
+
+        EXAMPLES:
+            >>> from teradataml import Axis
+            >>> Axis()._is_sub_plot()
+        """
+        return False
+
+
+class AxesSubplot(Axis):
+    def _is_sub_plot(self):
+        """
+        DESCRIPTION:
+            Internal function to check if the Axis is for subplot or not.
+
+        RETURNS:
+            bool
+
+        EXAMPLES:
+            >>> from teradataml import Axis
+            >>> Axis()._is_sub_plot()
+        """
+        return True