maxframe 2.0.0b2__cp37-cp37m-win32.whl → 2.3.0rc1__cp37-cp37m-win32.whl

maxframe/dataframe/datasource/read_odps_table.py

@@ -22,7 +22,7 @@ from odps.models import Table
 from odps.utils import to_timestamp
 
 from ... import opcodes
-from ...config import options
+from ...config import option_context, options
 from ...core import OutputType
 from ...io.odpsio import odps_schema_to_pandas_dtypes
 from ...serialization.serializables import (
@@ -36,8 +36,12 @@ from ...serialization.serializables import (
 )
 from ...utils import estimate_table_size, is_empty
 from ..core import DataFrame  # noqa: F401
-from ..utils import parse_index
-from .core import ColumnPruneSupportedDataSourceMixin, IncrementalIndexDatasource
+from ..utils import parse_index, validate_dtype_backend
+from .core import (
+    ColumnPruneSupportedDataSourceMixin,
+    DtypeBackendCompatibleMixin,
+    IncrementalIndexDatasource,
+)
 
 logger = logging.getLogger(__name__)
 
@@ -45,6 +49,7 @@ logger = logging.getLogger(__name__)
 class DataFrameReadODPSTable(
     IncrementalIndexDatasource,
     ColumnPruneSupportedDataSourceMixin,
+    DtypeBackendCompatibleMixin,
 ):
     __slots__ = ("_odps_entry",)
     _op_type_ = opcodes.READ_ODPS_TABLE
@@ -54,18 +59,22 @@ class DataFrameReadODPSTable(
     dtypes = SeriesField("dtypes", default=None)
     columns = AnyField("columns", default=None)
     nrows = Int64Field("nrows", default=None)
-    use_arrow_dtype = BoolField("use_arrow_dtype", default=None)
+    dtype_backend = StringField("dtype_backend", default=None)
     string_as_binary = BoolField("string_as_binary", default=None)
     append_partitions = BoolField("append_partitions", default=None)
     last_modified_time = Int64Field("last_modified_time", default=None)
     index_columns = ListField("index_columns", FieldTypes.string, default=None)
     index_dtypes = SeriesField("index_dtypes", default=None)
 
-    def __init__(self, memory_scale=None, **kw):
+    def __init__(self, memory_scale=None, dtype_backend=None, **kw):
         output_type = kw.pop("output_type", OutputType.dataframe)
         self._odps_entry = kw.pop("odps_entry", None)
+        dtype_backend = validate_dtype_backend(dtype_backend)
         super(DataFrameReadODPSTable, self).__init__(
-            memory_scale=memory_scale, _output_types=[output_type], **kw
+            memory_scale=memory_scale,
+            dtype_backend=dtype_backend,
+            _output_types=[output_type],
+            **kw,
         )
 
     @property
@@ -153,6 +162,7 @@ def read_odps_table(
     odps_entry: ODPS = None,
     string_as_binary: bool = None,
     append_partitions: bool = False,
+    dtype_backend: str = None,
     **kw,
 ):
     """
@@ -176,6 +186,8 @@ def read_odps_table(
     append_partitions: bool
         If True, will add all partition columns as selected columns when
         `columns` is not specified,
+    dtype_backend: {'numpy', 'pyarrow'}, default 'numpy'
+        Back-end data type applied to the resultant DataFrame (still experimental).
 
     Returns
     -------
@@ -202,9 +214,20 @@ def read_odps_table(
         else table.table_schema.simple_columns
     )
     table_columns = [c.name.lower() for c in cols]
-    table_dtypes = odps_schema_to_pandas_dtypes(
-        table.table_schema, with_partitions=True
+
+    if "use_arrow_dtype" in kw:
+        dtype_backend = dtype_backend or validate_dtype_backend(
+            kw.pop("use_arrow_dtype")
+        )
+    dtype_backend = validate_dtype_backend(
+        dtype_backend or options.dataframe.dtype_backend
     )
+
+    with option_context():
+        options.dataframe.dtype_backend = dtype_backend
+        table_dtypes = odps_schema_to_pandas_dtypes(
+            table.table_schema, with_partitions=True
+        )
     df_types = [table_dtypes[c] for c in table_columns]
 
     if isinstance(index_col, str):
@@ -246,7 +269,6 @@ def read_odps_table(
     dtypes = pd.Series(df_types, index=table_columns)
     chunk_bytes = kw.pop("chunk_bytes", None)
     chunk_size = kw.pop("chunk_size", None)
-    use_arrow_dtype = kw.pop("use_arrow_dtype", True)
 
     partitions = partitions or kw.get("partition")
     if isinstance(partitions, str):
@@ -261,7 +283,7 @@ def read_odps_table(
         partitions=partitions,
         dtypes=dtypes,
         columns=columns,
-        use_arrow_dtype=use_arrow_dtype,
+        dtype_backend=dtype_backend,
         string_as_binary=string_as_binary,
         append_partitions=append_partitions,
         last_modified_time=to_timestamp(table.last_data_modified_time),

maxframe/dataframe/datasource/read_parquet.py

@@ -32,6 +32,7 @@ except ImportError:
 
 from ... import opcodes
 from ...config import options
+from ...lib.dtypes_extension import ArrowDtype
 from ...lib.filesystem import FileSystem, get_fs, glob, open_file
 from ...serialization.serializables import (
     AnyField,
@@ -43,10 +44,13 @@ from ...serialization.serializables import (
     StringField,
 )
 from ...utils import lazy_import
-from ..arrays import ArrowStringDtype
 from ..operators import OutputType
 from ..utils import parse_index, to_arrow_dtypes
-from .core import ColumnPruneSupportedDataSourceMixin, IncrementalIndexDatasource
+from .core import (
+    ColumnPruneSupportedDataSourceMixin,
+    DtypeBackendCompatibleMixin,
+    IncrementalIndexDatasource,
+)
 
 PARQUET_MEMORY_SCALE = 15
 STRING_FIELD_OVERHEAD = 50
@@ -89,13 +93,11 @@ class ParquetEngine:
     def read_dtypes(self, f, **kwargs):
         raise NotImplementedError
 
-    def read_to_pandas(
-        self, f, columns=None, nrows=None, use_arrow_dtype=None, **kwargs
-    ):
+    def read_to_pandas(self, f, columns=None, nrows=None, dtype_backend=None, **kwargs):
         raise NotImplementedError
 
     def read_group_to_pandas(
-        self, f, group_index, columns=None, nrows=None, use_arrow_dtype=None, **kwargs
+        self, f, group_index, columns=None, nrows=None, dtype_backend=None, **kwargs
     ):
         raise NotImplementedError
 
@@ -106,11 +108,11 @@ class ParquetEngine:
         partition_keys: Dict,
         columns=None,
         nrows=None,
-        use_arrow_dtype=None,
+        dtype_backend=None,
         **kwargs,
     ):
         raw_df = self.read_to_pandas(
-            f, columns=columns, nrows=nrows, use_arrow_dtype=use_arrow_dtype, **kwargs
+            f, columns=columns, nrows=nrows, dtype_backend=dtype_backend, **kwargs
         )
         for col, value in partition_keys.items():
             dictionary = partitions[col]
@@ -169,28 +171,26 @@ class ArrowEngine(ParquetEngine):
         return file.schema_arrow.empty_table().to_pandas().dtypes
 
     @classmethod
-    def _table_to_pandas(cls, t, nrows=None, use_arrow_dtype=None):
+    def _table_to_pandas(cls, t, nrows=None, dtype_backend=None):
         if nrows is not None:
             t = t.slice(0, nrows)
-        if use_arrow_dtype:
-            df = t.to_pandas(types_mapper={pa.string(): ArrowStringDtype()}.get)
+        if dtype_backend == "pyarrow":
+            df = t.to_pandas(types_mapper={pa.string(): ArrowDtype(pa.string())}.get)
         else:
             df = t.to_pandas()
         return df
 
-    def read_to_pandas(
-        self, f, columns=None, nrows=None, use_arrow_dtype=None, **kwargs
-    ):
+    def read_to_pandas(self, f, columns=None, nrows=None, dtype_backend=None, **kwargs):
         file = pq.ParquetFile(f)
         t = file.read(columns=columns, **kwargs)
-        return self._table_to_pandas(t, nrows=nrows, use_arrow_dtype=use_arrow_dtype)
+        return self._table_to_pandas(t, nrows=nrows, dtype_backend=dtype_backend)
 
     def read_group_to_pandas(
-        self, f, group_index, columns=None, nrows=None, use_arrow_dtype=None, **kwargs
+        self, f, group_index, columns=None, nrows=None, dtype_backend=None, **kwargs
     ):
         file = pq.ParquetFile(f)
         t = file.read_row_group(group_index, columns=columns, **kwargs)
-        return self._table_to_pandas(t, nrows=nrows, use_arrow_dtype=use_arrow_dtype)
+        return self._table_to_pandas(t, nrows=nrows, dtype_backend=dtype_backend)
 
 
 class FastpaquetEngine(ParquetEngine):
@@ -203,14 +203,12 @@ class FastpaquetEngine(ParquetEngine):
         dtypes_dict = file._dtypes()
         return pd.Series(dict((c, dtypes_dict[c]) for c in file.columns))
 
-    def read_to_pandas(
-        self, f, columns=None, nrows=None, use_arrow_dtype=None, **kwargs
-    ):
+    def read_to_pandas(self, f, columns=None, nrows=None, dtype_backend=None, **kwargs):
         file = fastparquet.ParquetFile(f)
         df = file.to_pandas(columns, **kwargs)
         if nrows is not None:
             df = df.head(nrows)
-        if use_arrow_dtype:
+        if dtype_backend == "pyarrow":
             df = df.astype(to_arrow_dtypes(df.dtypes).to_dict())
         return df
 
@@ -265,29 +263,30 @@ class CudfEngine:
 class DataFrameReadParquet(
     IncrementalIndexDatasource,
     ColumnPruneSupportedDataSourceMixin,
+    DtypeBackendCompatibleMixin,
 ):
     _op_type_ = opcodes.READ_PARQUET
 
     path = AnyField("path")
     engine = StringField("engine")
     columns = ListField("columns")
-    use_arrow_dtype = BoolField("use_arrow_dtype")
-    groups_as_chunks = BoolField("groups_as_chunks")
-    group_index = Int32Field("group_index")
-    read_kwargs = DictField("read_kwargs")
-    incremental_index = BoolField("incremental_index")
-    storage_options = DictField("storage_options")
-    is_partitioned = BoolField("is_partitioned")
-    merge_small_files = BoolField("merge_small_files")
-    merge_small_file_options = DictField("merge_small_file_options")
+    dtype_backend = StringField("dtype_backend", default=None)
+    groups_as_chunks = BoolField("groups_as_chunks", default=None)
+    group_index = Int32Field("group_index", default=None)
+    read_kwargs = DictField("read_kwargs", default=None)
+    incremental_index = BoolField("incremental_index", default=None)
+    storage_options = DictField("storage_options", default=None)
+    is_partitioned = BoolField("is_partitioned", default=None)
+    merge_small_files = BoolField("merge_small_files", default=None)
+    merge_small_file_options = DictField("merge_small_file_options", default=None)
     # for chunk
     partitions = DictField("partitions", default=None)
     partition_keys = DictField("partition_keys", default=None)
     num_group_rows = Int64Field("num_group_rows", default=None)
     # as read meta may be too time-consuming when number of files is large,
     # thus we only read first file to get row number and raw file size
-    first_chunk_row_num = Int64Field("first_chunk_row_num")
-    first_chunk_raw_bytes = Int64Field("first_chunk_raw_bytes")
+    first_chunk_row_num = Int64Field("first_chunk_row_num", default=None)
+    first_chunk_raw_bytes = Int64Field("first_chunk_raw_bytes", default=None)
 
     def get_columns(self):
         return self.columns
@@ -319,7 +318,7 @@ def read_parquet(
     engine: str = "auto",
     columns: list = None,
     groups_as_chunks: bool = False,
-    use_arrow_dtype: bool = None,
+    dtype_backend: str = None,
     incremental_index: bool = False,
     storage_options: dict = None,
     memory_scale: int = None,
@@ -356,8 +355,8 @@ def read_parquet(
     incremental_index: bool, default False
         If index_col not specified, ensure range index incremental,
         gain a slightly better performance if setting False.
-    use_arrow_dtype: bool, default None
-        If True, use arrow dtype to store columns.
+    dtype_backend: {'numpy', 'pyarrow'}, default 'numpy'
+        Back-end data type applied to the resultant DataFrame (still experimental).
     storage_options: dict, optional
         Options for storage connection.
     memory_scale: int, optional
@@ -401,9 +400,9 @@ def read_parquet(
     if columns:
         dtypes = dtypes[columns]
 
-    if use_arrow_dtype is None:
-        use_arrow_dtype = options.dataframe.use_arrow_dtype
-    if use_arrow_dtype:
+    if dtype_backend is None:
+        dtype_backend = options.dataframe.dtype_backend
+    if dtype_backend == "pyarrow":
         dtypes = to_arrow_dtypes(dtypes)
 
     index_value = parse_index(pd.RangeIndex(-1))
@@ -413,7 +412,7 @@ def read_parquet(
         engine=engine_type,
         columns=columns,
         groups_as_chunks=groups_as_chunks,
-        use_arrow_dtype=use_arrow_dtype,
+        dtype_backend=dtype_backend,
         read_kwargs=kwargs,
         incremental_index=incremental_index,
         storage_options=storage_options,

maxframe/dataframe/datasource/tests/test_datasource.py

@@ -184,6 +184,23 @@ def test_from_tensor():
     df = dataframe_from_1d_tileables(d)
     pd.testing.assert_index_equal(df.columns_value.to_pandas(), pd.RangeIndex(2))
 
+    # test axis parameter for dataframe_from_1d_tileables
+    d = OrderedDict(
+        [("a", mt.tensor(np.random.rand(4))), ("b", mt.tensor(np.random.rand(4)))]
+    )
+
+    # axis=1 (default behavior) - keys become columns
+    df = dataframe_from_1d_tileables(d, axis=1)
+    assert df.shape == (4, 2)
+    pd.testing.assert_index_equal(df.columns_value.to_pandas(), pd.Index(["a", "b"]))
+    pd.testing.assert_index_equal(df.index_value.to_pandas(), pd.RangeIndex(4))
+
+    # axis=0 - keys become index (rows)
+    df = dataframe_from_1d_tileables(d, axis=0)
+    assert df.shape == (2, 4)
+    pd.testing.assert_index_equal(df.index_value.to_pandas(), pd.Index(["a", "b"]))
+    pd.testing.assert_index_equal(df.columns_value.to_pandas(), pd.RangeIndex(4))
+
     series = series_from_tensor(mt.random.rand(4))
     pd.testing.assert_index_equal(series.index_value.to_pandas(), pd.RangeIndex(4))
 
@@ -207,6 +224,26 @@ def test_from_tensor():
     with pytest.raises(ValueError):
         dataframe_from_tensor(mt.random.rand(4, 3), columns=["a", "b"])
 
+    # 1-d tensors should have same shape
+    with pytest.raises(ValueError):
+        dataframe_from_1d_tileables(
+            OrderedDict(
+                [(0, mt.tensor(np.random.rand(3))), (1, mt.tensor(np.random.rand(2)))]
+            )
+        )
+
+    # index has wrong shape
+    with pytest.raises(ValueError):
+        dataframe_from_1d_tileables(
+            {0: mt.tensor(np.random.rand(3))}, index=mt.tensor(np.random.rand(2))
+        )
+
+    # columns have wrong shape
+    with pytest.raises(ValueError):
+        dataframe_from_1d_tileables(
+            {0: mt.tensor(np.random.rand(3))}, columns=["a", "b"]
+        )
+
     # index should be 1-d
     with pytest.raises(ValueError):
         dataframe_from_tensor(

maxframe/dataframe/datastore/__init__.py

@@ -12,14 +12,24 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+from .direct import df_to_dict, series_to_dict, series_to_list, to_clipboard
+from .to_csv import to_csv
 from .to_odps import to_odps_table
 
 
 def _install():
-    from ..core import DATAFRAME_TYPE
+    from ..core import DATAFRAME_TYPE, SERIES_TYPE
 
     for t in DATAFRAME_TYPE:
+        t.to_clipboard = to_clipboard
+        t.to_csv = to_csv
+        t.to_dict = df_to_dict
         t.to_odps_table = to_odps_table
+    for t in SERIES_TYPE:
+        t.to_clipboard = to_clipboard
+        t.to_csv = to_csv
+        t.to_dict = series_to_dict
+        t.to_list = series_to_list
 
 
 _install()

maxframe/dataframe/datastore/direct.py

@@ -0,0 +1,268 @@
+# Copyright 1999-2025 Alibaba Group Holding Ltd.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from ...utils import pd_release_version
+
+_to_dict_has_index = pd_release_version[0] >= 2
+
+
+def df_to_dict(
+    df, orient="dict", into=dict, index=True, batch_size=10000, session=None
+):
+    """
+    Convert the DataFrame to a dictionary.
+
+    The type of the key-value pairs can be customized with the parameters
+    (see below).
+
+    Parameters
+    ----------
+    orient : str {'dict', 'list', 'series', 'split', 'tight', 'records', 'index'}
+        Determines the type of the values of the dictionary.
+
+        - 'dict' (default) : dict like {column -> {index -> value}}
+        - 'list' : dict like {column -> [values]}
+        - 'series' : dict like {column -> Series(values)}
+        - 'split' : dict like
+          {'index' -> [index], 'columns' -> [columns], 'data' -> [values]}
+        - 'tight' : dict like
+          {'index' -> [index], 'columns' -> [columns], 'data' -> [values],
+          'index_names' -> [index.names], 'column_names' -> [column.names]}
+        - 'records' : list like
+          [{column -> value}, ... , {column -> value}]
+        - 'index' : dict like {index -> {column -> value}}
+
+    into : class, default dict
+        The collections.abc.MutableMapping subclass used for all Mappings
+        in the return value.  Can be the actual class or an empty
+        instance of the mapping type you want.  If you want a
+        collections.defaultdict, you must pass it initialized.
+
+    index : bool, default True
+        Whether to include the index item (and index_names item if `orient`
+        is 'tight') in the returned dictionary. Can only be ``False``
+        when `orient` is 'split' or 'tight'.
+
+    Returns
+    -------
+    dict, list or collections.abc.MutableMapping
+        Return a collections.abc.MutableMapping object representing the
+        DataFrame. The resulting transformation depends on the `orient`
+        parameter.
+
+    See Also
+    --------
+    DataFrame.from_dict: Create a DataFrame from a dictionary.
+    DataFrame.to_json: Convert a DataFrame to JSON format.
+
+    Examples
+    --------
+    >>> import maxframe.dataframe as md
+    >>> df = md.DataFrame({'col1': [1, 2],
+    ...                    'col2': [0.5, 0.75]},
+    ...                   index=['row1', 'row2'])
+    >>> df.execute()
+          col1  col2
+    row1     1  0.50
+    row2     2  0.75
+    >>> df.to_dict()
+    {'col1': {'row1': 1, 'row2': 2}, 'col2': {'row1': 0.5, 'row2': 0.75}}
+
+    You can specify the return orientation.
+
+    >>> df.to_dict('series')
+    {'col1': row1    1
+             row2    2
+    Name: col1, dtype: int64,
+    'col2': row1    0.50
+            row2    0.75
+    Name: col2, dtype: float64}
+
+    >>> df.to_dict('split')
+    {'index': ['row1', 'row2'], 'columns': ['col1', 'col2'],
+     'data': [[1, 0.5], [2, 0.75]]}
+
+    >>> df.to_dict('records')
+    [{'col1': 1, 'col2': 0.5}, {'col1': 2, 'col2': 0.75}]
+
+    >>> df.to_dict('index')
+    {'row1': {'col1': 1, 'col2': 0.5}, 'row2': {'col1': 2, 'col2': 0.75}}
+
+    >>> df.to_dict('tight')
+    {'index': ['row1', 'row2'], 'columns': ['col1', 'col2'],
+     'data': [[1, 0.5], [2, 0.75]], 'index_names': [None], 'column_names': [None]}
+
+    You can also specify the mapping type.
+
+    >>> from collections import OrderedDict, defaultdict
+    >>> df.to_dict(into=OrderedDict)
+    OrderedDict([('col1', OrderedDict([('row1', 1), ('row2', 2)])),
+                 ('col2', OrderedDict([('row1', 0.5), ('row2', 0.75)]))])
+
+    If you want a `defaultdict`, you need to initialize it:
+
+    >>> dd = defaultdict(list)
+    >>> df.to_dict('records', into=dd)
+    [defaultdict(<class 'list'>, {'col1': 1, 'col2': 0.5}),
+     defaultdict(<class 'list'>, {'col1': 2, 'col2': 0.75})]
+    """
+    fetch_kwargs = dict(batch_size=batch_size)
+    to_dict_kw = dict(orient=orient, into=into)
+    if _to_dict_has_index:
+        to_dict_kw["index"] = index
+    return df.to_pandas(session=session, fetch_kwargs=fetch_kwargs).to_dict(
+        **to_dict_kw
+    )
+
+
+def series_to_dict(series, into=dict, batch_size=10000, session=None):
+    """
+    Convert Series to {label -> value} dict or dict-like object.
+
+    Parameters
+    ----------
+    into : class, default dict
+        The collections.abc.Mapping subclass to use as the return
+        object. Can be the actual class or an empty
+        instance of the mapping type you want.  If you want a
+        collections.defaultdict, you must pass it initialized.
+
+    Returns
+    -------
+    collections.abc.Mapping
+        Key-value representation of Series.
+
+    Examples
+    --------
+    >>> import maxframe.dataframe as md
+    >>> s = md.Series([1, 2, 3, 4])
+    >>> s.to_dict()
+    {0: 1, 1: 2, 2: 3, 3: 4}
+    >>> from collections import OrderedDict, defaultdict
+    >>> s.to_dict(OrderedDict)
+    OrderedDict([(0, 1), (1, 2), (2, 3), (3, 4)])
+    >>> dd = defaultdict(list)
+    >>> s.to_dict(dd)
+    defaultdict(<class 'list'>, {0: 1, 1: 2, 2: 3, 3: 4})
+    """
+    fetch_kwargs = dict(batch_size=batch_size)
+    return series.to_pandas(session=session, fetch_kwargs=fetch_kwargs).to_dict(
+        into=into
+    )
+
+
+def series_to_list(series, batch_size=10000, session=None):
+    """
+    Return a list of the values.
+
+    These are each a scalar type, which is a Python scalar
+    (for str, int, float) or a pandas scalar
+    (for Timestamp/Timedelta/Interval/Period)
+
+    Returns
+    -------
+    list
+
+    See Also
+    --------
+    numpy.ndarray.tolist : Return the array as an a.ndim-levels deep
+        nested list of Python scalars.
+
+    Examples
+    --------
+    For Series
+
+    >>> import maxframe.dataframe as md
+    >>> s = md.Series([1, 2, 3])
+    >>> s.to_list()
+    [1, 2, 3]
+
+    For Index:
+
+    >>> idx = md.Index([1, 2, 3])
+    >>> idx.execute()
+    Index([1, 2, 3], dtype='int64')
+
+    >>> idx.to_list()
+    [1, 2, 3]
+    """
+    fetch_kwargs = dict(batch_size=batch_size)
+    return series.to_pandas(session=session, fetch_kwargs=fetch_kwargs).to_list()
+
+
+def to_clipboard(
+    obj, *, excel=True, sep=None, batch_size=10000, session=None, **kwargs
+):
+    """
+    Copy object to the system clipboard.
+
+    Write a text representation of object to the system clipboard.
+    This can be pasted into Excel, for example.
+
+    Parameters
+    ----------
+    excel : bool, default True
+        Produce output in a csv format for easy pasting into excel.
+
+        - True, use the provided separator for csv pasting.
+        - False, write a string representation of the object to the clipboard.
+
+    sep : str, default ``'\t'``
+        Field delimiter.
+    **kwargs
+        These parameters will be passed to DataFrame.to_csv.
+
+    See Also
+    --------
+    DataFrame.to_csv : Write a DataFrame to a comma-separated values
+        (csv) file.
+    read_clipboard : Read text from clipboard and pass to read_csv.
+
+    Notes
+    -----
+    Requirements for your platform.
+
+      - Linux : `xclip`, or `xsel` (with `PyQt4` modules)
+      - Windows : none
+      - macOS : none
+
+    This method uses the processes developed for the package `pyperclip`. A
+    solution to render any output string format is given in the examples.
+
+    Examples
+    --------
+    Copy the contents of a DataFrame to the clipboard.
+
+    >>> import maxframe.dataframe as md
+    >>> df = md.DataFrame([[1, 2, 3], [4, 5, 6]], columns=['A', 'B', 'C'])
+
+    >>> df.to_clipboard(sep=',')  # doctest: +SKIP
+    ... # Wrote the following to the system clipboard:
+    ... # ,A,B,C
+    ... # 0,1,2,3
+    ... # 1,4,5,6
+
+    We can omit the index by passing the keyword `index` and setting
+    it to false.
+
+    >>> df.to_clipboard(sep=',', index=False)  # doctest: +SKIP
+    ... # Wrote the following to the system clipboard:
+    ... # A,B,C
+    ... # 1,2,3
+    ... # 4,5,6
+    """
+    fetch_kwargs = dict(batch_size=batch_size)
+    return obj.to_pandas(session=session, fetch_kwargs=fetch_kwargs).to_clipboard(
+        excel=excel, sep=sep, **kwargs
+    )