maxframe 2.4.0rc1__cp312-cp312-win32.whl

maxframe/io/odpsio/arrow.py

@@ -0,0 +1,161 @@
+# 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 typing import Any, Tuple, Union
+
+import numpy as np
+import pandas as pd
+import pyarrow as pa
+
+from ...core import OutputType
+from ...lib.version import parse as parse_version
+from ...protocol import DataFrameTableMeta
+from ...tensor.core import TENSOR_TYPE
+from ...typing_ import ArrowTableType, PandasObjectTypes
+from .schema import (
+    arrow_table_to_pandas_dataframe,
+    build_dataframe_table_meta,
+    pandas_dataframe_to_arrow_table,
+)
+
+
+def _rebuild_dataframe(
+    df: pd.DataFrame, table_meta: DataFrameTableMeta
+) -> Union[pd.DataFrame, pd.Series]:
+    indexed = df.set_index(list(table_meta.table_index_column_names))
+    indexed.index.set_names(table_meta.pd_index_level_names, inplace=True)
+    if len(table_meta.pd_column_level_names) == 1:
+        cols = pd.Index(
+            table_meta.pd_column_names, name=table_meta.pd_column_level_names[0]
+        )
+    else:
+        cols = pd.MultiIndex.from_tuples(table_meta.pd_column_names).set_names(
+            table_meta.pd_column_level_names
+        )
+    indexed.columns = cols
+    if table_meta.type == OutputType.series:
+        return indexed.iloc[:, 0]
+    return indexed
+
+
+def _rebuild_index(df: pd.DataFrame, table_meta: DataFrameTableMeta) -> pd.Index:
+    if df.shape[1] > 1:
+        idx = pd.MultiIndex.from_frame(df)
+        idx.names = table_meta.pd_index_level_names
+    else:
+        # make sure even if None names are updated properly
+        idx = pd.Index(df.iloc[:, 0])
+        idx.name = table_meta.pd_index_level_names[0]
+    return idx
+
+
+def arrow_to_pandas(
+    arrow_table: ArrowTableType, table_meta: DataFrameTableMeta
+) -> PandasObjectTypes:
+    df = arrow_table_to_pandas_dataframe(arrow_table, table_meta)
+    if table_meta.type in (OutputType.dataframe, OutputType.series):
+        return _rebuild_dataframe(df, table_meta)
+    elif table_meta.type == OutputType.index:
+        return _rebuild_index(df, table_meta)
+    elif table_meta.type == OutputType.tensor:
+        return _rebuild_index(df, table_meta).to_numpy()
+    elif table_meta.type == OutputType.scalar:
+        return _rebuild_index(df, table_meta)[0]
+    else:  # this could never happen  # pragma: no cover
+        raise ValueError(f"Does not support meta type {table_meta.type!r}")
+
+
+def pandas_to_arrow(
+    df: Any, nthreads=1, ignore_index=False, ms_cols=None
+) -> Tuple[ArrowTableType, DataFrameTableMeta]:
+    table_meta = build_dataframe_table_meta(df, ignore_index)
+    df = df.copy() if callable(getattr(df, "copy", None)) else df
+    table_datetime_cols = None
+    if table_meta.type in (OutputType.dataframe, OutputType.series):
+        if table_meta.type == OutputType.series:
+            df = df.to_frame("_data" if df.name is None else df.name)
+            if ms_cols:
+                table_datetime_cols = {"_data"}
+        elif ms_cols:
+            ms_col_set = set(ms_cols)
+            table_datetime_cols = set()
+            for pd_col, table_col in zip(
+                table_meta.pd_column_dtypes.keys(), table_meta.table_column_names
+            ):
+                if pd_col in ms_col_set:
+                    table_datetime_cols.add(table_col)
+        df.columns = pd.Index(table_meta.table_column_names)
+        if not ignore_index:
+            df = df.rename_axis(table_meta.table_index_column_names).reset_index()
+    elif ignore_index and table_meta.type != OutputType.index:
+        df = pd.DataFrame([], columns=[])
+    elif table_meta.type == OutputType.index:
+        names = [f"_idx_{idx}" for idx in range(len(df.names))]
+        table_datetime_cols = set()
+        if ms_cols:
+            if isinstance(df, pd.MultiIndex):
+                table_datetime_cols = {f"_idx_{idx}" for idx in ms_cols}
+            else:
+                table_datetime_cols = {"_idx_0"}
+        df = df.to_frame(name=names[0] if len(names) == 1 else names)
+    elif table_meta.type in (OutputType.scalar, OutputType.tensor):
+        names = ["_idx_0"]
+        if isinstance(df, (TENSOR_TYPE, np.ndarray)):
+            df = pd.DataFrame([], columns=names).astype({names[0]: df.dtype})
+        else:
+            df = pd.DataFrame([[df]], columns=names)
+    else:  # this could never happen  # pragma: no cover
+        raise ValueError(f"Does not support meta type {table_meta.type!r}")
+
+    try:
+        pa_table = pandas_dataframe_to_arrow_table(df, nthreads=nthreads)
+    except pa.ArrowTypeError as ex:  # pragma: no cover
+        late_np_version = parse_version(np.__version__) >= parse_version("1.20")
+        early_pa_version = parse_version(pa.__version__) <= parse_version("4.0")
+        if (
+            late_np_version
+            and early_pa_version
+            and "Did not pass numpy.dtype object" in str(ex)
+        ):
+            raise TypeError(
+                "Potential dependency conflict. Try update to pyarrow>4.0 "
+                "or downgrade to numpy<1.20. Details can be seen at "
+                "https://github.com/numpy/numpy/issues/17913. "
+                f"Raw error message: {ex!r}"
+            ).with_traceback(ex.__traceback__) from None
+        else:
+            raise
+
+    if table_datetime_cols:
+        col_names = pa_table.schema.names
+        col_datas = []
+        for idx, col_name in enumerate(pa_table.schema.names):
+            if col_name not in table_datetime_cols:
+                col_datas.append(pa_table.column(idx))
+                continue
+            col_data = pa_table.column(idx).cast(pa.timestamp("ms"))
+            col_datas.append(col_data)
+        pa_table = pa.Table.from_arrays(col_datas, names=col_names)
+
+        new_names, new_dtypes = [], []
+        for table_col, (pd_col, pd_dtype) in zip(
+            table_meta.table_column_names, table_meta.pd_column_dtypes.items()
+        ):
+            new_names.append(pd_col)
+            if table_col not in table_datetime_cols:
+                new_dtypes.append(pd_dtype)
+            else:
+                new_dtypes.append(np.dtype("datetime64[ms]"))
+        table_meta.pd_column_dtypes = pd.Series(new_dtypes, index=new_names)
+    return pa_table, table_meta

maxframe/io/odpsio/schema.py

@@ -0,0 +1,533 @@
+# 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.
+
+import string
+from collections import defaultdict
+from typing import Any, Dict, Tuple
+
+import numpy as np
+import pandas as pd
+import pyarrow as pa
+from odps import types as odps_types
+from pandas.api import types as pd_types
+
+from ...config import options
+from ...core import TILEABLE_TYPE, OutputType
+from ...dataframe.core import DATAFRAME_TYPE, INDEX_TYPE, SERIES_TYPE
+from ...lib.dtypes_extension import ArrowBlobType, ArrowDtype
+from ...protocol import DataFrameTableMeta
+from ...tensor.core import TENSOR_TYPE
+from ...utils import build_temp_table_name
+
+_TEMP_TABLE_PREFIX = "tmp_mf_"
+DEFAULT_SINGLE_INDEX_NAME = "_idx_0"
+
+_arrow_to_odps_types = {
+    pa.string(): odps_types.string,
+    pa.binary(): odps_types.binary,
+    pa.int8(): odps_types.tinyint,
+    pa.int16(): odps_types.smallint,
+    pa.int32(): odps_types.int_,
+    pa.int64(): odps_types.bigint,
+    pa.bool_(): odps_types.boolean,
+    pa.float32(): odps_types.float_,
+    pa.float64(): odps_types.double,
+    pa.date32(): odps_types.date,
+    pa.timestamp("ms"): odps_types.datetime,
+    pa.timestamp("us"): odps_types.timestamp,
+    pa.timestamp("ns"): odps_types.timestamp,
+}
+
+_odps_type_to_arrow = {
+    odps_types.string: pa.string(),
+    odps_types.binary: pa.binary(),
+    odps_types.tinyint: pa.int8(),
+    odps_types.smallint: pa.int16(),
+    odps_types.int_: pa.int32(),
+    odps_types.bigint: pa.int64(),
+    odps_types.boolean: pa.bool_(),
+    odps_types.float_: pa.float32(),
+    odps_types.double: pa.float64(),
+    odps_types.date: pa.date32(),
+    odps_types.datetime: pa.timestamp("ms"),
+    odps_types.json: pa.string(),
+    odps_types.timestamp: pa.timestamp("ns"),
+    odps_types.timestamp_ntz: pa.timestamp("ns"),
+}
+
+_int_to_pd_dtype = {
+    np.dtype("int8"): pd.Int8Dtype(),
+    np.dtype("int16"): pd.Int16Dtype(),
+    np.dtype("int32"): pd.Int32Dtype(),
+    np.dtype("int64"): pd.Int64Dtype(),
+    np.dtype("uint8"): pd.UInt8Dtype(),
+    np.dtype("uint16"): pd.UInt16Dtype(),
+    np.dtype("uint32"): pd.UInt32Dtype(),
+    np.dtype("uint64"): pd.UInt64Dtype(),
+}
+
+if hasattr(odps_types, "blob"):
+    _arrow_to_odps_types[ArrowBlobType()] = odps_types.blob
+    _odps_type_to_arrow[odps_types.blob] = ArrowBlobType()
+
+_based_for_pandas_pa_types = (pa.ListType, pa.MapType, pa.StructType)
+
+
+def cast_df_with_possible_nans(
+    df_obj: pd.DataFrame, dtypes: pd.Series, try_cast_back: bool = True
+) -> pd.DataFrame:
+    # align types to cast with existing dataframe
+    new_dtypes = df_obj.dtypes.copy()
+    new_dtypes.update(dtypes)
+    res = df_obj.astype(new_dtypes.replace(_int_to_pd_dtype))
+    if not try_cast_back:
+        return res
+
+    to_cast = {}
+    for idx, col_dtype in enumerate(new_dtypes):
+        if col_dtype in _int_to_pd_dtype and not res.iloc[:, idx].isna().any():
+            to_cast[idx] = col_dtype
+    if to_cast:
+        # in case there is duplications, only cast on integer indexes
+        res.columns, cols = range(len(res.columns)), res.columns
+        res = res.astype(to_cast)
+        res.columns = cols
+    return res
+
+
+def is_based_for_pandas_dtype(arrow_type: pa.DataType) -> bool:
+    """
+    Check whether the arrow type is based for one pandas data type.
+    If true, we should make sure the environment support ArrowDtype.
+    """
+    if not isinstance(arrow_type, _based_for_pandas_pa_types):
+        return False
+
+    if ArrowDtype is None:
+        raise ImportError("ArrowDtype is not supported in current environment")
+    return True
+
+
+def pandas_types_to_arrow_schema(df_obj: pd.DataFrame) -> pa.Schema:
+    """
+    This one is only called when a pandas DataFrame is written to ODPS. So we can check
+    whether the ArrowDtype is supported.
+    """
+    schema = pa.Schema.from_pandas(df_obj, preserve_index=False)
+    names, types = schema.names, schema.types
+    for idx, col_dtype in enumerate(df_obj.dtypes.tolist()):
+        if ArrowDtype is not None and isinstance(col_dtype, ArrowDtype):
+            types[idx] = col_dtype.pyarrow_dtype
+        elif isinstance(col_dtype, pd.StringDtype):
+            # as ODPS does not support large_string, we use string instead
+            types[idx] = pa.string()
+    return pa.schema([pa.field(name, typ) for name, typ in zip(names, types)])
+
+
+def arrow_type_to_odps_type(
+    arrow_type: pa.DataType, col_name: str, unknown_as_string: bool = False
+) -> odps_types.DataType:
+    if arrow_type in _arrow_to_odps_types:
+        return _arrow_to_odps_types[arrow_type]
+    elif isinstance(arrow_type, pa.ListType):
+        return odps_types.Array(
+            arrow_type_to_odps_type(arrow_type.value_type, col_name, unknown_as_string)
+        )
+    elif isinstance(arrow_type, pa.MapType):
+        return odps_types.Map(
+            arrow_type_to_odps_type(arrow_type.key_type, col_name, unknown_as_string),
+            arrow_type_to_odps_type(arrow_type.item_type, col_name, unknown_as_string),
+        )
+    elif isinstance(arrow_type, pa.StructType):
+        type_dict = {}
+        for idx in range(arrow_type.num_fields):
+            field = arrow_type[idx]
+            type_dict[field.name] = arrow_type_to_odps_type(
+                field.type, col_name, unknown_as_string
+            )
+        return odps_types.Struct(type_dict)
+    elif isinstance(arrow_type, pa.Decimal128Type):
+        return odps_types.Decimal(arrow_type.precision, arrow_type.scale)
+
+    if unknown_as_string:
+        return odps_types.string
+    else:
+        raise TypeError(
+            "Unknown type {}, column name is {},"
+            "specify `unknown_as_string=True` "
+            "or `as_type` to set column dtype".format(arrow_type, col_name)
+        )
+
+
+def arrow_schema_to_odps_schema(
+    arrow_schema: pa.Schema, unknown_as_string: bool = False
+) -> odps_types.OdpsSchema:
+    odps_cols = []
+    for col_name, col_type in zip(arrow_schema.names, arrow_schema.types):
+        col_odps_type = arrow_type_to_odps_type(
+            col_type, col_name, unknown_as_string=unknown_as_string
+        )
+        odps_cols.append(odps_types.Column(col_name, col_odps_type))
+
+    return odps_types.OdpsSchema(odps_cols)
+
+
+def odps_type_to_arrow_type(
+    odps_type: odps_types.DataType, col_name: str
+) -> pa.DataType:
+    if odps_type in _odps_type_to_arrow:
+        col_type = _odps_type_to_arrow[odps_type]
+    else:
+        if isinstance(odps_type, odps_types.Array):
+            col_type = pa.list_(odps_type_to_arrow_type(odps_type.value_type, col_name))
+        elif isinstance(odps_type, odps_types.Map):
+            col_type = pa.map_(
+                odps_type_to_arrow_type(odps_type.key_type, col_name),
+                odps_type_to_arrow_type(odps_type.value_type, col_name),
+            )
+        elif isinstance(odps_type, odps_types.Struct):
+            fields = [
+                (k, odps_type_to_arrow_type(v, col_name))
+                for k, v in odps_type.field_types.items()
+            ]
+            col_type = pa.struct(fields)
+        elif isinstance(odps_type, odps_types.Decimal):
+            if odps_type.name == "decimal":
+                # legacy decimal data without precision or scale
+                # precision data from internal compat mode
+                col_type = pa.decimal128(38, 18)
+            else:
+                col_type = pa.decimal128(
+                    odps_type.precision or odps_types.Decimal._max_precision,
+                    odps_type.scale or odps_types.Decimal._max_scale,
+                )
+        elif isinstance(odps_type, (odps_types.Varchar, odps_types.Char)):
+            col_type = pa.string()
+        else:
+            raise TypeError(
+                "Unsupported type {}, column name is {}".format(odps_type, col_name)
+            )
+    return col_type
+
+
+def odps_schema_to_arrow_schema(
+    odps_schema: odps_types.OdpsSchema, with_partitions: bool = False
+) -> pa.Schema:
+    arrow_schema = []
+    cols = odps_schema.columns if with_partitions else odps_schema.simple_columns
+    for col in cols:
+        col_name = col.name
+        col_type = odps_type_to_arrow_type(col.type, col_name)
+        arrow_schema.append(pa.field(col_name, col_type))
+
+    return pa.schema(arrow_schema)
+
+
+def odps_schema_to_pandas_dtypes(
+    odps_schema: odps_types.OdpsSchema, with_partitions: bool = False
+) -> pd.Series:
+    arrow_schema = odps_schema_to_arrow_schema(
+        odps_schema, with_partitions=with_partitions
+    )
+    return arrow_table_to_pandas_dataframe(arrow_schema.empty_table()).dtypes
+
+
+def arrow_table_to_pandas_dataframe(
+    table: pa.Table, meta: DataFrameTableMeta = None
+) -> pd.DataFrame:
+    use_arrow_backend = options.dataframe.dtype_backend == "pyarrow"
+    df = table.to_pandas(
+        types_mapper=lambda x: (
+            ArrowDtype(x) if is_based_for_pandas_dtype(x) or use_arrow_backend else None
+        ),
+        ignore_metadata=True,
+    )
+    if not meta:
+        return df
+
+    # If meta is passed, we should convert the dtypes to match the ones in the meta
+    converted_column_dtypes = dict()
+    for source_dtype, target_col, target_dtype in zip(
+        df.dtypes.values,
+        df.columns,
+        list(meta.pd_index_dtypes.values) + list(meta.pd_column_dtypes.values),
+    ):
+        if source_dtype != target_dtype:
+            # Converting tz-aware dtype to tz-native dtype is a special case.
+            # In numpy1.19, we can't use numpy.dtype.DateTime64Dtype
+            if (
+                isinstance(source_dtype, pd.DatetimeTZDtype)
+                and isinstance(target_dtype, np.dtype)
+                and target_dtype.name.startswith("datetime64")
+            ):
+                df[target_col] = df[target_col].dt.tz_localize(None)
+            else:
+                converted_column_dtypes[target_col] = target_dtype
+
+    if converted_column_dtypes:
+        df = cast_df_with_possible_nans(df, converted_column_dtypes)
+
+    return df
+
+
+def pandas_dataframe_to_arrow_table(df: pd.DataFrame, nthreads=1) -> pa.Table:
+    schema = pandas_types_to_arrow_schema(df)
+    return pa.Table.from_pandas(
+        df, schema=schema, nthreads=nthreads, preserve_index=False
+    )
+
+
+def pandas_dtypes_to_arrow_schema(dtypes, unknown_as_string: bool = False) -> pa.Schema:
+    if unknown_as_string:
+        dt_list = [dt if dt != np.dtype("O") else pd.StringDtype() for dt in dtypes]
+        dtypes = pd.Series(dt_list, index=dtypes.index)
+    schema = pandas_types_to_arrow_schema(
+        pd.DataFrame([], columns=dtypes.index).astype(dtypes)
+    )
+    return schema
+
+
+def pandas_dtype_to_arrow_type(dtype, unknown_as_string: bool = False) -> pa.DataType:
+    if unknown_as_string and dtype == np.dtype("O"):
+        dtype = pd.StringDtype()
+    schema = pandas_types_to_arrow_schema(
+        pd.DataFrame([], columns=["a"]).astype({"a": dtype})
+    )
+    return schema.types[0]
+
+
+def is_scalar_object(df_obj: Any) -> bool:
+    return (
+        isinstance(df_obj, TENSOR_TYPE) and df_obj.shape == ()
+    ) or pd_types.is_scalar(df_obj)
+
+
+def is_tensor_object(df_obj: Any) -> bool:
+    return (
+        isinstance(df_obj, TENSOR_TYPE) or isinstance(df_obj, np.ndarray)
+    ) and df_obj.ndim <= 1
+
+
+def _scalar_as_index(df_obj: Any) -> pd.Index:
+    if isinstance(df_obj, TILEABLE_TYPE):
+        return pd.Index([], dtype=df_obj.dtype)
+    else:
+        return pd.Index([df_obj])[:0]
+
+
+def pandas_to_odps_schema(
+    df_obj: Any,
+    unknown_as_string: bool = False,
+    ignore_index=False,
+) -> Tuple[odps_types.OdpsSchema, DataFrameTableMeta]:
+    from ... import dataframe as md
+    from .arrow import pandas_to_arrow
+
+    if is_scalar_object(df_obj) or is_tensor_object(df_obj):
+        empty_index = None
+    elif hasattr(df_obj, "index_value"):
+        empty_index = df_obj.index_value.to_pandas()[:0]
+    elif not isinstance(df_obj, pd.Index):
+        empty_index = df_obj.index[:0]
+    else:
+        empty_index = df_obj[:0]
+
+    if hasattr(df_obj, "columns_value"):
+        empty_columns = df_obj.dtypes.index
+    elif hasattr(df_obj, "columns"):
+        empty_columns = df_obj.columns
+    else:
+        empty_columns = None
+
+    ms_cols = None
+    if isinstance(df_obj, (md.DataFrame, pd.DataFrame)):
+        empty_df_obj = pd.DataFrame(
+            [], columns=empty_columns, index=empty_index
+        ).astype(df_obj.dtypes)
+        ms_cols = [
+            col for col, dt in df_obj.dtypes.items() if dt == np.dtype("datetime64[ms]")
+        ]
+    elif isinstance(df_obj, (md.Series, pd.Series)):
+        empty_df_obj = pd.Series([], name=df_obj.name, index=empty_index).astype(
+            df_obj.dtype
+        )
+        ms_cols = df_obj.dtype == np.dtype("datetime64[ms]")
+    elif isinstance(df_obj, (md.Index, pd.Index)):
+        empty_df_obj = empty_index
+        if isinstance(empty_index, pd.MultiIndex):
+            ms_cols = [
+                idx
+                for idx, dt in enumerate(empty_index.dtypes.values)
+                if dt == np.dtype("datetime64[ms]")
+            ]
+        else:
+            ms_cols = df_obj.dtype == np.dtype("datetime64[ms]")
+    else:
+        empty_df_obj = df_obj
+
+    arrow_data, table_meta = pandas_to_arrow(
+        empty_df_obj, ignore_index=ignore_index, ms_cols=ms_cols
+    )
+    return (
+        arrow_schema_to_odps_schema(
+            arrow_data.schema, unknown_as_string=unknown_as_string
+        ),
+        table_meta,
+    )
+
+
+def build_table_column_name(
+    col_idx: int, pd_col_name: Any, records: Dict[str, str]
+) -> str:
+    """
+    Convert column name to MaxCompute acceptable names
+
+    Parameters
+    ----------
+    col_idx:
+        index of the column
+    pd_col_name:
+        column name in pandas
+    records:
+        record for existing columns
+
+    Returns
+    -------
+        converted column name
+    """
+
+    def _is_col_name_legal(name: str):
+        if len(name) < 1 or len(name) > 128:
+            return False
+        if name[0] not in string.ascii_letters and name[0] != "_":
+            return False
+        for ch in name:
+            if ch not in string.digits and ch not in string.ascii_letters and ch != "_":
+                return False
+        return True
+
+    try:
+        return records[pd_col_name]
+    except KeyError:
+        pass
+
+    if isinstance(pd_col_name, str):
+        col_name = pd_col_name
+    elif isinstance(pd_col_name, tuple):
+        col_name = "_".join(str(x) for x in pd_col_name)
+    else:
+        col_name = str(pd_col_name)
+
+    col_name = col_name.lower()
+    if not _is_col_name_legal(col_name):
+        col_name = f"_column_{col_idx}"
+
+    records[pd_col_name] = col_name
+    return col_name
+
+
+def build_dataframe_table_meta(
+    df_obj: Any, ignore_index: bool = False, session_id: str = None
+) -> DataFrameTableMeta:
+    col_to_count = defaultdict(lambda: 0)
+    col_to_idx = defaultdict(lambda: 0)
+    pd_col_to_col_name = dict()
+    if isinstance(df_obj, (DATAFRAME_TYPE, pd.DataFrame)):
+        obj_type = OutputType.dataframe
+    elif isinstance(df_obj, (SERIES_TYPE, pd.Series)):
+        obj_type = OutputType.series
+    elif isinstance(df_obj, (INDEX_TYPE, pd.Index)):
+        obj_type = OutputType.index
+    elif is_tensor_object(df_obj) and df_obj.ndim == 1:
+        obj_type = OutputType.tensor
+    elif is_scalar_object(df_obj):
+        obj_type = OutputType.scalar
+    else:  # pragma: no cover
+        raise TypeError(f"Cannot accept type {type(df_obj)}")
+
+    if obj_type in (OutputType.scalar, OutputType.tensor):
+        pd_dtypes = pd.Series([])
+        column_index_names = []
+        index_obj = _scalar_as_index(df_obj)
+    elif obj_type == OutputType.index:
+        pd_dtypes = pd.Series([])
+        column_index_names = []
+        index_obj = df_obj
+    elif obj_type == OutputType.series:
+        pd_dtypes = pd.Series([df_obj.dtype], index=[df_obj.name])
+        column_index_names = [None]
+        index_obj = df_obj.index
+    else:
+        pd_dtypes = df_obj.dtypes
+        column_index_names = list(pd_dtypes.index.names)
+        index_obj = df_obj.index
+
+    if isinstance(df_obj, TILEABLE_TYPE):
+        if not session_id:
+            table_name = _TEMP_TABLE_PREFIX + str(df_obj.key)
+        else:
+            table_name = build_temp_table_name(session_id, df_obj.key)
+    else:
+        table_name = None
+
+    sql_columns = [None] * len(pd_dtypes)
+    pd_col_names = pd_dtypes.index
+    if obj_type == OutputType.series and df_obj.name is None:
+        # use special table column name for series
+        pd_col_names = ["_data"]
+    for idx, col in enumerate(pd_col_names):
+        sql_columns[idx] = col_name = build_table_column_name(
+            idx, col, pd_col_to_col_name
+        )
+        col_to_count[col_name] += 1
+
+    final_sql_columns = []
+    for col in sql_columns:
+        if col_to_count[col] > 1:
+            col_name = f"{col}_{col_to_idx[col]}"
+            col_to_idx[col] += 1
+            while col_name in col_to_count:
+                col_name = f"{col}_{col_to_idx[col]}"
+                col_to_idx[col] += 1
+            final_sql_columns.append(col_name)
+        else:
+            final_sql_columns.append(col)
+
+    if hasattr(index_obj, "index_value"):
+        pd_index_val = index_obj.index_value.to_pandas()
+    else:
+        pd_index_val = index_obj
+
+    level_dtypes = [
+        pd_index_val.get_level_values(level).dtype
+        for level in range(pd_index_val.nlevels)
+    ]
+    index_dtypes = pd.Series(level_dtypes, index=pd_index_val.names)
+
+    if ignore_index and obj_type != OutputType.index:
+        table_index_column_names = []
+        pd_index_dtypes = pd.Series([], index=[])
+    else:
+        table_index_column_names = [f"_idx_{i}" for i in range(len(index_obj.names))]
+        pd_index_dtypes = index_dtypes
+
+    return DataFrameTableMeta(
+        table_name=table_name,
+        type=obj_type,
+        table_column_names=final_sql_columns,
+        table_index_column_names=table_index_column_names,
+        pd_column_dtypes=pd_dtypes,
+        pd_column_level_names=column_index_names,
+        pd_index_dtypes=pd_index_dtypes,
+    )