admin/llgo
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
ba61b42ef5bced6fe1bdb87efac713b925f0e6ca
llgo/py/pandas/gen.go
xushiwei c1927c985a pysig.Parse; py/pandas
2024-05-17 05:25:13 +08:00

7352 lines
235 KiB
Go
Raw Blame History

package pandas
import (
_ "unsafe"
"github.com/goplus/llgo/py"
)
const LLGoPackage = "py.pandas"
// Detect missing values for an array-like object.
//
// This function takes a scalar or array-like object and indicates
// whether values are missing (“NaN“ in numeric arrays, “None“ or “NaN“
// in object arrays, “NaT“ in datetimelike).
//
// Parameters
// ----------
// obj : scalar or array-like
//
// Object to check for null or missing values.
//
// Returns
// -------
// bool or array-like of bool
//
// For scalar input, returns a scalar boolean.
// For array input, returns an array of boolean indicating whether each
// corresponding element is missing.
//
// See Also
// --------
// notna : Boolean inverse of pandas.isna.
// Series.isna : Detect missing values in a Series.
// DataFrame.isna : Detect missing values in a DataFrame.
// Index.isna : Detect missing values in an Index.
//
// Examples
// --------
// Scalar arguments (including strings) result in a scalar boolean.
//
// >>> pd.isna('dog')
// False
//
// >>> pd.isna(pd.NA)
// True
//
// >>> pd.isna(np.nan)
// True
//
// ndarrays result in an ndarray of booleans.
//
// >>> array = np.array([[1, np.nan, 3], [4, 5, np.nan]])
// >>> array
// array([[ 1., nan, 3.],
//
// [ 4., 5., nan]])
//
// >>> pd.isna(array)
// array([[False, True, False],
//
// [False, False, True]])
//
// For indexes, an ndarray of booleans is returned.
//
// >>> index = pd.DatetimeIndex(["2017-07-05", "2017-07-06", None,
// ... "2017-07-08"])
// >>> index
// DatetimeIndex(['2017-07-05', '2017-07-06', 'NaT', '2017-07-08'],
//
// dtype='datetime64[ns]', freq=None)
//
// >>> pd.isna(index)
// array([False, False, True, False])
//
// For Series and DataFrame, the same type is returned, containing booleans.
//
// >>> df = pd.DataFrame([['ant', 'bee', 'cat'], ['dog', None, 'fly']])
// >>> df
//
// 0 1 2
//
// 0 ant bee cat
// 1 dog None fly
// >>> pd.isna(df)
//
// 0 1 2
//
// 0 False False False
// 1 False True False
//
// >>> pd.isna(df[1])
// 0 False
// 1 True
// Name: 1, dtype: bool
//
//go:linkname Isna py.isna
func Isna(obj *py.Object) *py.Object
// Detect missing values for an array-like object.
//
// This function takes a scalar or array-like object and indicates
// whether values are missing (“NaN“ in numeric arrays, “None“ or “NaN“
// in object arrays, “NaT“ in datetimelike).
//
// Parameters
// ----------
// obj : scalar or array-like
//
// Object to check for null or missing values.
//
// Returns
// -------
// bool or array-like of bool
//
// For scalar input, returns a scalar boolean.
// For array input, returns an array of boolean indicating whether each
// corresponding element is missing.
//
// See Also
// --------
// notna : Boolean inverse of pandas.isna.
// Series.isna : Detect missing values in a Series.
// DataFrame.isna : Detect missing values in a DataFrame.
// Index.isna : Detect missing values in an Index.
//
// Examples
// --------
// Scalar arguments (including strings) result in a scalar boolean.
//
// >>> pd.isna('dog')
// False
//
// >>> pd.isna(pd.NA)
// True
//
// >>> pd.isna(np.nan)
// True
//
// ndarrays result in an ndarray of booleans.
//
// >>> array = np.array([[1, np.nan, 3], [4, 5, np.nan]])
// >>> array
// array([[ 1., nan, 3.],
//
// [ 4., 5., nan]])
//
// >>> pd.isna(array)
// array([[False, True, False],
//
// [False, False, True]])
//
// For indexes, an ndarray of booleans is returned.
//
// >>> index = pd.DatetimeIndex(["2017-07-05", "2017-07-06", None,
// ... "2017-07-08"])
// >>> index
// DatetimeIndex(['2017-07-05', '2017-07-06', 'NaT', '2017-07-08'],
//
// dtype='datetime64[ns]', freq=None)
//
// >>> pd.isna(index)
// array([False, False, True, False])
//
// For Series and DataFrame, the same type is returned, containing booleans.
//
// >>> df = pd.DataFrame([['ant', 'bee', 'cat'], ['dog', None, 'fly']])
// >>> df
//
// 0 1 2
//
// 0 ant bee cat
// 1 dog None fly
// >>> pd.isna(df)
//
// 0 1 2
//
// 0 False False False
// 1 False True False
//
// >>> pd.isna(df[1])
// 0 False
// 1 True
// Name: 1, dtype: bool
//
//go:linkname Isnull py.isnull
func Isnull(obj *py.Object) *py.Object
// Detect non-missing values for an array-like object.
//
// This function takes a scalar or array-like object and indicates
// whether values are valid (not missing, which is “NaN“ in numeric
// arrays, “None“ or “NaN“ in object arrays, “NaT“ in datetimelike).
//
// Parameters
// ----------
// obj : array-like or object value
//
// Object to check for *not* null or *non*-missing values.
//
// Returns
// -------
// bool or array-like of bool
//
// For scalar input, returns a scalar boolean.
// For array input, returns an array of boolean indicating whether each
// corresponding element is valid.
//
// See Also
// --------
// isna : Boolean inverse of pandas.notna.
// Series.notna : Detect valid values in a Series.
// DataFrame.notna : Detect valid values in a DataFrame.
// Index.notna : Detect valid values in an Index.
//
// Examples
// --------
// Scalar arguments (including strings) result in a scalar boolean.
//
// >>> pd.notna('dog')
// True
//
// >>> pd.notna(pd.NA)
// False
//
// >>> pd.notna(np.nan)
// False
//
// ndarrays result in an ndarray of booleans.
//
// >>> array = np.array([[1, np.nan, 3], [4, 5, np.nan]])
// >>> array
// array([[ 1., nan, 3.],
//
// [ 4., 5., nan]])
//
// >>> pd.notna(array)
// array([[ True, False, True],
//
// [ True, True, False]])
//
// For indexes, an ndarray of booleans is returned.
//
// >>> index = pd.DatetimeIndex(["2017-07-05", "2017-07-06", None,
// ... "2017-07-08"])
// >>> index
// DatetimeIndex(['2017-07-05', '2017-07-06', 'NaT', '2017-07-08'],
//
// dtype='datetime64[ns]', freq=None)
//
// >>> pd.notna(index)
// array([ True, True, False, True])
//
// For Series and DataFrame, the same type is returned, containing booleans.
//
// >>> df = pd.DataFrame([['ant', 'bee', 'cat'], ['dog', None, 'fly']])
// >>> df
//
// 0 1 2
//
// 0 ant bee cat
// 1 dog None fly
// >>> pd.notna(df)
//
// 0 1 2
//
// 0 True True True
// 1 True False True
//
// >>> pd.notna(df[1])
// 0 True
// 1 False
// Name: 1, dtype: bool
//
//go:linkname Notna py.notna
func Notna(obj *py.Object) *py.Object
// Detect non-missing values for an array-like object.
//
// This function takes a scalar or array-like object and indicates
// whether values are valid (not missing, which is “NaN“ in numeric
// arrays, “None“ or “NaN“ in object arrays, “NaT“ in datetimelike).
//
// Parameters
// ----------
// obj : array-like or object value
//
// Object to check for *not* null or *non*-missing values.
//
// Returns
// -------
// bool or array-like of bool
//
// For scalar input, returns a scalar boolean.
// For array input, returns an array of boolean indicating whether each
// corresponding element is valid.
//
// See Also
// --------
// isna : Boolean inverse of pandas.notna.
// Series.notna : Detect valid values in a Series.
// DataFrame.notna : Detect valid values in a DataFrame.
// Index.notna : Detect valid values in an Index.
//
// Examples
// --------
// Scalar arguments (including strings) result in a scalar boolean.
//
// >>> pd.notna('dog')
// True
//
// >>> pd.notna(pd.NA)
// False
//
// >>> pd.notna(np.nan)
// False
//
// ndarrays result in an ndarray of booleans.
//
// >>> array = np.array([[1, np.nan, 3], [4, 5, np.nan]])
// >>> array
// array([[ 1., nan, 3.],
//
// [ 4., 5., nan]])
//
// >>> pd.notna(array)
// array([[ True, False, True],
//
// [ True, True, False]])
//
// For indexes, an ndarray of booleans is returned.
//
// >>> index = pd.DatetimeIndex(["2017-07-05", "2017-07-06", None,
// ... "2017-07-08"])
// >>> index
// DatetimeIndex(['2017-07-05', '2017-07-06', 'NaT', '2017-07-08'],
//
// dtype='datetime64[ns]', freq=None)
//
// >>> pd.notna(index)
// array([ True, True, False, True])
//
// For Series and DataFrame, the same type is returned, containing booleans.
//
// >>> df = pd.DataFrame([['ant', 'bee', 'cat'], ['dog', None, 'fly']])
// >>> df
//
// 0 1 2
//
// 0 ant bee cat
// 1 dog None fly
// >>> pd.notna(df)
//
// 0 1 2
//
// 0 True True True
// 1 True False True
//
// >>> pd.notna(df[1])
// 0 True
// 1 False
// Name: 1, dtype: bool
//
//go:linkname Notnull py.notnull
func Notnull(obj *py.Object) *py.Object
// Return a fixed frequency PeriodIndex.
//
// The day (calendar) is the default frequency.
//
// Parameters
// ----------
// start : str, datetime, date, pandas.Timestamp, or period-like, default None
//
// Left bound for generating periods.
//
// end : str, datetime, date, pandas.Timestamp, or period-like, default None
//
// Right bound for generating periods.
//
// periods : int, default None
//
// Number of periods to generate.
//
// freq : str or DateOffset, optional
//
// Frequency alias. By default the freq is taken from `start` or `end`
// if those are Period objects. Otherwise, the default is ``"D"`` for
// daily frequency.
//
// name : str, default None
//
// Name of the resulting PeriodIndex.
//
// Returns
// -------
// PeriodIndex
//
// Notes
// -----
// Of the three parameters: “start“, “end“, and “periods“, exactly two
// must be specified.
//
// To learn more about the frequency strings, please see `this link
// <https://pandas.pydata.org/pandas-docs/stable/user_guide/timeseries.html#offset-aliases>`__.
//
// Examples
// --------
// >>> pd.period_range(start='2017-01-01', end='2018-01-01', freq='M')
// PeriodIndex(['2017-01', '2017-02', '2017-03', '2017-04', '2017-05', '2017-06',
//
// '2017-07', '2017-08', '2017-09', '2017-10', '2017-11', '2017-12',
// '2018-01'],
// dtype='period[M]')
//
// If “start“ or “end“ are “Period“ objects, they will be used as anchor
// endpoints for a “PeriodIndex“ with frequency matching that of the
// “period_range“ constructor.
//
// >>> pd.period_range(start=pd.Period('2017Q1', freq='Q'),
// ... end=pd.Period('2017Q2', freq='Q'), freq='M')
// PeriodIndex(['2017-03', '2017-04', '2017-05', '2017-06'],
//
// dtype='period[M]')
//
//go:linkname PeriodRange py.period_range
func PeriodRange(start *py.Object, end *py.Object, periods *py.Object, freq *py.Object, name *py.Object) *py.Object
// Return a fixed frequency TimedeltaIndex with day as the default.
//
// Parameters
// ----------
// start : str or timedelta-like, default None
//
// Left bound for generating timedeltas.
//
// end : str or timedelta-like, default None
//
// Right bound for generating timedeltas.
//
// periods : int, default None
//
// Number of periods to generate.
//
// freq : str, Timedelta, datetime.timedelta, or DateOffset, default 'D'
//
// Frequency strings can have multiples, e.g. '5h'.
//
// name : str, default None
//
// Name of the resulting TimedeltaIndex.
//
// closed : str, default None
//
// Make the interval closed with respect to the given frequency to
// the 'left', 'right', or both sides (None).
//
// unit : str, default None
//
// Specify the desired resolution of the result.
//
// .. versionadded:: 2.0.0
//
// Returns
// -------
// TimedeltaIndex
//
// Notes
// -----
// Of the four parameters “start“, “end“, “periods“, and “freq“,
// exactly three must be specified. If “freq“ is omitted, the resulting
// “TimedeltaIndex“ will have “periods“ linearly spaced elements between
// “start“ and “end“ (closed on both sides).
//
// To learn more about the frequency strings, please see `this link
// <https://pandas.pydata.org/pandas-docs/stable/user_guide/timeseries.html#offset-aliases>`__.
//
// Examples
// --------
// >>> pd.timedelta_range(start='1 day', periods=4)
// TimedeltaIndex(['1 days', '2 days', '3 days', '4 days'],
//
// dtype='timedelta64[ns]', freq='D')
//
// The “closed“ parameter specifies which endpoint is included. The default
// behavior is to include both endpoints.
//
// >>> pd.timedelta_range(start='1 day', periods=4, closed='right')
// TimedeltaIndex(['2 days', '3 days', '4 days'],
//
// dtype='timedelta64[ns]', freq='D')
//
// The “freq“ parameter specifies the frequency of the TimedeltaIndex.
// Only fixed frequencies can be passed, non-fixed frequencies such as
// 'M' (month end) will raise.
//
// >>> pd.timedelta_range(start='1 day', end='2 days', freq='6h')
// TimedeltaIndex(['1 days 00:00:00', '1 days 06:00:00', '1 days 12:00:00',
//
// '1 days 18:00:00', '2 days 00:00:00'],
// dtype='timedelta64[ns]', freq='6h')
//
// Specify “start“, “end“, and “periods“; the frequency is generated
// automatically (linearly spaced).
//
// >>> pd.timedelta_range(start='1 day', end='5 days', periods=4)
// TimedeltaIndex(['1 days 00:00:00', '2 days 08:00:00', '3 days 16:00:00',
//
// '5 days 00:00:00'],
// dtype='timedelta64[ns]', freq=None)
//
// **Specify a unit**
//
// >>> pd.timedelta_range("1 Day", periods=3, freq="100000D", unit="s")
// TimedeltaIndex(['1 days', '100001 days', '200001 days'],
//
// dtype='timedelta64[s]', freq='100000D')
//
//go:linkname TimedeltaRange py.timedelta_range
func TimedeltaRange(start *py.Object, end *py.Object, periods *py.Object, freq *py.Object, name *py.Object, closed *py.Object) *py.Object
// Return a fixed frequency DatetimeIndex.
//
// Returns the range of equally spaced time points (where the difference between any
// two adjacent points is specified by the given frequency) such that they all
// satisfy `start <[=] x <[=] end`, where the first one and the last one are, resp.,
// the first and last time points in that range that fall on the boundary of “freq“
// (if given as a frequency string) or that are valid for “freq“ (if given as a
// :class:`pandas.tseries.offsets.DateOffset`). (If exactly one of “start“,
// “end“, or “freq“ is *not* specified, this missing parameter can be computed
// given “periods“, the number of timesteps in the range. See the note below.)
//
// Parameters
// ----------
// start : str or datetime-like, optional
//
// Left bound for generating dates.
//
// end : str or datetime-like, optional
//
// Right bound for generating dates.
//
// periods : int, optional
//
// Number of periods to generate.
//
// freq : str, Timedelta, datetime.timedelta, or DateOffset, default 'D'
//
// Frequency strings can have multiples, e.g. '5h'. See
// :ref:`here <timeseries.offset_aliases>` for a list of
// frequency aliases.
//
// tz : str or tzinfo, optional
//
// Time zone name for returning localized DatetimeIndex, for example
// 'Asia/Hong_Kong'. By default, the resulting DatetimeIndex is
// timezone-naive unless timezone-aware datetime-likes are passed.
//
// normalize : bool, default False
//
// Normalize start/end dates to midnight before generating date range.
//
// name : str, default None
//
// Name of the resulting DatetimeIndex.
//
// inclusive : {"both", "neither", "left", "right"}, default "both"
//
// Include boundaries; Whether to set each bound as closed or open.
//
// .. versionadded:: 1.4.0
//
// unit : str, default None
//
// Specify the desired resolution of the result.
//
// .. versionadded:: 2.0.0
//
// **kwargs
//
// For compatibility. Has no effect on the result.
//
// Returns
// -------
// DatetimeIndex
//
// See Also
// --------
// DatetimeIndex : An immutable container for datetimes.
// timedelta_range : Return a fixed frequency TimedeltaIndex.
// period_range : Return a fixed frequency PeriodIndex.
// interval_range : Return a fixed frequency IntervalIndex.
//
// Notes
// -----
// Of the four parameters “start“, “end“, “periods“, and “freq“,
// exactly three must be specified. If “freq“ is omitted, the resulting
// “DatetimeIndex“ will have “periods“ linearly spaced elements between
// “start“ and “end“ (closed on both sides).
//
// To learn more about the frequency strings, please see `this link
// <https://pandas.pydata.org/pandas-docs/stable/user_guide/timeseries.html#offset-aliases>`__.
//
// Examples
// --------
// **Specifying the values**
//
// The next four examples generate the same `DatetimeIndex`, but vary
// the combination of `start`, `end` and `periods`.
//
// Specify `start` and `end`, with the default daily frequency.
//
// >>> pd.date_range(start='1/1/2018', end='1/08/2018')
// DatetimeIndex(['2018-01-01', '2018-01-02', '2018-01-03', '2018-01-04',
//
// '2018-01-05', '2018-01-06', '2018-01-07', '2018-01-08'],
// dtype='datetime64[ns]', freq='D')
//
// Specify timezone-aware `start` and `end`, with the default daily frequency.
//
// >>> pd.date_range(
// ... start=pd.to_datetime("1/1/2018").tz_localize("Europe/Berlin"),
// ... end=pd.to_datetime("1/08/2018").tz_localize("Europe/Berlin"),
// ... )
// DatetimeIndex(['2018-01-01 00:00:00+01:00', '2018-01-02 00:00:00+01:00',
//
// '2018-01-03 00:00:00+01:00', '2018-01-04 00:00:00+01:00',
// '2018-01-05 00:00:00+01:00', '2018-01-06 00:00:00+01:00',
// '2018-01-07 00:00:00+01:00', '2018-01-08 00:00:00+01:00'],
// dtype='datetime64[ns, Europe/Berlin]', freq='D')
//
// Specify `start` and `periods`, the number of periods (days).
//
// >>> pd.date_range(start='1/1/2018', periods=8)
// DatetimeIndex(['2018-01-01', '2018-01-02', '2018-01-03', '2018-01-04',
//
// '2018-01-05', '2018-01-06', '2018-01-07', '2018-01-08'],
// dtype='datetime64[ns]', freq='D')
//
// Specify `end` and `periods`, the number of periods (days).
//
// >>> pd.date_range(end='1/1/2018', periods=8)
// DatetimeIndex(['2017-12-25', '2017-12-26', '2017-12-27', '2017-12-28',
//
// '2017-12-29', '2017-12-30', '2017-12-31', '2018-01-01'],
// dtype='datetime64[ns]', freq='D')
//
// Specify `start`, `end`, and `periods`; the frequency is generated
// automatically (linearly spaced).
//
// >>> pd.date_range(start='2018-04-24', end='2018-04-27', periods=3)
// DatetimeIndex(['2018-04-24 00:00:00', '2018-04-25 12:00:00',
//
// '2018-04-27 00:00:00'],
// dtype='datetime64[ns]', freq=None)
//
// **Other Parameters**
//
// Changed the `freq` (frequency) to “'ME'“ (month end frequency).
//
// >>> pd.date_range(start='1/1/2018', periods=5, freq='ME')
// DatetimeIndex(['2018-01-31', '2018-02-28', '2018-03-31', '2018-04-30',
//
// '2018-05-31'],
// dtype='datetime64[ns]', freq='ME')
//
// # Multiples are allowed
//
// >>> pd.date_range(start='1/1/2018', periods=5, freq='3ME')
// DatetimeIndex(['2018-01-31', '2018-04-30', '2018-07-31', '2018-10-31',
//
// '2019-01-31'],
// dtype='datetime64[ns]', freq='3ME')
//
// `freq` can also be specified as an Offset object.
//
// >>> pd.date_range(start='1/1/2018', periods=5, freq=pd.offsets.MonthEnd(3))
// DatetimeIndex(['2018-01-31', '2018-04-30', '2018-07-31', '2018-10-31',
//
// '2019-01-31'],
// dtype='datetime64[ns]', freq='3ME')
//
// Specify `tz` to set the timezone.
//
// >>> pd.date_range(start='1/1/2018', periods=5, tz='Asia/Tokyo')
// DatetimeIndex(['2018-01-01 00:00:00+09:00', '2018-01-02 00:00:00+09:00',
//
// '2018-01-03 00:00:00+09:00', '2018-01-04 00:00:00+09:00',
// '2018-01-05 00:00:00+09:00'],
// dtype='datetime64[ns, Asia/Tokyo]', freq='D')
//
// `inclusive` controls whether to include `start` and `end` that are on the
// boundary. The default, "both", includes boundary points on either end.
//
// >>> pd.date_range(start='2017-01-01', end='2017-01-04', inclusive="both")
// DatetimeIndex(['2017-01-01', '2017-01-02', '2017-01-03', '2017-01-04'],
//
// dtype='datetime64[ns]', freq='D')
//
// Use “inclusive='left'“ to exclude `end` if it falls on the boundary.
//
// >>> pd.date_range(start='2017-01-01', end='2017-01-04', inclusive='left')
// DatetimeIndex(['2017-01-01', '2017-01-02', '2017-01-03'],
//
// dtype='datetime64[ns]', freq='D')
//
// Use “inclusive='right'“ to exclude `start` if it falls on the boundary, and
// similarly “inclusive='neither'“ will exclude both `start` and `end`.
//
// >>> pd.date_range(start='2017-01-01', end='2017-01-04', inclusive='right')
// DatetimeIndex(['2017-01-02', '2017-01-03', '2017-01-04'],
//
// dtype='datetime64[ns]', freq='D')
//
// **Specify a unit**
//
// >>> pd.date_range(start="2017-01-01", periods=10, freq="100YS", unit="s")
// DatetimeIndex(['2017-01-01', '2117-01-01', '2217-01-01', '2317-01-01',
//
// '2417-01-01', '2517-01-01', '2617-01-01', '2717-01-01',
// '2817-01-01', '2917-01-01'],
// dtype='datetime64[s]', freq='100YS-JAN')
//
//go:linkname DateRange py.date_range
func DateRange(start *py.Object, end *py.Object, periods *py.Object, freq *py.Object, tz *py.Object, normalize *py.Object, name *py.Object, inclusive *py.Object) *py.Object
// Return a fixed frequency DatetimeIndex with business day as the default.
//
// Parameters
// ----------
// start : str or datetime-like, default None
//
// Left bound for generating dates.
//
// end : str or datetime-like, default None
//
// Right bound for generating dates.
//
// periods : int, default None
//
// Number of periods to generate.
//
// freq : str, Timedelta, datetime.timedelta, or DateOffset, default 'B'
//
// Frequency strings can have multiples, e.g. '5h'. The default is
// business daily ('B').
//
// tz : str or None
//
// Time zone name for returning localized DatetimeIndex, for example
// Asia/Beijing.
//
// normalize : bool, default False
//
// Normalize start/end dates to midnight before generating date range.
//
// name : str, default None
//
// Name of the resulting DatetimeIndex.
//
// weekmask : str or None, default None
//
// Weekmask of valid business days, passed to ``numpy.busdaycalendar``,
// only used when custom frequency strings are passed. The default
// value None is equivalent to 'Mon Tue Wed Thu Fri'.
//
// holidays : list-like or None, default None
//
// Dates to exclude from the set of valid business days, passed to
// ``numpy.busdaycalendar``, only used when custom frequency strings
// are passed.
//
// inclusive : {"both", "neither", "left", "right"}, default "both"
//
// Include boundaries; Whether to set each bound as closed or open.
//
// .. versionadded:: 1.4.0
//
// **kwargs
//
// For compatibility. Has no effect on the result.
//
// Returns
// -------
// DatetimeIndex
//
// Notes
// -----
// Of the four parameters: “start“, “end“, “periods“, and “freq“,
// exactly three must be specified. Specifying “freq“ is a requirement
// for “bdate_range“. Use “date_range“ if specifying “freq“ is not
// desired.
//
// To learn more about the frequency strings, please see `this link
// <https://pandas.pydata.org/pandas-docs/stable/user_guide/timeseries.html#offset-aliases>`__.
//
// Examples
// --------
// Note how the two weekend days are skipped in the result.
//
// >>> pd.bdate_range(start='1/1/2018', end='1/08/2018')
// DatetimeIndex(['2018-01-01', '2018-01-02', '2018-01-03', '2018-01-04',
//
// '2018-01-05', '2018-01-08'],
// dtype='datetime64[ns]', freq='B')
//
//go:linkname BdateRange py.bdate_range
func BdateRange(start *py.Object, end *py.Object, periods *py.Object, freq *py.Object, tz *py.Object, normalize *py.Object, name *py.Object, weekmask *py.Object, holidays *py.Object, inclusive *py.Object) *py.Object
// Return a fixed frequency IntervalIndex.
//
// Parameters
// ----------
// start : numeric or datetime-like, default None
//
// Left bound for generating intervals.
//
// end : numeric or datetime-like, default None
//
// Right bound for generating intervals.
//
// periods : int, default None
//
// Number of periods to generate.
//
// freq : numeric, str, Timedelta, datetime.timedelta, or DateOffset, default None
//
// The length of each interval. Must be consistent with the type of start
// and end, e.g. 2 for numeric, or '5H' for datetime-like. Default is 1
// for numeric and 'D' for datetime-like.
//
// name : str, default None
//
// Name of the resulting IntervalIndex.
//
// closed : {'left', 'right', 'both', 'neither'}, default 'right'
//
// Whether the intervals are closed on the left-side, right-side, both
// or neither.
//
// Returns
// -------
// IntervalIndex
//
// See Also
// --------
// IntervalIndex : An Index of intervals that are all closed on the same side.
//
// Notes
// -----
// Of the four parameters “start“, “end“, “periods“, and “freq“,
// exactly three must be specified. If “freq“ is omitted, the resulting
// “IntervalIndex“ will have “periods“ linearly spaced elements between
// “start“ and “end“, inclusively.
//
// To learn more about datetime-like frequency strings, please see `this link
// <https://pandas.pydata.org/pandas-docs/stable/user_guide/timeseries.html#offset-aliases>`__.
//
// Examples
// --------
// Numeric “start“ and “end“ is supported.
//
// >>> pd.interval_range(start=0, end=5)
// IntervalIndex([(0, 1], (1, 2], (2, 3], (3, 4], (4, 5]],
//
// dtype='interval[int64, right]')
//
// Additionally, datetime-like input is also supported.
//
// >>> pd.interval_range(start=pd.Timestamp('2017-01-01'),
// ... end=pd.Timestamp('2017-01-04'))
// IntervalIndex([(2017-01-01 00:00:00, 2017-01-02 00:00:00],
//
// (2017-01-02 00:00:00, 2017-01-03 00:00:00],
// (2017-01-03 00:00:00, 2017-01-04 00:00:00]],
// dtype='interval[datetime64[ns], right]')
//
// The “freq“ parameter specifies the frequency between the left and right.
// endpoints of the individual intervals within the “IntervalIndex“. For
// numeric “start“ and “end“, the frequency must also be numeric.
//
// >>> pd.interval_range(start=0, periods=4, freq=1.5)
// IntervalIndex([(0.0, 1.5], (1.5, 3.0], (3.0, 4.5], (4.5, 6.0]],
//
// dtype='interval[float64, right]')
//
// Similarly, for datetime-like “start“ and “end“, the frequency must be
// convertible to a DateOffset.
//
// >>> pd.interval_range(start=pd.Timestamp('2017-01-01'),
// ... periods=3, freq='MS')
// IntervalIndex([(2017-01-01 00:00:00, 2017-02-01 00:00:00],
//
// (2017-02-01 00:00:00, 2017-03-01 00:00:00],
// (2017-03-01 00:00:00, 2017-04-01 00:00:00]],
// dtype='interval[datetime64[ns], right]')
//
// Specify “start“, “end“, and “periods“; the frequency is generated
// automatically (linearly spaced).
//
// >>> pd.interval_range(start=0, end=6, periods=4)
// IntervalIndex([(0.0, 1.5], (1.5, 3.0], (3.0, 4.5], (4.5, 6.0]],
//
// dtype='interval[float64, right]')
//
// The “closed“ parameter specifies which endpoints of the individual
// intervals within the “IntervalIndex“ are closed.
//
// >>> pd.interval_range(end=5, periods=4, closed='both')
// IntervalIndex([[1, 2], [2, 3], [3, 4], [4, 5]],
//
// dtype='interval[int64, both]')
//
//go:linkname IntervalRange py.interval_range
func IntervalRange(start *py.Object, end *py.Object, periods *py.Object, freq *py.Object, name *py.Object, closed *py.Object) *py.Object
// Convert argument to a numeric type.
//
// The default return dtype is `float64` or `int64`
// depending on the data supplied. Use the `downcast` parameter
// to obtain other dtypes.
//
// Please note that precision loss may occur if really large numbers
// are passed in. Due to the internal limitations of `ndarray`, if
// numbers smaller than `-9223372036854775808` (np.iinfo(np.int64).min)
// or larger than `18446744073709551615` (np.iinfo(np.uint64).max) are
// passed in, it is very likely they will be converted to float so that
// they can be stored in an `ndarray`. These warnings apply similarly to
// `Series` since it internally leverages `ndarray`.
//
// Parameters
// ----------
// arg : scalar, list, tuple, 1-d array, or Series
//
// Argument to be converted.
//
// errors : {'ignore', 'raise', 'coerce'}, default 'raise'
//
// - If 'raise', then invalid parsing will raise an exception.
//
// - If 'coerce', then invalid parsing will be set as NaN.
//
// - If 'ignore', then invalid parsing will return the input.
//
// .. versionchanged:: 2.2
//
// "ignore" is deprecated. Catch exceptions explicitly instead.
//
// downcast : str, default None
//
// Can be 'integer', 'signed', 'unsigned', or 'float'.
// If not None, and if the data has been successfully cast to a
// numerical dtype (or if the data was numeric to begin with),
// downcast that resulting data to the smallest numerical dtype
// possible according to the following rules:
//
// - 'integer' or 'signed': smallest signed int dtype (min.: np.int8)
// - 'unsigned': smallest unsigned int dtype (min.: np.uint8)
// - 'float': smallest float dtype (min.: np.float32)
//
// As this behaviour is separate from the core conversion to
// numeric values, any errors raised during the downcasting
// will be surfaced regardless of the value of the 'errors' input.
//
// In addition, downcasting will only occur if the size
// of the resulting data's dtype is strictly larger than
// the dtype it is to be cast to, so if none of the dtypes
// checked satisfy that specification, no downcasting will be
// performed on the data.
//
// dtype_backend : {'numpy_nullable', 'pyarrow'}, default 'numpy_nullable'
//
// Back-end data type applied to the resultant :class:`DataFrame`
// (still experimental). Behaviour is as follows:
//
// * ``"numpy_nullable"``: returns nullable-dtype-backed :class:`DataFrame`
// (default).
// * ``"pyarrow"``: returns pyarrow-backed nullable :class:`ArrowDtype`
// DataFrame.
//
// .. versionadded:: 2.0
//
// Returns
// -------
// ret
//
// Numeric if parsing succeeded.
// Return type depends on input. Series if Series, otherwise ndarray.
//
// See Also
// --------
// DataFrame.astype : Cast argument to a specified dtype.
// to_datetime : Convert argument to datetime.
// to_timedelta : Convert argument to timedelta.
// numpy.ndarray.astype : Cast a numpy array to a specified type.
// DataFrame.convert_dtypes : Convert dtypes.
//
// Examples
// --------
// Take separate series and convert to numeric, coercing when told to
//
// >>> s = pd.Series(['1.0', '2', -3])
// >>> pd.to_numeric(s)
// 0 1.0
// 1 2.0
// 2 -3.0
// dtype: float64
// >>> pd.to_numeric(s, downcast='float')
// 0 1.0
// 1 2.0
// 2 -3.0
// dtype: float32
// >>> pd.to_numeric(s, downcast='signed')
// 0 1
// 1 2
// 2 -3
// dtype: int8
// >>> s = pd.Series(['apple', '1.0', '2', -3])
// >>> pd.to_numeric(s, errors='coerce')
// 0 NaN
// 1 1.0
// 2 2.0
// 3 -3.0
// dtype: float64
//
// Downcasting of nullable integer and floating dtypes is supported:
//
// >>> s = pd.Series([1, 2, 3], dtype="Int64")
// >>> pd.to_numeric(s, downcast="integer")
// 0 1
// 1 2
// 2 3
// dtype: Int8
// >>> s = pd.Series([1.0, 2.1, 3.0], dtype="Float64")
// >>> pd.to_numeric(s, downcast="float")
// 0 1.0
// 1 2.1
// 2 3.0
// dtype: Float32
//
//go:linkname ToNumeric py.to_numeric
func ToNumeric(arg *py.Object, errors *py.Object, downcast *py.Object, dtypeBackend *py.Object) *py.Object
// Convert argument to datetime.
//
// This function converts a scalar, array-like, :class:`Series` or
// :class:`DataFrame`/dict-like to a pandas datetime object.
//
// Parameters
// ----------
// arg : int, float, str, datetime, list, tuple, 1-d array, Series, DataFrame/dict-like
//
// The object to convert to a datetime. If a :class:`DataFrame` is provided, the
// method expects minimally the following columns: :const:`"year"`,
// :const:`"month"`, :const:`"day"`. The column "year"
// must be specified in 4-digit format.
//
// errors : {'ignore', 'raise', 'coerce'}, default 'raise'
// - If :const:`'raise'`, then invalid parsing will raise an exception.
// - If :const:`'coerce'`, then invalid parsing will be set as :const:`NaT`.
// - If :const:`'ignore'`, then invalid parsing will return the input.
//
// dayfirst : bool, default False
//
// Specify a date parse order if `arg` is str or is list-like.
// If :const:`True`, parses dates with the day first, e.g. :const:`"10/11/12"`
// is parsed as :const:`2012-11-10`.
//
// .. warning::
//
// ``dayfirst=True`` is not strict, but will prefer to parse
// with day first.
//
// yearfirst : bool, default False
//
// Specify a date parse order if `arg` is str or is list-like.
//
// - If :const:`True` parses dates with the year first, e.g.
// :const:`"10/11/12"` is parsed as :const:`2010-11-12`.
// - If both `dayfirst` and `yearfirst` are :const:`True`, `yearfirst` is
// preceded (same as :mod:`dateutil`).
//
// .. warning::
//
// ``yearfirst=True`` is not strict, but will prefer to parse
// with year first.
//
// utc : bool, default False
//
// Control timezone-related parsing, localization and conversion.
//
// - If :const:`True`, the function *always* returns a timezone-aware
// UTC-localized :class:`Timestamp`, :class:`Series` or
// :class:`DatetimeIndex`. To do this, timezone-naive inputs are
// *localized* as UTC, while timezone-aware inputs are *converted* to UTC.
//
// - If :const:`False` (default), inputs will not be coerced to UTC.
// Timezone-naive inputs will remain naive, while timezone-aware ones
// will keep their time offsets. Limitations exist for mixed
// offsets (typically, daylight savings), see :ref:`Examples
// <to_datetime_tz_examples>` section for details.
//
// .. warning::
//
// In a future version of pandas, parsing datetimes with mixed time
// zones will raise an error unless `utc=True`.
// Please specify `utc=True` to opt in to the new behaviour
// and silence this warning. To create a `Series` with mixed offsets and
// `object` dtype, please use `apply` and `datetime.datetime.strptime`.
//
// See also: pandas general documentation about `timezone conversion and
// localization
// <https://pandas.pydata.org/pandas-docs/stable/user_guide/timeseries.html
// #time-zone-handling>`_.
//
// format : str, default None
//
// The strftime to parse time, e.g. :const:`"%d/%m/%Y"`. See
// `strftime documentation
// <https://docs.python.org/3/library/datetime.html
// #strftime-and-strptime-behavior>`_ for more information on choices, though
// note that :const:`"%f"` will parse all the way up to nanoseconds.
// You can also pass:
//
// - "ISO8601", to parse any `ISO8601 <https://en.wikipedia.org/wiki/ISO_8601>`_
// time string (not necessarily in exactly the same format);
// - "mixed", to infer the format for each element individually. This is risky,
// and you should probably use it along with `dayfirst`.
//
// .. note::
//
// If a :class:`DataFrame` is passed, then `format` has no effect.
//
// exact : bool, default True
//
// Control how `format` is used:
//
// - If :const:`True`, require an exact `format` match.
// - If :const:`False`, allow the `format` to match anywhere in the target
// string.
//
// Cannot be used alongside ``format='ISO8601'`` or ``format='mixed'``.
//
// unit : str, default 'ns'
//
// The unit of the arg (D,s,ms,us,ns) denote the unit, which is an
// integer or float number. This will be based off the origin.
// Example, with ``unit='ms'`` and ``origin='unix'``, this would calculate
// the number of milliseconds to the unix epoch start.
//
// infer_datetime_format : bool, default False
//
// If :const:`True` and no `format` is given, attempt to infer the format
// of the datetime strings based on the first non-NaN element,
// and if it can be inferred, switch to a faster method of parsing them.
// In some cases this can increase the parsing speed by ~5-10x.
//
// .. deprecated:: 2.0.0
// A strict version of this argument is now the default, passing it has
// no effect.
//
// origin : scalar, default 'unix'
//
// Define the reference date. The numeric values would be parsed as number
// of units (defined by `unit`) since this reference date.
//
// - If :const:`'unix'` (or POSIX) time; origin is set to 1970-01-01.
// - If :const:`'julian'`, unit must be :const:`'D'`, and origin is set to
// beginning of Julian Calendar. Julian day number :const:`0` is assigned
// to the day starting at noon on January 1, 4713 BC.
// - If Timestamp convertible (Timestamp, dt.datetime, np.datetimt64 or date
// string), origin is set to Timestamp identified by origin.
// - If a float or integer, origin is the difference
// (in units determined by the ``unit`` argument) relative to 1970-01-01.
//
// cache : bool, default True
//
// If :const:`True`, use a cache of unique, converted dates to apply the
// datetime conversion. May produce significant speed-up when parsing
// duplicate date strings, especially ones with timezone offsets. The cache
// is only used when there are at least 50 values. The presence of
// out-of-bounds values will render the cache unusable and may slow down
// parsing.
//
// Returns
// -------
// datetime
//
// If parsing succeeded.
// Return type depends on input (types in parenthesis correspond to
// fallback in case of unsuccessful timezone or out-of-range timestamp
// parsing):
//
// - scalar: :class:`Timestamp` (or :class:`datetime.datetime`)
// - array-like: :class:`DatetimeIndex` (or :class:`Series` with
// :class:`object` dtype containing :class:`datetime.datetime`)
// - Series: :class:`Series` of :class:`datetime64` dtype (or
// :class:`Series` of :class:`object` dtype containing
// :class:`datetime.datetime`)
// - DataFrame: :class:`Series` of :class:`datetime64` dtype (or
// :class:`Series` of :class:`object` dtype containing
// :class:`datetime.datetime`)
//
// Raises
// ------
// ParserError
//
// When parsing a date from string fails.
//
// ValueError
//
// When another datetime conversion error happens. For example when one
// of 'year', 'month', day' columns is missing in a :class:`DataFrame`, or
// when a Timezone-aware :class:`datetime.datetime` is found in an array-like
// of mixed time offsets, and ``utc=False``.
//
// See Also
// --------
// DataFrame.astype : Cast argument to a specified dtype.
// to_timedelta : Convert argument to timedelta.
// convert_dtypes : Convert dtypes.
//
// Notes
// -----
//
// Many input types are supported, and lead to different output types:
//
// - **scalars** can be int, float, str, datetime object (from stdlib :mod:`datetime`
// module or :mod:`numpy`). They are converted to :class:`Timestamp` when
// possible, otherwise they are converted to :class:`datetime.datetime`.
// None/NaN/null scalars are converted to :const:`NaT`.
//
// - **array-like** can contain int, float, str, datetime objects. They are
// converted to :class:`DatetimeIndex` when possible, otherwise they are
// converted to :class:`Index` with :class:`object` dtype, containing
// :class:`datetime.datetime`. None/NaN/null entries are converted to
// :const:`NaT` in both cases.
//
// - **Series** are converted to :class:`Series` with :class:`datetime64`
// dtype when possible, otherwise they are converted to :class:`Series` with
// :class:`object` dtype, containing :class:`datetime.datetime`. None/NaN/null
// entries are converted to :const:`NaT` in both cases.
//
// - **DataFrame/dict-like** are converted to :class:`Series` with
// :class:`datetime64` dtype. For each row a datetime is created from assembling
// the various dataframe columns. Column keys can be common abbreviations
// like ['year', 'month', 'day', 'minute', 'second', 'ms', 'us', 'ns']) or
// plurals of the same.
//
// The following causes are responsible for :class:`datetime.datetime` objects
// being returned (possibly inside an :class:`Index` or a :class:`Series` with
// :class:`object` dtype) instead of a proper pandas designated type
// (:class:`Timestamp`, :class:`DatetimeIndex` or :class:`Series`
// with :class:`datetime64` dtype):
//
// - when any input element is before :const:`Timestamp.min` or after
// :const:`Timestamp.max`, see `timestamp limitations
// <https://pandas.pydata.org/pandas-docs/stable/user_guide/timeseries.html
// #timeseries-timestamp-limits>`_.
//
// - when “utc=False“ (default) and the input is an array-like or
// :class:`Series` containing mixed naive/aware datetime, or aware with mixed
// time offsets. Note that this happens in the (quite frequent) situation when
// the timezone has a daylight savings policy. In that case you may wish to
// use “utc=True“.
//
// Examples
// --------
//
// **Handling various input formats**
//
// Assembling a datetime from multiple columns of a :class:`DataFrame`. The keys
// can be common abbreviations like ['year', 'month', 'day', 'minute', 'second',
// 'ms', 'us', 'ns']) or plurals of the same
//
// >>> df = pd.DataFrame({'year': [2015, 2016],
// ... 'month': [2, 3],
// ... 'day': [4, 5]})
// >>> pd.to_datetime(df)
// 0 2015-02-04
// 1 2016-03-05
// dtype: datetime64[ns]
//
// # Using a unix epoch time
//
// >>> pd.to_datetime(1490195805, unit='s')
// Timestamp('2017-03-22 15:16:45')
// >>> pd.to_datetime(1490195805433502912, unit='ns')
// Timestamp('2017-03-22 15:16:45.433502912')
//
// .. warning:: For float arg, precision rounding might happen. To prevent
//
// unexpected behavior use a fixed-width exact type.
//
// # Using a non-unix epoch origin
//
// >>> pd.to_datetime([1, 2, 3], unit='D',
// ... origin=pd.Timestamp('1960-01-01'))
// DatetimeIndex(['1960-01-02', '1960-01-03', '1960-01-04'],
//
// dtype='datetime64[ns]', freq=None)
//
// **Differences with strptime behavior**
//
// :const:`"%f"` will parse all the way up to nanoseconds.
//
// >>> pd.to_datetime('2018-10-26 12:00:00.0000000011',
// ... format='%Y-%m-%d %H:%M:%S.%f')
// Timestamp('2018-10-26 12:00:00.000000001')
//
// **Non-convertible date/times**
//
// Passing “errors='coerce'“ will force an out-of-bounds date to :const:`NaT`,
// in addition to forcing non-dates (or non-parseable dates) to :const:`NaT`.
//
// >>> pd.to_datetime('13000101', format='%Y%m%d', errors='coerce')
// NaT
//
// .. _to_datetime_tz_examples:
//
// **Timezones and time offsets**
//
// The default behaviour (“utc=False“) is as follows:
//
// - Timezone-naive inputs are converted to timezone-naive :class:`DatetimeIndex`:
//
// >>> pd.to_datetime(['2018-10-26 12:00:00', '2018-10-26 13:00:15'])
// DatetimeIndex(['2018-10-26 12:00:00', '2018-10-26 13:00:15'],
//
// dtype='datetime64[ns]', freq=None)
//
// - Timezone-aware inputs *with constant time offset* are converted to
// timezone-aware :class:`DatetimeIndex`:
//
// >>> pd.to_datetime(['2018-10-26 12:00 -0500', '2018-10-26 13:00 -0500'])
// DatetimeIndex(['2018-10-26 12:00:00-05:00', '2018-10-26 13:00:00-05:00'],
//
// dtype='datetime64[ns, UTC-05:00]', freq=None)
//
// - However, timezone-aware inputs *with mixed time offsets* (for example
// issued from a timezone with daylight savings, such as Europe/Paris)
// are **not successfully converted** to a :class:`DatetimeIndex`.
// Parsing datetimes with mixed time zones will show a warning unless
// `utc=True`. If you specify `utc=False` the warning below will be shown
// and a simple :class:`Index` containing :class:`datetime.datetime`
// objects will be returned:
//
// >>> pd.to_datetime(['2020-10-25 02:00 +0200',
// ... '2020-10-25 04:00 +0100']) # doctest: +SKIP
// FutureWarning: In a future version of pandas, parsing datetimes with mixed
// time zones will raise an error unless `utc=True`. Please specify `utc=True`
// to opt in to the new behaviour and silence this warning. To create a `Series`
// with mixed offsets and `object` dtype, please use `apply` and
// `datetime.datetime.strptime`.
// Index([2020-10-25 02:00:00+02:00, 2020-10-25 04:00:00+01:00],
//
// dtype='object')
//
// - A mix of timezone-aware and timezone-naive inputs is also converted to
// a simple :class:`Index` containing :class:`datetime.datetime` objects:
//
// >>> from datetime import datetime
// >>> pd.to_datetime(["2020-01-01 01:00:00-01:00",
// ... datetime(2020, 1, 1, 3, 0)]) # doctest: +SKIP
// FutureWarning: In a future version of pandas, parsing datetimes with mixed
// time zones will raise an error unless `utc=True`. Please specify `utc=True`
// to opt in to the new behaviour and silence this warning. To create a `Series`
// with mixed offsets and `object` dtype, please use `apply` and
// `datetime.datetime.strptime`.
// Index([2020-01-01 01:00:00-01:00, 2020-01-01 03:00:00], dtype='object')
//
// |
//
// Setting “utc=True“ solves most of the above issues:
//
// - Timezone-naive inputs are *localized* as UTC
//
// >>> pd.to_datetime(['2018-10-26 12:00', '2018-10-26 13:00'], utc=True)
// DatetimeIndex(['2018-10-26 12:00:00+00:00', '2018-10-26 13:00:00+00:00'],
//
// dtype='datetime64[ns, UTC]', freq=None)
//
// - Timezone-aware inputs are *converted* to UTC (the output represents the
// exact same datetime, but viewed from the UTC time offset `+00:00`).
//
// >>> pd.to_datetime(['2018-10-26 12:00 -0530', '2018-10-26 12:00 -0500'],
// ... utc=True)
// DatetimeIndex(['2018-10-26 17:30:00+00:00', '2018-10-26 17:00:00+00:00'],
//
// dtype='datetime64[ns, UTC]', freq=None)
//
// - Inputs can contain both string or datetime, the above
// rules still apply
//
// >>> pd.to_datetime(['2018-10-26 12:00', datetime(2020, 1, 1, 18)], utc=True)
// DatetimeIndex(['2018-10-26 12:00:00+00:00', '2020-01-01 18:00:00+00:00'],
//
// dtype='datetime64[ns, UTC]', freq=None)
//
//go:linkname ToDatetime py.to_datetime
func ToDatetime(arg *py.Object, errors *py.Object, dayfirst *py.Object, yearfirst *py.Object, utc *py.Object, format *py.Object, exact *py.Object, unit *py.Object, inferDatetimeFormat *py.Object, origin *py.Object, cache *py.Object) *py.Object
// Convert argument to timedelta.
//
// Timedeltas are absolute differences in times, expressed in difference
// units (e.g. days, hours, minutes, seconds). This method converts
// an argument from a recognized timedelta format / value into
// a Timedelta type.
//
// Parameters
// ----------
// arg : str, timedelta, list-like or Series
//
// The data to be converted to timedelta.
//
// .. versionchanged:: 2.0
// Strings with units 'M', 'Y' and 'y' do not represent
// unambiguous timedelta values and will raise an exception.
//
// unit : str, optional
//
// Denotes the unit of the arg for numeric `arg`. Defaults to ``"ns"``.
//
// Possible values:
//
// * 'W'
// * 'D' / 'days' / 'day'
// * 'hours' / 'hour' / 'hr' / 'h' / 'H'
// * 'm' / 'minute' / 'min' / 'minutes' / 'T'
// * 's' / 'seconds' / 'sec' / 'second' / 'S'
// * 'ms' / 'milliseconds' / 'millisecond' / 'milli' / 'millis' / 'L'
// * 'us' / 'microseconds' / 'microsecond' / 'micro' / 'micros' / 'U'
// * 'ns' / 'nanoseconds' / 'nano' / 'nanos' / 'nanosecond' / 'N'
//
// Must not be specified when `arg` contains strings and ``errors="raise"``.
//
// .. deprecated:: 2.2.0
// Units 'H', 'T', 'S', 'L', 'U' and 'N' are deprecated and will be removed
// in a future version. Please use 'h', 'min', 's', 'ms', 'us', and 'ns'
// instead of 'H', 'T', 'S', 'L', 'U' and 'N'.
//
// errors : {'ignore', 'raise', 'coerce'}, default 'raise'
// - If 'raise', then invalid parsing will raise an exception.
// - If 'coerce', then invalid parsing will be set as NaT.
// - If 'ignore', then invalid parsing will return the input.
//
// Returns
// -------
// timedelta
//
// If parsing succeeded.
// Return type depends on input:
//
// - list-like: TimedeltaIndex of timedelta64 dtype
// - Series: Series of timedelta64 dtype
// - scalar: Timedelta
//
// See Also
// --------
// DataFrame.astype : Cast argument to a specified dtype.
// to_datetime : Convert argument to datetime.
// convert_dtypes : Convert dtypes.
//
// Notes
// -----
// If the precision is higher than nanoseconds, the precision of the duration is
// truncated to nanoseconds for string inputs.
//
// Examples
// --------
// Parsing a single string to a Timedelta:
//
// >>> pd.to_timedelta('1 days 06:05:01.00003')
// Timedelta('1 days 06:05:01.000030')
// >>> pd.to_timedelta('15.5us')
// Timedelta('0 days 00:00:00.000015500')
//
// Parsing a list or array of strings:
//
// >>> pd.to_timedelta(['1 days 06:05:01.00003', '15.5us', 'nan'])
// TimedeltaIndex(['1 days 06:05:01.000030', '0 days 00:00:00.000015500', NaT],
//
// dtype='timedelta64[ns]', freq=None)
//
// Converting numbers by specifying the `unit` keyword argument:
//
// >>> pd.to_timedelta(np.arange(5), unit='s')
// TimedeltaIndex(['0 days 00:00:00', '0 days 00:00:01', '0 days 00:00:02',
//
// '0 days 00:00:03', '0 days 00:00:04'],
// dtype='timedelta64[ns]', freq=None)
//
// >>> pd.to_timedelta(np.arange(5), unit='d')
// TimedeltaIndex(['0 days', '1 days', '2 days', '3 days', '4 days'],
//
// dtype='timedelta64[ns]', freq=None)
//
//go:linkname ToTimedelta py.to_timedelta
func ToTimedelta(arg *py.Object, unit *py.Object, errors *py.Object) *py.Object
// Encode the object as an enumerated type or categorical variable.
//
// This method is useful for obtaining a numeric representation of an
// array when all that matters is identifying distinct values. `factorize`
// is available as both a top-level function :func:`pandas.factorize`,
// and as a method :meth:`Series.factorize` and :meth:`Index.factorize`.
//
// Parameters
// ----------
// values : sequence
//
// A 1-D sequence. Sequences that aren't pandas objects are
// coerced to ndarrays before factorization.
//
// sort : bool, default False
//
// Sort `uniques` and shuffle `codes` to maintain the
// relationship.
//
// use_na_sentinel : bool, default True
//
// If True, the sentinel -1 will be used for NaN values. If False,
// NaN values will be encoded as non-negative integers and will not drop the
// NaN from the uniques of the values.
//
// .. versionadded:: 1.5.0
//
// size_hint : int, optional
//
// Hint to the hashtable sizer.
//
// Returns
// -------
// codes : ndarray
//
// An integer ndarray that's an indexer into `uniques`.
// ``uniques.take(codes)`` will have the same values as `values`.
//
// uniques : ndarray, Index, or Categorical
//
// The unique valid values. When `values` is Categorical, `uniques`
// is a Categorical. When `values` is some other pandas object, an
// `Index` is returned. Otherwise, a 1-D ndarray is returned.
//
// .. note::
//
// Even if there's a missing value in `values`, `uniques` will
// *not* contain an entry for it.
//
// See Also
// --------
// cut : Discretize continuous-valued array.
// unique : Find the unique value in an array.
//
// Notes
// -----
// Reference :ref:`the user guide <reshaping.factorize>` for more examples.
//
// Examples
// --------
// These examples all show factorize as a top-level method like
// “pd.factorize(values)“. The results are identical for methods like
// :meth:`Series.factorize`.
//
// >>> codes, uniques = pd.factorize(np.array(['b', 'b', 'a', 'c', 'b'], dtype="O"))
// >>> codes
// array([0, 0, 1, 2, 0])
// >>> uniques
// array(['b', 'a', 'c'], dtype=object)
//
// With “sort=True“, the `uniques` will be sorted, and `codes` will be
// shuffled so that the relationship is the maintained.
//
// >>> codes, uniques = pd.factorize(np.array(['b', 'b', 'a', 'c', 'b'], dtype="O"),
// ... sort=True)
// >>> codes
// array([1, 1, 0, 2, 1])
// >>> uniques
// array(['a', 'b', 'c'], dtype=object)
//
// When “use_na_sentinel=True“ (the default), missing values are indicated in
// the `codes` with the sentinel value “-1“ and missing values are not
// included in `uniques`.
//
// >>> codes, uniques = pd.factorize(np.array(['b', None, 'a', 'c', 'b'], dtype="O"))
// >>> codes
// array([ 0, -1, 1, 2, 0])
// >>> uniques
// array(['b', 'a', 'c'], dtype=object)
//
// Thus far, we've only factorized lists (which are internally coerced to
// NumPy arrays). When factorizing pandas objects, the type of `uniques`
// will differ. For Categoricals, a `Categorical` is returned.
//
// >>> cat = pd.Categorical(['a', 'a', 'c'], categories=['a', 'b', 'c'])
// >>> codes, uniques = pd.factorize(cat)
// >>> codes
// array([0, 0, 1])
// >>> uniques
// ['a', 'c']
// Categories (3, object): ['a', 'b', 'c']
//
// Notice that “'b'“ is in “uniques.categories“, despite not being
// present in “cat.values“.
//
// For all other pandas objects, an Index of the appropriate type is
// returned.
//
// >>> cat = pd.Series(['a', 'a', 'c'])
// >>> codes, uniques = pd.factorize(cat)
// >>> codes
// array([0, 0, 1])
// >>> uniques
// Index(['a', 'c'], dtype='object')
//
// If NaN is in the values, and we want to include NaN in the uniques of the
// values, it can be achieved by setting “use_na_sentinel=False“.
//
// >>> values = np.array([1, 2, 1, np.nan])
// >>> codes, uniques = pd.factorize(values) # default: use_na_sentinel=True
// >>> codes
// array([ 0, 1, 0, -1])
// >>> uniques
// array([1., 2.])
//
// >>> codes, uniques = pd.factorize(values, use_na_sentinel=False)
// >>> codes
// array([0, 1, 0, 2])
// >>> uniques
// array([ 1., 2., nan])
//
//go:linkname Factorize py.factorize
func Factorize(values *py.Object, sort *py.Object, useNaSentinel *py.Object, sizeHint *py.Object) *py.Object
// Return unique values based on a hash table.
//
// Uniques are returned in order of appearance. This does NOT sort.
//
// Significantly faster than numpy.unique for long enough sequences.
// Includes NA values.
//
// Parameters
// ----------
// values : 1d array-like
//
// Returns
// -------
// numpy.ndarray or ExtensionArray
//
// The return can be:
//
// * Index : when the input is an Index
// * Categorical : when the input is a Categorical dtype
// * ndarray : when the input is a Series/ndarray
//
// Return numpy.ndarray or ExtensionArray.
//
// See Also
// --------
// Index.unique : Return unique values from an Index.
// Series.unique : Return unique values of Series object.
//
// Examples
// --------
// >>> pd.unique(pd.Series([2, 1, 3, 3]))
// array([2, 1, 3])
//
// >>> pd.unique(pd.Series([2] + [1] * 5))
// array([2, 1])
//
// >>> pd.unique(pd.Series([pd.Timestamp("20160101"), pd.Timestamp("20160101")]))
// array(['2016-01-01T00:00:00.000000000'], dtype='datetime64[ns]')
//
// >>> pd.unique(
// ... pd.Series(
// ... [
// ... pd.Timestamp("20160101", tz="US/Eastern"),
// ... pd.Timestamp("20160101", tz="US/Eastern"),
// ... ]
// ... )
// ... )
// <DatetimeArray>
// ['2016-01-01 00:00:00-05:00']
// Length: 1, dtype: datetime64[ns, US/Eastern]
//
// >>> pd.unique(
// ... pd.Index(
// ... [
// ... pd.Timestamp("20160101", tz="US/Eastern"),
// ... pd.Timestamp("20160101", tz="US/Eastern"),
// ... ]
// ... )
// ... )
// DatetimeIndex(['2016-01-01 00:00:00-05:00'],
//
// dtype='datetime64[ns, US/Eastern]',
// freq=None)
//
// >>> pd.unique(np.array(list("baabc"), dtype="O"))
// array(['b', 'a', 'c'], dtype=object)
//
// An unordered Categorical will return categories in the
// order of appearance.
//
// >>> pd.unique(pd.Series(pd.Categorical(list("baabc"))))
// ['b', 'a', 'c']
// Categories (3, object): ['a', 'b', 'c']
//
// >>> pd.unique(pd.Series(pd.Categorical(list("baabc"), categories=list("abc"))))
// ['b', 'a', 'c']
// Categories (3, object): ['a', 'b', 'c']
//
// An ordered Categorical preserves the category ordering.
//
// >>> pd.unique(
// ... pd.Series(
// ... pd.Categorical(list("baabc"), categories=list("abc"), ordered=True)
// ... )
// ... )
// ['b', 'a', 'c']
// Categories (3, object): ['a' < 'b' < 'c']
//
// # An array of tuples
//
// >>> pd.unique(pd.Series([("a", "b"), ("b", "a"), ("a", "c"), ("b", "a")]).values)
// array([('a', 'b'), ('b', 'a'), ('a', 'c')], dtype=object)
//
//go:linkname Unique py.unique
func Unique(values *py.Object) *py.Object
// Compute a histogram of the counts of non-null values.
//
// Parameters
// ----------
// values : ndarray (1-d)
// sort : bool, default True
//
// Sort by values
//
// ascending : bool, default False
//
// Sort in ascending order
//
// normalize: bool, default False
//
// If True then compute a relative histogram
//
// bins : integer, optional
//
// Rather than count values, group them into half-open bins,
// convenience for pd.cut, only works with numeric data
//
// dropna : bool, default True
//
// Don't include counts of NaN
//
// Returns
// -------
// Series
//
//go:linkname ValueCounts py.value_counts
func ValueCounts(values *py.Object, sort *py.Object, ascending *py.Object, normalize *py.Object, bins *py.Object, dropna *py.Object) *py.Object
// Create an array.
//
// Parameters
// ----------
// data : Sequence of objects
//
// The scalars inside `data` should be instances of the
// scalar type for `dtype`. It's expected that `data`
// represents a 1-dimensional array of data.
//
// When `data` is an Index or Series, the underlying array
// will be extracted from `data`.
//
// dtype : str, np.dtype, or ExtensionDtype, optional
//
// The dtype to use for the array. This may be a NumPy
// dtype or an extension type registered with pandas using
// :meth:`pandas.api.extensions.register_extension_dtype`.
//
// If not specified, there are two possibilities:
//
// 1. When `data` is a :class:`Series`, :class:`Index`, or
// :class:`ExtensionArray`, the `dtype` will be taken
// from the data.
// 2. Otherwise, pandas will attempt to infer the `dtype`
// from the data.
//
// Note that when `data` is a NumPy array, ``data.dtype`` is
// *not* used for inferring the array type. This is because
// NumPy cannot represent all the types of data that can be
// held in extension arrays.
//
// Currently, pandas will infer an extension dtype for sequences of
//
// ============================== =======================================
// Scalar Type Array Type
// ============================== =======================================
// :class:`pandas.Interval` :class:`pandas.arrays.IntervalArray`
// :class:`pandas.Period` :class:`pandas.arrays.PeriodArray`
// :class:`datetime.datetime` :class:`pandas.arrays.DatetimeArray`
// :class:`datetime.timedelta` :class:`pandas.arrays.TimedeltaArray`
// :class:`int` :class:`pandas.arrays.IntegerArray`
// :class:`float` :class:`pandas.arrays.FloatingArray`
// :class:`str` :class:`pandas.arrays.StringArray` or
// :class:`pandas.arrays.ArrowStringArray`
// :class:`bool` :class:`pandas.arrays.BooleanArray`
// ============================== =======================================
//
// The ExtensionArray created when the scalar type is :class:`str` is determined by
// ``pd.options.mode.string_storage`` if the dtype is not explicitly given.
//
// For all other cases, NumPy's usual inference rules will be used.
//
// copy : bool, default True
//
// Whether to copy the data, even if not necessary. Depending
// on the type of `data`, creating the new array may require
// copying data, even if ``copy=False``.
//
// Returns
// -------
// ExtensionArray
//
// The newly created array.
//
// Raises
// ------
// ValueError
//
// When `data` is not 1-dimensional.
//
// See Also
// --------
// numpy.array : Construct a NumPy array.
// Series : Construct a pandas Series.
// Index : Construct a pandas Index.
// arrays.NumpyExtensionArray : ExtensionArray wrapping a NumPy array.
// Series.array : Extract the array stored within a Series.
//
// Notes
// -----
// Omitting the `dtype` argument means pandas will attempt to infer the
// best array type from the values in the data. As new array types are
// added by pandas and 3rd party libraries, the "best" array type may
// change. We recommend specifying `dtype` to ensure that
//
// 1. the correct array type for the data is returned
// 2. the returned array type doesn't change as new extension types
// are added by pandas and third-party libraries
//
// Additionally, if the underlying memory representation of the returned
// array matters, we recommend specifying the `dtype` as a concrete object
// rather than a string alias or allowing it to be inferred. For example,
// a future version of pandas or a 3rd-party library may include a
// dedicated ExtensionArray for string data. In this event, the following
// would no longer return a :class:`arrays.NumpyExtensionArray` backed by a
// NumPy array.
//
// >>> pd.array(['a', 'b'], dtype=str)
// <NumpyExtensionArray>
// ['a', 'b']
// Length: 2, dtype: str32
//
// This would instead return the new ExtensionArray dedicated for string
// data. If you really need the new array to be backed by a NumPy array,
// specify that in the dtype.
//
// >>> pd.array(['a', 'b'], dtype=np.dtype("<U1"))
// <NumpyExtensionArray>
// ['a', 'b']
// Length: 2, dtype: str32
//
// Finally, Pandas has arrays that mostly overlap with NumPy
//
// - :class:`arrays.DatetimeArray`
// - :class:`arrays.TimedeltaArray`
//
// When data with a “datetime64[ns]“ or “timedelta64[ns]“ dtype is
// passed, pandas will always return a “DatetimeArray“ or “TimedeltaArray“
// rather than a “NumpyExtensionArray“. This is for symmetry with the case of
// timezone-aware data, which NumPy does not natively support.
//
// >>> pd.array(['2015', '2016'], dtype='datetime64[ns]')
// <DatetimeArray>
// ['2015-01-01 00:00:00', '2016-01-01 00:00:00']
// Length: 2, dtype: datetime64[ns]
//
// >>> pd.array(["1h", "2h"], dtype='timedelta64[ns]')
// <TimedeltaArray>
// ['0 days 01:00:00', '0 days 02:00:00']
// Length: 2, dtype: timedelta64[ns]
//
// Examples
// --------
// If a dtype is not specified, pandas will infer the best dtype from the values.
// See the description of `dtype` for the types pandas infers for.
//
// >>> pd.array([1, 2])
// <IntegerArray>
// [1, 2]
// Length: 2, dtype: Int64
//
// >>> pd.array([1, 2, np.nan])
// <IntegerArray>
// [1, 2, <NA>]
// Length: 3, dtype: Int64
//
// >>> pd.array([1.1, 2.2])
// <FloatingArray>
// [1.1, 2.2]
// Length: 2, dtype: Float64
//
// >>> pd.array(["a", None, "c"])
// <StringArray>
// ['a', <NA>, 'c']
// Length: 3, dtype: string
//
// >>> with pd.option_context("string_storage", "pyarrow"):
// ... arr = pd.array(["a", None, "c"])
// ...
// >>> arr
// <ArrowStringArray>
// ['a', <NA>, 'c']
// Length: 3, dtype: string
//
// >>> pd.array([pd.Period('2000', freq="D"), pd.Period("2000", freq="D")])
// <PeriodArray>
// ['2000-01-01', '2000-01-01']
// Length: 2, dtype: period[D]
//
// You can use the string alias for `dtype`
//
// >>> pd.array(['a', 'b', 'a'], dtype='category')
// ['a', 'b', 'a']
// Categories (2, object): ['a', 'b']
//
// # Or specify the actual dtype
//
// >>> pd.array(['a', 'b', 'a'],
// ... dtype=pd.CategoricalDtype(['a', 'b', 'c'], ordered=True))
// ['a', 'b', 'a']
// Categories (3, object): ['a' < 'b' < 'c']
//
// If pandas does not infer a dedicated extension type a
// :class:`arrays.NumpyExtensionArray` is returned.
//
// >>> pd.array([1 + 1j, 3 + 2j])
// <NumpyExtensionArray>
// [(1+1j), (3+2j)]
// Length: 2, dtype: complex128
//
// As mentioned in the "Notes" section, new extension types may be added
// in the future (by pandas or 3rd party libraries), causing the return
// value to no longer be a :class:`arrays.NumpyExtensionArray`. Specify the
// `dtype` as a NumPy dtype if you need to ensure there's no future change in
// behavior.
//
// >>> pd.array([1, 2], dtype=np.dtype("int32"))
// <NumpyExtensionArray>
// [1, 2]
// Length: 2, dtype: int32
//
// `data` must be 1-dimensional. A ValueError is raised when the input
// has the wrong dimensionality.
//
// >>> pd.array(1)
// Traceback (most recent call last):
//
// ...
//
// ValueError: Cannot pass scalar '1' to 'pandas.array'.
//
//go:linkname Array py.array
func Array(data *py.Object, dtype *py.Object, copy *py.Object) *py.Object
// Format float representation in DataFrame with SI notation.
//
// Parameters
// ----------
// accuracy : int, default 3
//
// Number of decimal digits after the floating point.
//
// use_eng_prefix : bool, default False
//
// Whether to represent a value with SI prefixes.
//
// Returns
// -------
// None
//
// Examples
// --------
// >>> df = pd.DataFrame([1e-9, 1e-3, 1, 1e3, 1e6])
// >>> df
//
// 0
//
// 0 1.000000e-09
// 1 1.000000e-03
// 2 1.000000e+00
// 3 1.000000e+03
// 4 1.000000e+06
//
// >>> pd.set_eng_float_format(accuracy=1)
// >>> df
//
// 0
//
// 0 1.0E-09
// 1 1.0E-03
// 2 1.0E+00
// 3 1.0E+03
// 4 1.0E+06
//
// >>> pd.set_eng_float_format(use_eng_prefix=True)
// >>> df
//
// 0
//
// 0 1.000n
// 1 1.000m
// 2 1.000
// 3 1.000k
// 4 1.000M
//
// >>> pd.set_eng_float_format(accuracy=1, use_eng_prefix=True)
// >>> df
//
// 0
//
// 0 1.0n
// 1 1.0m
// 2 1.0
// 3 1.0k
// 4 1.0M
//
// >>> pd.set_option("display.float_format", None) # unset option
//
//go:linkname SetEngFloatFormat py.set_eng_float_format
func SetEngFloatFormat(accuracy *py.Object, useEngPrefix *py.Object) *py.Object
// Infer the most likely frequency given the input index.
//
// Parameters
// ----------
// index : DatetimeIndex, TimedeltaIndex, Series or array-like
//
// If passed a Series will use the values of the series (NOT THE INDEX).
//
// Returns
// -------
// str or None
//
// None if no discernible frequency.
//
// Raises
// ------
// TypeError
//
// If the index is not datetime-like.
//
// ValueError
//
// If there are fewer than three values.
//
// Examples
// --------
// >>> idx = pd.date_range(start='2020/12/01', end='2020/12/30', periods=30)
// >>> pd.infer_freq(idx)
// 'D'
//
//go:linkname InferFreq py.infer_freq
func InferFreq(index *py.Object) *py.Object
// Concatenate pandas objects along a particular axis.
//
// Allows optional set logic along the other axes.
//
// Can also add a layer of hierarchical indexing on the concatenation axis,
// which may be useful if the labels are the same (or overlapping) on
// the passed axis number.
//
// Parameters
// ----------
// objs : a sequence or mapping of Series or DataFrame objects
//
// If a mapping is passed, the sorted keys will be used as the `keys`
// argument, unless it is passed, in which case the values will be
// selected (see below). Any None objects will be dropped silently unless
// they are all None in which case a ValueError will be raised.
//
// axis : {0/'index', 1/'columns'}, default 0
//
// The axis to concatenate along.
//
// join : {'inner', 'outer'}, default 'outer'
//
// How to handle indexes on other axis (or axes).
//
// ignore_index : bool, default False
//
// If True, do not use the index values along the concatenation axis. The
// resulting axis will be labeled 0, ..., n - 1. This is useful if you are
// concatenating objects where the concatenation axis does not have
// meaningful indexing information. Note the index values on the other
// axes are still respected in the join.
//
// keys : sequence, default None
//
// If multiple levels passed, should contain tuples. Construct
// hierarchical index using the passed keys as the outermost level.
//
// levels : list of sequences, default None
//
// Specific levels (unique values) to use for constructing a
// MultiIndex. Otherwise they will be inferred from the keys.
//
// names : list, default None
//
// Names for the levels in the resulting hierarchical index.
//
// verify_integrity : bool, default False
//
// Check whether the new concatenated axis contains duplicates. This can
// be very expensive relative to the actual data concatenation.
//
// sort : bool, default False
//
// Sort non-concatenation axis if it is not already aligned. One exception to
// this is when the non-concatentation axis is a DatetimeIndex and join='outer'
// and the axis is not already aligned. In that case, the non-concatenation
// axis is always sorted lexicographically.
//
// copy : bool, default True
//
// If False, do not copy data unnecessarily.
//
// Returns
// -------
// object, type of objs
//
// When concatenating all ``Series`` along the index (axis=0), a
// ``Series`` is returned. When ``objs`` contains at least one
// ``DataFrame``, a ``DataFrame`` is returned. When concatenating along
// the columns (axis=1), a ``DataFrame`` is returned.
//
// See Also
// --------
// DataFrame.join : Join DataFrames using indexes.
// DataFrame.merge : Merge DataFrames by indexes or columns.
//
// Notes
// -----
// The keys, levels, and names arguments are all optional.
//
// A walkthrough of how this method fits in with other tools for combining
// pandas objects can be found `here
// <https://pandas.pydata.org/pandas-docs/stable/user_guide/merging.html>`__.
//
// It is not recommended to build DataFrames by adding single rows in a
// for loop. Build a list of rows and make a DataFrame in a single concat.
//
// Examples
// --------
// Combine two “Series“.
//
// >>> s1 = pd.Series(['a', 'b'])
// >>> s2 = pd.Series(['c', 'd'])
// >>> pd.concat([s1, s2])
// 0 a
// 1 b
// 0 c
// 1 d
// dtype: object
//
// Clear the existing index and reset it in the result
// by setting the “ignore_index“ option to “True“.
//
// >>> pd.concat([s1, s2], ignore_index=True)
// 0 a
// 1 b
// 2 c
// 3 d
// dtype: object
//
// Add a hierarchical index at the outermost level of
// the data with the “keys“ option.
//
// >>> pd.concat([s1, s2], keys=['s1', 's2'])
// s1 0 a
//
// 1 b
//
// s2 0 c
//
// 1 d
//
// dtype: object
//
// Label the index keys you create with the “names“ option.
//
// >>> pd.concat([s1, s2], keys=['s1', 's2'],
// ... names=['Series name', 'Row ID'])
// Series name Row ID
// s1 0 a
//
// 1 b
//
// s2 0 c
//
// 1 d
//
// dtype: object
//
// Combine two “DataFrame“ objects with identical columns.
//
// >>> df1 = pd.DataFrame([['a', 1], ['b', 2]],
// ... columns=['letter', 'number'])
// >>> df1
//
// letter number
//
// 0 a 1
// 1 b 2
// >>> df2 = pd.DataFrame([['c', 3], ['d', 4]],
// ... columns=['letter', 'number'])
// >>> df2
//
// letter number
//
// 0 c 3
// 1 d 4
// >>> pd.concat([df1, df2])
//
// letter number
//
// 0 a 1
// 1 b 2
// 0 c 3
// 1 d 4
//
// Combine “DataFrame“ objects with overlapping columns
// and return everything. Columns outside the intersection will
// be filled with “NaN“ values.
//
// >>> df3 = pd.DataFrame([['c', 3, 'cat'], ['d', 4, 'dog']],
// ... columns=['letter', 'number', 'animal'])
// >>> df3
//
// letter number animal
//
// 0 c 3 cat
// 1 d 4 dog
// >>> pd.concat([df1, df3], sort=False)
//
// letter number animal
//
// 0 a 1 NaN
// 1 b 2 NaN
// 0 c 3 cat
// 1 d 4 dog
//
// Combine “DataFrame“ objects with overlapping columns
// and return only those that are shared by passing “inner“ to
// the “join“ keyword argument.
//
// >>> pd.concat([df1, df3], join="inner")
//
// letter number
//
// 0 a 1
// 1 b 2
// 0 c 3
// 1 d 4
//
// Combine “DataFrame“ objects horizontally along the x axis by
// passing in “axis=1“.
//
// >>> df4 = pd.DataFrame([['bird', 'polly'], ['monkey', 'george']],
// ... columns=['animal', 'name'])
// >>> pd.concat([df1, df4], axis=1)
//
// letter number animal name
//
// 0 a 1 bird polly
// 1 b 2 monkey george
//
// Prevent the result from including duplicate index values with the
// “verify_integrity“ option.
//
// >>> df5 = pd.DataFrame([1], index=['a'])
// >>> df5
//
// 0
//
// a 1
// >>> df6 = pd.DataFrame([2], index=['a'])
// >>> df6
//
// 0
//
// a 2
// >>> pd.concat([df5, df6], verify_integrity=True)
// Traceback (most recent call last):
//
// ...
//
// ValueError: Indexes have overlapping values: ['a']
//
// Append a single row to the end of a “DataFrame“ object.
//
// >>> df7 = pd.DataFrame({'a': 1, 'b': 2}, index=[0])
// >>> df7
//
// a b
//
// 0 1 2
// >>> new_row = pd.Series({'a': 3, 'b': 4})
// >>> new_row
// a 3
// b 4
// dtype: int64
// >>> pd.concat([df7, new_row.to_frame().T], ignore_index=True)
//
// a b
//
// 0 1 2
// 1 3 4
//
//go:linkname Concat py.concat
func Concat(objs *py.Object) *py.Object
// Reshape wide-format data to long. Generalized inverse of DataFrame.pivot.
//
// Accepts a dictionary, “groups“, in which each key is a new column name
// and each value is a list of old column names that will be "melted" under
// the new column name as part of the reshape.
//
// Parameters
// ----------
// data : DataFrame
//
// The wide-format DataFrame.
//
// groups : dict
//
// {new_name : list_of_columns}.
//
// dropna : bool, default True
//
// Do not include columns whose entries are all NaN.
//
// Returns
// -------
// DataFrame
//
// Reshaped DataFrame.
//
// See Also
// --------
// melt : Unpivot a DataFrame from wide to long format, optionally leaving
//
// identifiers set.
//
// pivot : Create a spreadsheet-style pivot table as a DataFrame.
// DataFrame.pivot : Pivot without aggregation that can handle
//
// non-numeric data.
//
// DataFrame.pivot_table : Generalization of pivot that can handle
//
// duplicate values for one index/column pair.
//
// DataFrame.unstack : Pivot based on the index values instead of a
//
// column.
//
// wide_to_long : Wide panel to long format. Less flexible but more
//
// user-friendly than melt.
//
// Examples
// --------
// >>> data = pd.DataFrame({'hr1': [514, 573], 'hr2': [545, 526],
// ... 'team': ['Red Sox', 'Yankees'],
// ... 'year1': [2007, 2007], 'year2': [2008, 2008]})
// >>> data
//
// hr1 hr2 team year1 year2
//
// 0 514 545 Red Sox 2007 2008
// 1 573 526 Yankees 2007 2008
//
// >>> pd.lreshape(data, {'year': ['year1', 'year2'], 'hr': ['hr1', 'hr2']})
//
// team year hr
//
// 0 Red Sox 2007 514
// 1 Yankees 2007 573
// 2 Red Sox 2008 545
// 3 Yankees 2008 526
//
//go:linkname Lreshape py.lreshape
func Lreshape(data *py.Object, groups *py.Object, dropna *py.Object) *py.Object
// Unpivot a DataFrame from wide to long format, optionally leaving identifiers set.
//
// This function is useful to massage a DataFrame into a format where one
// or more columns are identifier variables (`id_vars`), while all other
// columns, considered measured variables (`value_vars`), are "unpivoted" to
// the row axis, leaving just two non-identifier columns, 'variable' and
// 'value'.
//
// Parameters
// ----------
// id_vars : scalar, tuple, list, or ndarray, optional
//
// Column(s) to use as identifier variables.
//
// value_vars : scalar, tuple, list, or ndarray, optional
//
// Column(s) to unpivot. If not specified, uses all columns that
// are not set as `id_vars`.
//
// var_name : scalar, default None
//
// Name to use for the 'variable' column. If None it uses
// ``frame.columns.name`` or 'variable'.
//
// value_name : scalar, default 'value'
//
// Name to use for the 'value' column, can't be an existing column label.
//
// col_level : scalar, optional
//
// If columns are a MultiIndex then use this level to melt.
//
// ignore_index : bool, default True
//
// If True, original index is ignored. If False, the original index is retained.
// Index labels will be repeated as necessary.
//
// Returns
// -------
// DataFrame
//
// Unpivoted DataFrame.
//
// See Also
// --------
// DataFrame.melt : Identical method.
// pivot_table : Create a spreadsheet-style pivot table as a DataFrame.
// DataFrame.pivot : Return reshaped DataFrame organized
//
// by given index / column values.
//
// DataFrame.explode : Explode a DataFrame from list-like
//
// columns to long format.
//
// Notes
// -----
// Reference :ref:`the user guide <reshaping.melt>` for more examples.
//
// Examples
// --------
// >>> df = pd.DataFrame({'A': {0: 'a', 1: 'b', 2: 'c'},
// ... 'B': {0: 1, 1: 3, 2: 5},
// ... 'C': {0: 2, 1: 4, 2: 6}})
// >>> df
//
// A B C
//
// 0 a 1 2
// 1 b 3 4
// 2 c 5 6
//
// >>> pd.melt(df, id_vars=['A'], value_vars=['B'])
//
// A variable value
//
// 0 a B 1
// 1 b B 3
// 2 c B 5
//
// >>> pd.melt(df, id_vars=['A'], value_vars=['B', 'C'])
//
// A variable value
//
// 0 a B 1
// 1 b B 3
// 2 c B 5
// 3 a C 2
// 4 b C 4
// 5 c C 6
//
// The names of 'variable' and 'value' columns can be customized:
//
// >>> pd.melt(df, id_vars=['A'], value_vars=['B'],
// ... var_name='myVarname', value_name='myValname')
//
// A myVarname myValname
//
// 0 a B 1
// 1 b B 3
// 2 c B 5
//
// Original index values can be kept around:
//
// >>> pd.melt(df, id_vars=['A'], value_vars=['B', 'C'], ignore_index=False)
//
// A variable value
//
// 0 a B 1
// 1 b B 3
// 2 c B 5
// 0 a C 2
// 1 b C 4
// 2 c C 6
//
// If you have multi-index columns:
//
// >>> df.columns = [list('ABC'), list('DEF')]
// >>> df
//
// A B C
// D E F
//
// 0 a 1 2
// 1 b 3 4
// 2 c 5 6
//
// >>> pd.melt(df, col_level=0, id_vars=['A'], value_vars=['B'])
//
// A variable value
//
// 0 a B 1
// 1 b B 3
// 2 c B 5
//
// >>> pd.melt(df, id_vars=[('A', 'D')], value_vars=[('B', 'E')])
//
// (A, D) variable_0 variable_1 value
//
// 0 a B E 1
// 1 b B E 3
// 2 c B E 5
//
//go:linkname Melt py.melt
func Melt(frame *py.Object, idVars *py.Object, valueVars *py.Object, varName *py.Object, valueName *py.Object, colLevel *py.Object, ignoreIndex *py.Object) *py.Object
// Unpivot a DataFrame from wide to long format.
//
// Less flexible but more user-friendly than melt.
//
// With stubnames ['A', 'B'], this function expects to find one or more
// group of columns with format
// A-suffix1, A-suffix2,..., B-suffix1, B-suffix2,...
// You specify what you want to call this suffix in the resulting long format
// with `j` (for example `j='year'`)
//
// Each row of these wide variables are assumed to be uniquely identified by
// `i` (can be a single column name or a list of column names)
//
// All remaining variables in the data frame are left intact.
//
// Parameters
// ----------
// df : DataFrame
//
// The wide-format DataFrame.
//
// stubnames : str or list-like
//
// The stub name(s). The wide format variables are assumed to
// start with the stub names.
//
// i : str or list-like
//
// Column(s) to use as id variable(s).
//
// j : str
//
// The name of the sub-observation variable. What you wish to name your
// suffix in the long format.
//
// sep : str, default ""
//
// A character indicating the separation of the variable names
// in the wide format, to be stripped from the names in the long format.
// For example, if your column names are A-suffix1, A-suffix2, you
// can strip the hyphen by specifying `sep='-'`.
//
// suffix : str, default '\\d+'
//
// A regular expression capturing the wanted suffixes. '\\d+' captures
// numeric suffixes. Suffixes with no numbers could be specified with the
// negated character class '\\D+'. You can also further disambiguate
// suffixes, for example, if your wide variables are of the form A-one,
// B-two,.., and you have an unrelated column A-rating, you can ignore the
// last one by specifying `suffix='(!?one|two)'`. When all suffixes are
// numeric, they are cast to int64/float64.
//
// Returns
// -------
// DataFrame
//
// A DataFrame that contains each stub name as a variable, with new index
// (i, j).
//
// See Also
// --------
// melt : Unpivot a DataFrame from wide to long format, optionally leaving
//
// identifiers set.
//
// pivot : Create a spreadsheet-style pivot table as a DataFrame.
// DataFrame.pivot : Pivot without aggregation that can handle
//
// non-numeric data.
//
// DataFrame.pivot_table : Generalization of pivot that can handle
//
// duplicate values for one index/column pair.
//
// DataFrame.unstack : Pivot based on the index values instead of a
//
// column.
//
// Notes
// -----
// All extra variables are left untouched. This simply uses
// `pandas.melt` under the hood, but is hard-coded to "do the right thing"
// in a typical case.
//
// Examples
// --------
// >>> np.random.seed(123)
// >>> df = pd.DataFrame({"A1970" : {0 : "a", 1 : "b", 2 : "c"},
// ... "A1980" : {0 : "d", 1 : "e", 2 : "f"},
// ... "B1970" : {0 : 2.5, 1 : 1.2, 2 : .7},
// ... "B1980" : {0 : 3.2, 1 : 1.3, 2 : .1},
// ... "X" : dict(zip(range(3), np.random.randn(3)))
// ... })
// >>> df["id"] = df.index
// >>> df
//
// A1970 A1980 B1970 B1980 X id
//
// 0 a d 2.5 3.2 -1.085631 0
// 1 b e 1.2 1.3 0.997345 1
// 2 c f 0.7 0.1 0.282978 2
// >>> pd.wide_to_long(df, ["A", "B"], i="id", j="year")
// ... # doctest: +NORMALIZE_WHITESPACE
//
// X A B
//
// id year
// 0 1970 -1.085631 a 2.5
// 1 1970 0.997345 b 1.2
// 2 1970 0.282978 c 0.7
// 0 1980 -1.085631 d 3.2
// 1 1980 0.997345 e 1.3
// 2 1980 0.282978 f 0.1
//
// # With multiple id columns
//
// >>> df = pd.DataFrame({
// ... 'famid': [1, 1, 1, 2, 2, 2, 3, 3, 3],
// ... 'birth': [1, 2, 3, 1, 2, 3, 1, 2, 3],
// ... 'ht1': [2.8, 2.9, 2.2, 2, 1.8, 1.9, 2.2, 2.3, 2.1],
// ... 'ht2': [3.4, 3.8, 2.9, 3.2, 2.8, 2.4, 3.3, 3.4, 2.9]
// ... })
// >>> df
//
// famid birth ht1 ht2
//
// 0 1 1 2.8 3.4
// 1 1 2 2.9 3.8
// 2 1 3 2.2 2.9
// 3 2 1 2.0 3.2
// 4 2 2 1.8 2.8
// 5 2 3 1.9 2.4
// 6 3 1 2.2 3.3
// 7 3 2 2.3 3.4
// 8 3 3 2.1 2.9
// >>> l = pd.wide_to_long(df, stubnames='ht', i=['famid', 'birth'], j='age')
// >>> l
// ... # doctest: +NORMALIZE_WHITESPACE
//
// ht
//
// famid birth age
// 1 1 1 2.8
//
// 2 3.4
// 2 1 2.9
// 2 3.8
// 3 1 2.2
// 2 2.9
//
// 2 1 1 2.0
//
// 2 3.2
// 2 1 1.8
// 2 2.8
// 3 1 1.9
// 2 2.4
//
// 3 1 1 2.2
//
// 2 3.3
// 2 1 2.3
// 2 3.4
// 3 1 2.1
// 2 2.9
//
// Going from long back to wide just takes some creative use of `unstack`
//
// >>> w = l.unstack()
// >>> w.columns = w.columns.map('{0[0]}{0[1]}'.format)
// >>> w.reset_index()
//
// famid birth ht1 ht2
//
// 0 1 1 2.8 3.4
// 1 1 2 2.9 3.8
// 2 1 3 2.2 2.9
// 3 2 1 2.0 3.2
// 4 2 2 1.8 2.8
// 5 2 3 1.9 2.4
// 6 3 1 2.2 3.3
// 7 3 2 2.3 3.4
// 8 3 3 2.1 2.9
//
// # Less wieldy column names are also handled
//
// >>> np.random.seed(0)
// >>> df = pd.DataFrame({'A(weekly)-2010': np.random.rand(3),
// ... 'A(weekly)-2011': np.random.rand(3),
// ... 'B(weekly)-2010': np.random.rand(3),
// ... 'B(weekly)-2011': np.random.rand(3),
// ... 'X' : np.random.randint(3, size=3)})
// >>> df['id'] = df.index
// >>> df # doctest: +NORMALIZE_WHITESPACE, +ELLIPSIS
//
// A(weekly)-2010 A(weekly)-2011 B(weekly)-2010 B(weekly)-2011 X id
//
// 0 0.548814 0.544883 0.437587 0.383442 0 0
// 1 0.715189 0.423655 0.891773 0.791725 1 1
// 2 0.602763 0.645894 0.963663 0.528895 1 2
//
// >>> pd.wide_to_long(df, ['A(weekly)', 'B(weekly)'], i='id',
// ... j='year', sep='-')
// ... # doctest: +NORMALIZE_WHITESPACE
//
// X A(weekly) B(weekly)
//
// id year
// 0 2010 0 0.548814 0.437587
// 1 2010 1 0.715189 0.891773
// 2 2010 1 0.602763 0.963663
// 0 2011 0 0.544883 0.383442
// 1 2011 1 0.423655 0.791725
// 2 2011 1 0.645894 0.528895
//
// If we have many columns, we could also use a regex to find our
// stubnames and pass that list on to wide_to_long
//
// >>> stubnames = sorted(
// ... set([match[0] for match in df.columns.str.findall(
// ... r'[A-B]\(.*\)').values if match != []])
// ... )
// >>> list(stubnames)
// ['A(weekly)', 'B(weekly)']
//
// All of the above examples have integers as suffixes. It is possible to
// have non-integers as suffixes.
//
// >>> df = pd.DataFrame({
// ... 'famid': [1, 1, 1, 2, 2, 2, 3, 3, 3],
// ... 'birth': [1, 2, 3, 1, 2, 3, 1, 2, 3],
// ... 'ht_one': [2.8, 2.9, 2.2, 2, 1.8, 1.9, 2.2, 2.3, 2.1],
// ... 'ht_two': [3.4, 3.8, 2.9, 3.2, 2.8, 2.4, 3.3, 3.4, 2.9]
// ... })
// >>> df
//
// famid birth ht_one ht_two
//
// 0 1 1 2.8 3.4
// 1 1 2 2.9 3.8
// 2 1 3 2.2 2.9
// 3 2 1 2.0 3.2
// 4 2 2 1.8 2.8
// 5 2 3 1.9 2.4
// 6 3 1 2.2 3.3
// 7 3 2 2.3 3.4
// 8 3 3 2.1 2.9
//
// >>> l = pd.wide_to_long(df, stubnames='ht', i=['famid', 'birth'], j='age',
// ... sep='_', suffix=r'\w+')
// >>> l
// ... # doctest: +NORMALIZE_WHITESPACE
//
// ht
//
// famid birth age
// 1 1 one 2.8
//
// two 3.4
// 2 one 2.9
// two 3.8
// 3 one 2.2
// two 2.9
//
// 2 1 one 2.0
//
// two 3.2
// 2 one 1.8
// two 2.8
// 3 one 1.9
// two 2.4
//
// 3 1 one 2.2
//
// two 3.3
// 2 one 2.3
// two 3.4
// 3 one 2.1
// two 2.9
//
//go:linkname WideToLong py.wide_to_long
func WideToLong(df *py.Object, stubnames *py.Object, i *py.Object, j *py.Object, sep *py.Object, suffix *py.Object) *py.Object
// Merge DataFrame or named Series objects with a database-style join.
//
// A named Series object is treated as a DataFrame with a single named column.
//
// The join is done on columns or indexes. If joining columns on
// columns, the DataFrame indexes *will be ignored*. Otherwise if joining indexes
// on indexes or indexes on a column or columns, the index will be passed on.
// When performing a cross merge, no column specifications to merge on are
// allowed.
//
// .. warning::
//
// If both key columns contain rows where the key is a null value, those
// rows will be matched against each other. This is different from usual SQL
// join behaviour and can lead to unexpected results.
//
// Parameters
// ----------
// left : DataFrame or named Series
// right : DataFrame or named Series
//
// Object to merge with.
//
// how : {'left', 'right', 'outer', 'inner', 'cross'}, default 'inner'
//
// Type of merge to be performed.
//
// * left: use only keys from left frame, similar to a SQL left outer join;
// preserve key order.
// * right: use only keys from right frame, similar to a SQL right outer join;
// preserve key order.
// * outer: use union of keys from both frames, similar to a SQL full outer
// join; sort keys lexicographically.
// * inner: use intersection of keys from both frames, similar to a SQL inner
// join; preserve the order of the left keys.
// * cross: creates the cartesian product from both frames, preserves the order
// of the left keys.
//
// on : label or list
//
// Column or index level names to join on. These must be found in both
// DataFrames. If `on` is None and not merging on indexes then this defaults
// to the intersection of the columns in both DataFrames.
//
// left_on : label or list, or array-like
//
// Column or index level names to join on in the left DataFrame. Can also
// be an array or list of arrays of the length of the left DataFrame.
// These arrays are treated as if they are columns.
//
// right_on : label or list, or array-like
//
// Column or index level names to join on in the right DataFrame. Can also
// be an array or list of arrays of the length of the right DataFrame.
// These arrays are treated as if they are columns.
//
// left_index : bool, default False
//
// Use the index from the left DataFrame as the join key(s). If it is a
// MultiIndex, the number of keys in the other DataFrame (either the index
// or a number of columns) must match the number of levels.
//
// right_index : bool, default False
//
// Use the index from the right DataFrame as the join key. Same caveats as
// left_index.
//
// sort : bool, default False
//
// Sort the join keys lexicographically in the result DataFrame. If False,
// the order of the join keys depends on the join type (how keyword).
//
// suffixes : list-like, default is ("_x", "_y")
//
// A length-2 sequence where each element is optionally a string
// indicating the suffix to add to overlapping column names in
// `left` and `right` respectively. Pass a value of `None` instead
// of a string to indicate that the column name from `left` or
// `right` should be left as-is, with no suffix. At least one of the
// values must not be None.
//
// copy : bool, default True
//
// If False, avoid copy if possible.
//
// .. note::
// The `copy` keyword will change behavior in pandas 3.0.
// `Copy-on-Write
// <https://pandas.pydata.org/docs/dev/user_guide/copy_on_write.html>`__
// will be enabled by default, which means that all methods with a
// `copy` keyword will use a lazy copy mechanism to defer the copy and
// ignore the `copy` keyword. The `copy` keyword will be removed in a
// future version of pandas.
//
// You can already get the future behavior and improvements through
// enabling copy on write ``pd.options.mode.copy_on_write = True``
//
// indicator : bool or str, default False
//
// If True, adds a column to the output DataFrame called "_merge" with
// information on the source of each row. The column can be given a different
// name by providing a string argument. The column will have a Categorical
// type with the value of "left_only" for observations whose merge key only
// appears in the left DataFrame, "right_only" for observations
// whose merge key only appears in the right DataFrame, and "both"
// if the observation's merge key is found in both DataFrames.
//
// validate : str, optional
//
// If specified, checks if merge is of specified type.
//
// * "one_to_one" or "1:1": check if merge keys are unique in both
// left and right datasets.
// * "one_to_many" or "1:m": check if merge keys are unique in left
// dataset.
// * "many_to_one" or "m:1": check if merge keys are unique in right
// dataset.
// * "many_to_many" or "m:m": allowed, but does not result in checks.
//
// Returns
// -------
// DataFrame
//
// A DataFrame of the two merged objects.
//
// See Also
// --------
// merge_ordered : Merge with optional filling/interpolation.
// merge_asof : Merge on nearest keys.
// DataFrame.join : Similar method using indices.
//
// Examples
// --------
// >>> df1 = pd.DataFrame({'lkey': ['foo', 'bar', 'baz', 'foo'],
// ... 'value': [1, 2, 3, 5]})
// >>> df2 = pd.DataFrame({'rkey': ['foo', 'bar', 'baz', 'foo'],
// ... 'value': [5, 6, 7, 8]})
// >>> df1
//
// lkey value
//
// 0 foo 1
// 1 bar 2
// 2 baz 3
// 3 foo 5
// >>> df2
//
// rkey value
//
// 0 foo 5
// 1 bar 6
// 2 baz 7
// 3 foo 8
//
// Merge df1 and df2 on the lkey and rkey columns. The value columns have
// the default suffixes, _x and _y, appended.
//
// >>> df1.merge(df2, left_on='lkey', right_on='rkey')
//
// lkey value_x rkey value_y
//
// 0 foo 1 foo 5
// 1 foo 1 foo 8
// 2 bar 2 bar 6
// 3 baz 3 baz 7
// 4 foo 5 foo 5
// 5 foo 5 foo 8
//
// Merge DataFrames df1 and df2 with specified left and right suffixes
// appended to any overlapping columns.
//
// >>> df1.merge(df2, left_on='lkey', right_on='rkey',
// ... suffixes=('_left', '_right'))
//
// lkey value_left rkey value_right
//
// 0 foo 1 foo 5
// 1 foo 1 foo 8
// 2 bar 2 bar 6
// 3 baz 3 baz 7
// 4 foo 5 foo 5
// 5 foo 5 foo 8
//
// Merge DataFrames df1 and df2, but raise an exception if the DataFrames have
// any overlapping columns.
//
// >>> df1.merge(df2, left_on='lkey', right_on='rkey', suffixes=(False, False))
// Traceback (most recent call last):
// ...
// ValueError: columns overlap but no suffix specified:
//
// Index(['value'], dtype='object')
//
// >>> df1 = pd.DataFrame({'a': ['foo', 'bar'], 'b': [1, 2]})
// >>> df2 = pd.DataFrame({'a': ['foo', 'baz'], 'c': [3, 4]})
// >>> df1
//
// a b
//
// 0 foo 1
// 1 bar 2
// >>> df2
//
// a c
//
// 0 foo 3
// 1 baz 4
//
// >>> df1.merge(df2, how='inner', on='a')
//
// a b c
//
// 0 foo 1 3
//
// >>> df1.merge(df2, how='left', on='a')
//
// a b c
//
// 0 foo 1 3.0
// 1 bar 2 NaN
//
// >>> df1 = pd.DataFrame({'left': ['foo', 'bar']})
// >>> df2 = pd.DataFrame({'right': [7, 8]})
// >>> df1
//
// left
//
// 0 foo
// 1 bar
// >>> df2
//
// right
//
// 0 7
// 1 8
//
// >>> df1.merge(df2, how='cross')
//
// left right
//
// 0 foo 7
// 1 foo 8
// 2 bar 7
// 3 bar 8
//
//go:linkname Merge py.merge
func Merge(left *py.Object, right *py.Object, how *py.Object, on *py.Object, leftOn *py.Object, rightOn *py.Object, leftIndex *py.Object, rightIndex *py.Object, sort *py.Object, suffixes *py.Object, copy *py.Object, indicator *py.Object, validate *py.Object) *py.Object
// Perform a merge by key distance.
//
// This is similar to a left-join except that we match on nearest
// key rather than equal keys. Both DataFrames must be sorted by the key.
//
// For each row in the left DataFrame:
//
// - A "backward" search selects the last row in the right DataFrame whose
// 'on' key is less than or equal to the left's key.
//
// - A "forward" search selects the first row in the right DataFrame whose
// 'on' key is greater than or equal to the left's key.
//
// - A "nearest" search selects the row in the right DataFrame whose 'on'
// key is closest in absolute distance to the left's key.
//
// Optionally match on equivalent keys with 'by' before searching with 'on'.
//
// Parameters
// ----------
// left : DataFrame or named Series
// right : DataFrame or named Series
// on : label
//
// Field name to join on. Must be found in both DataFrames.
// The data MUST be ordered. Furthermore this must be a numeric column,
// such as datetimelike, integer, or float. On or left_on/right_on
// must be given.
//
// left_on : label
//
// Field name to join on in left DataFrame.
//
// right_on : label
//
// Field name to join on in right DataFrame.
//
// left_index : bool
//
// Use the index of the left DataFrame as the join key.
//
// right_index : bool
//
// Use the index of the right DataFrame as the join key.
//
// by : column name or list of column names
//
// Match on these columns before performing merge operation.
//
// left_by : column name
//
// Field names to match on in the left DataFrame.
//
// right_by : column name
//
// Field names to match on in the right DataFrame.
//
// suffixes : 2-length sequence (tuple, list, ...)
//
// Suffix to apply to overlapping column names in the left and right
// side, respectively.
//
// tolerance : int or Timedelta, optional, default None
//
// Select asof tolerance within this range; must be compatible
// with the merge index.
//
// allow_exact_matches : bool, default True
//
// - If True, allow matching with the same 'on' value
// (i.e. less-than-or-equal-to / greater-than-or-equal-to)
// - If False, don't match the same 'on' value
// (i.e., strictly less-than / strictly greater-than).
//
// direction : 'backward' (default), 'forward', or 'nearest'
//
// Whether to search for prior, subsequent, or closest matches.
//
// Returns
// -------
// DataFrame
//
// See Also
// --------
// merge : Merge with a database-style join.
// merge_ordered : Merge with optional filling/interpolation.
//
// Examples
// --------
// >>> left = pd.DataFrame({"a": [1, 5, 10], "left_val": ["a", "b", "c"]})
// >>> left
//
// a left_val
//
// 0 1 a
// 1 5 b
// 2 10 c
//
// >>> right = pd.DataFrame({"a": [1, 2, 3, 6, 7], "right_val": [1, 2, 3, 6, 7]})
// >>> right
//
// a right_val
//
// 0 1 1
// 1 2 2
// 2 3 3
// 3 6 6
// 4 7 7
//
// >>> pd.merge_asof(left, right, on="a")
//
// a left_val right_val
//
// 0 1 a 1
// 1 5 b 3
// 2 10 c 7
//
// >>> pd.merge_asof(left, right, on="a", allow_exact_matches=False)
//
// a left_val right_val
//
// 0 1 a NaN
// 1 5 b 3.0
// 2 10 c 7.0
//
// >>> pd.merge_asof(left, right, on="a", direction="forward")
//
// a left_val right_val
//
// 0 1 a 1.0
// 1 5 b 6.0
// 2 10 c NaN
//
// >>> pd.merge_asof(left, right, on="a", direction="nearest")
//
// a left_val right_val
//
// 0 1 a 1
// 1 5 b 6
// 2 10 c 7
//
// We can use indexed DataFrames as well.
//
// >>> left = pd.DataFrame({"left_val": ["a", "b", "c"]}, index=[1, 5, 10])
// >>> left
//
// left_val
//
// 1 a
// 5 b
// 10 c
//
// >>> right = pd.DataFrame({"right_val": [1, 2, 3, 6, 7]}, index=[1, 2, 3, 6, 7])
// >>> right
//
// right_val
//
// 1 1
// 2 2
// 3 3
// 6 6
// 7 7
//
// >>> pd.merge_asof(left, right, left_index=True, right_index=True)
//
// left_val right_val
//
// 1 a 1
// 5 b 3
// 10 c 7
//
// # Here is a real-world times-series example
//
// >>> quotes = pd.DataFrame(
// ... {
// ... "time": [
// ... pd.Timestamp("2016-05-25 13:30:00.023"),
// ... pd.Timestamp("2016-05-25 13:30:00.023"),
// ... pd.Timestamp("2016-05-25 13:30:00.030"),
// ... pd.Timestamp("2016-05-25 13:30:00.041"),
// ... pd.Timestamp("2016-05-25 13:30:00.048"),
// ... pd.Timestamp("2016-05-25 13:30:00.049"),
// ... pd.Timestamp("2016-05-25 13:30:00.072"),
// ... pd.Timestamp("2016-05-25 13:30:00.075")
// ... ],
// ... "ticker": [
// ... "GOOG",
// ... "MSFT",
// ... "MSFT",
// ... "MSFT",
// ... "GOOG",
// ... "AAPL",
// ... "GOOG",
// ... "MSFT"
// ... ],
// ... "bid": [720.50, 51.95, 51.97, 51.99, 720.50, 97.99, 720.50, 52.01],
// ... "ask": [720.93, 51.96, 51.98, 52.00, 720.93, 98.01, 720.88, 52.03]
// ... }
// ... )
// >>> quotes
//
// time ticker bid ask
//
// 0 2016-05-25 13:30:00.023 GOOG 720.50 720.93
// 1 2016-05-25 13:30:00.023 MSFT 51.95 51.96
// 2 2016-05-25 13:30:00.030 MSFT 51.97 51.98
// 3 2016-05-25 13:30:00.041 MSFT 51.99 52.00
// 4 2016-05-25 13:30:00.048 GOOG 720.50 720.93
// 5 2016-05-25 13:30:00.049 AAPL 97.99 98.01
// 6 2016-05-25 13:30:00.072 GOOG 720.50 720.88
// 7 2016-05-25 13:30:00.075 MSFT 52.01 52.03
//
// >>> trades = pd.DataFrame(
// ... {
// ... "time": [
// ... pd.Timestamp("2016-05-25 13:30:00.023"),
// ... pd.Timestamp("2016-05-25 13:30:00.038"),
// ... pd.Timestamp("2016-05-25 13:30:00.048"),
// ... pd.Timestamp("2016-05-25 13:30:00.048"),
// ... pd.Timestamp("2016-05-25 13:30:00.048")
// ... ],
// ... "ticker": ["MSFT", "MSFT", "GOOG", "GOOG", "AAPL"],
// ... "price": [51.95, 51.95, 720.77, 720.92, 98.0],
// ... "quantity": [75, 155, 100, 100, 100]
// ... }
// ... )
// >>> trades
//
// time ticker price quantity
//
// 0 2016-05-25 13:30:00.023 MSFT 51.95 75
// 1 2016-05-25 13:30:00.038 MSFT 51.95 155
// 2 2016-05-25 13:30:00.048 GOOG 720.77 100
// 3 2016-05-25 13:30:00.048 GOOG 720.92 100
// 4 2016-05-25 13:30:00.048 AAPL 98.00 100
//
// # By default we are taking the asof of the quotes
//
// >>> pd.merge_asof(trades, quotes, on="time", by="ticker")
//
// time ticker price quantity bid ask
//
// 0 2016-05-25 13:30:00.023 MSFT 51.95 75 51.95 51.96
// 1 2016-05-25 13:30:00.038 MSFT 51.95 155 51.97 51.98
// 2 2016-05-25 13:30:00.048 GOOG 720.77 100 720.50 720.93
// 3 2016-05-25 13:30:00.048 GOOG 720.92 100 720.50 720.93
// 4 2016-05-25 13:30:00.048 AAPL 98.00 100 NaN NaN
//
// # We only asof within 2ms between the quote time and the trade time
//
// >>> pd.merge_asof(
// ... trades, quotes, on="time", by="ticker", tolerance=pd.Timedelta("2ms")
// ... )
//
// time ticker price quantity bid ask
//
// 0 2016-05-25 13:30:00.023 MSFT 51.95 75 51.95 51.96
// 1 2016-05-25 13:30:00.038 MSFT 51.95 155 NaN NaN
// 2 2016-05-25 13:30:00.048 GOOG 720.77 100 720.50 720.93
// 3 2016-05-25 13:30:00.048 GOOG 720.92 100 720.50 720.93
// 4 2016-05-25 13:30:00.048 AAPL 98.00 100 NaN NaN
//
// We only asof within 10ms between the quote time and the trade time
// and we exclude exact matches on time. However *prior* data will
// propagate forward
//
// >>> pd.merge_asof(
// ... trades,
// ... quotes,
// ... on="time",
// ... by="ticker",
// ... tolerance=pd.Timedelta("10ms"),
// ... allow_exact_matches=False
// ... )
//
// time ticker price quantity bid ask
//
// 0 2016-05-25 13:30:00.023 MSFT 51.95 75 NaN NaN
// 1 2016-05-25 13:30:00.038 MSFT 51.95 155 51.97 51.98
// 2 2016-05-25 13:30:00.048 GOOG 720.77 100 NaN NaN
// 3 2016-05-25 13:30:00.048 GOOG 720.92 100 NaN NaN
// 4 2016-05-25 13:30:00.048 AAPL 98.00 100 NaN NaN
//
//go:linkname MergeAsof py.merge_asof
func MergeAsof(left *py.Object, right *py.Object, on *py.Object, leftOn *py.Object, rightOn *py.Object, leftIndex *py.Object, rightIndex *py.Object, by *py.Object, leftBy *py.Object, rightBy *py.Object, suffixes *py.Object, tolerance *py.Object, allowExactMatches *py.Object, direction *py.Object) *py.Object
// Perform a merge for ordered data with optional filling/interpolation.
//
// Designed for ordered data like time series data. Optionally
// perform group-wise merge (see examples).
//
// Parameters
// ----------
// left : DataFrame or named Series
// right : DataFrame or named Series
// on : label or list
//
// Field names to join on. Must be found in both DataFrames.
//
// left_on : label or list, or array-like
//
// Field names to join on in left DataFrame. Can be a vector or list of
// vectors of the length of the DataFrame to use a particular vector as
// the join key instead of columns.
//
// right_on : label or list, or array-like
//
// Field names to join on in right DataFrame or vector/list of vectors per
// left_on docs.
//
// left_by : column name or list of column names
//
// Group left DataFrame by group columns and merge piece by piece with
// right DataFrame. Must be None if either left or right are a Series.
//
// right_by : column name or list of column names
//
// Group right DataFrame by group columns and merge piece by piece with
// left DataFrame. Must be None if either left or right are a Series.
//
// fill_method : {'ffill', None}, default None
//
// Interpolation method for data.
//
// suffixes : list-like, default is ("_x", "_y")
//
// A length-2 sequence where each element is optionally a string
// indicating the suffix to add to overlapping column names in
// `left` and `right` respectively. Pass a value of `None` instead
// of a string to indicate that the column name from `left` or
// `right` should be left as-is, with no suffix. At least one of the
// values must not be None.
//
// how : {'left', 'right', 'outer', 'inner'}, default 'outer'
// - left: use only keys from left frame (SQL: left outer join)
// - right: use only keys from right frame (SQL: right outer join)
// - outer: use union of keys from both frames (SQL: full outer join)
// - inner: use intersection of keys from both frames (SQL: inner join).
//
// Returns
// -------
// DataFrame
//
// The merged DataFrame output type will be the same as
// 'left', if it is a subclass of DataFrame.
//
// See Also
// --------
// merge : Merge with a database-style join.
// merge_asof : Merge on nearest keys.
//
// Examples
// --------
// >>> from pandas import merge_ordered
// >>> df1 = pd.DataFrame(
// ... {
// ... "key": ["a", "c", "e", "a", "c", "e"],
// ... "lvalue": [1, 2, 3, 1, 2, 3],
// ... "group": ["a", "a", "a", "b", "b", "b"]
// ... }
// ... )
// >>> df1
//
// key lvalue group
//
// 0 a 1 a
// 1 c 2 a
// 2 e 3 a
// 3 a 1 b
// 4 c 2 b
// 5 e 3 b
//
// >>> df2 = pd.DataFrame({"key": ["b", "c", "d"], "rvalue": [1, 2, 3]})
// >>> df2
//
// key rvalue
//
// 0 b 1
// 1 c 2
// 2 d 3
//
// >>> merge_ordered(df1, df2, fill_method="ffill", left_by="group")
//
// key lvalue group rvalue
//
// 0 a 1 a NaN
// 1 b 1 a 1.0
// 2 c 2 a 2.0
// 3 d 2 a 3.0
// 4 e 3 a 3.0
// 5 a 1 b NaN
// 6 b 1 b 1.0
// 7 c 2 b 2.0
// 8 d 2 b 3.0
// 9 e 3 b 3.0
//
//go:linkname MergeOrdered py.merge_ordered
func MergeOrdered(left *py.Object, right *py.Object, on *py.Object, leftOn *py.Object, rightOn *py.Object, leftBy *py.Object, rightBy *py.Object, fillMethod *py.Object, suffixes *py.Object, how *py.Object) *py.Object
// Compute a simple cross tabulation of two (or more) factors.
//
// By default, computes a frequency table of the factors unless an
// array of values and an aggregation function are passed.
//
// Parameters
// ----------
// index : array-like, Series, or list of arrays/Series
//
// Values to group by in the rows.
//
// columns : array-like, Series, or list of arrays/Series
//
// Values to group by in the columns.
//
// values : array-like, optional
//
// Array of values to aggregate according to the factors.
// Requires `aggfunc` be specified.
//
// rownames : sequence, default None
//
// If passed, must match number of row arrays passed.
//
// colnames : sequence, default None
//
// If passed, must match number of column arrays passed.
//
// aggfunc : function, optional
//
// If specified, requires `values` be specified as well.
//
// margins : bool, default False
//
// Add row/column margins (subtotals).
//
// margins_name : str, default 'All'
//
// Name of the row/column that will contain the totals
// when margins is True.
//
// dropna : bool, default True
//
// Do not include columns whose entries are all NaN.
//
// normalize : bool, {'all', 'index', 'columns'}, or {0,1}, default False
//
// Normalize by dividing all values by the sum of values.
//
// - If passed 'all' or `True`, will normalize over all values.
// - If passed 'index' will normalize over each row.
// - If passed 'columns' will normalize over each column.
// - If margins is `True`, will also normalize margin values.
//
// Returns
// -------
// DataFrame
//
// Cross tabulation of the data.
//
// See Also
// --------
// DataFrame.pivot : Reshape data based on column values.
// pivot_table : Create a pivot table as a DataFrame.
//
// Notes
// -----
// Any Series passed will have their name attributes used unless row or column
// names for the cross-tabulation are specified.
//
// Any input passed containing Categorical data will have **all** of its
// categories included in the cross-tabulation, even if the actual data does
// not contain any instances of a particular category.
//
// In the event that there aren't overlapping indexes an empty DataFrame will
// be returned.
//
// Reference :ref:`the user guide <reshaping.crosstabulations>` for more examples.
//
// Examples
// --------
// >>> a = np.array(["foo", "foo", "foo", "foo", "bar", "bar",
// ... "bar", "bar", "foo", "foo", "foo"], dtype=object)
// >>> b = np.array(["one", "one", "one", "two", "one", "one",
// ... "one", "two", "two", "two", "one"], dtype=object)
// >>> c = np.array(["dull", "dull", "shiny", "dull", "dull", "shiny",
// ... "shiny", "dull", "shiny", "shiny", "shiny"],
// ... dtype=object)
// >>> pd.crosstab(a, [b, c], rownames=['a'], colnames=['b', 'c'])
// b one two
// c dull shiny dull shiny
// a
// bar 1 2 1 0
// foo 2 2 1 2
//
// Here 'c' and 'f' are not represented in the data and will not be
// shown in the output because dropna is True by default. Set
// dropna=False to preserve categories with no data.
//
// >>> foo = pd.Categorical(['a', 'b'], categories=['a', 'b', 'c'])
// >>> bar = pd.Categorical(['d', 'e'], categories=['d', 'e', 'f'])
// >>> pd.crosstab(foo, bar)
// col_0 d e
// row_0
// a 1 0
// b 0 1
// >>> pd.crosstab(foo, bar, dropna=False)
// col_0 d e f
// row_0
// a 1 0 0
// b 0 1 0
// c 0 0 0
//
//go:linkname Crosstab py.crosstab
func Crosstab(index *py.Object, columns *py.Object, values *py.Object, rownames *py.Object, colnames *py.Object, aggfunc *py.Object, margins *py.Object, marginsName *py.Object, dropna *py.Object, normalize *py.Object) *py.Object
// Return reshaped DataFrame organized by given index / column values.
//
// Reshape data (produce a "pivot" table) based on column values. Uses
// unique values from specified `index` / `columns` to form axes of the
// resulting DataFrame. This function does not support data
// aggregation, multiple values will result in a MultiIndex in the
// columns. See the :ref:`User Guide <reshaping>` for more on reshaping.
//
// Parameters
// ----------
// data : DataFrame
// columns : str or object or a list of str
//
// Column to use to make new frame's columns.
//
// index : str or object or a list of str, optional
//
// Column to use to make new frame's index. If not given, uses existing index.
//
// values : str, object or a list of the previous, optional
//
// Column(s) to use for populating new frame's values. If not
// specified, all remaining columns will be used and the result will
// have hierarchically indexed columns.
//
// Returns
// -------
// DataFrame
//
// Returns reshaped DataFrame.
//
// Raises
// ------
// ValueError:
//
// When there are any `index`, `columns` combinations with multiple
// values. `DataFrame.pivot_table` when you need to aggregate.
//
// See Also
// --------
// DataFrame.pivot_table : Generalization of pivot that can handle
//
// duplicate values for one index/column pair.
//
// DataFrame.unstack : Pivot based on the index values instead of a
//
// column.
//
// wide_to_long : Wide panel to long format. Less flexible but more
//
// user-friendly than melt.
//
// Notes
// -----
// For finer-tuned control, see hierarchical indexing documentation along
// with the related stack/unstack methods.
//
// Reference :ref:`the user guide <reshaping.pivot>` for more examples.
//
// Examples
// --------
// >>> df = pd.DataFrame({'foo': ['one', 'one', 'one', 'two', 'two',
// ... 'two'],
// ... 'bar': ['A', 'B', 'C', 'A', 'B', 'C'],
// ... 'baz': [1, 2, 3, 4, 5, 6],
// ... 'zoo': ['x', 'y', 'z', 'q', 'w', 't']})
// >>> df
//
// foo bar baz zoo
//
// 0 one A 1 x
// 1 one B 2 y
// 2 one C 3 z
// 3 two A 4 q
// 4 two B 5 w
// 5 two C 6 t
//
// >>> df.pivot(index='foo', columns='bar', values='baz')
// bar A B C
// foo
// one 1 2 3
// two 4 5 6
//
// >>> df.pivot(index='foo', columns='bar')['baz']
// bar A B C
// foo
// one 1 2 3
// two 4 5 6
//
// >>> df.pivot(index='foo', columns='bar', values=['baz', 'zoo'])
//
// baz zoo
//
// bar A B C A B C
// foo
// one 1 2 3 x y z
// two 4 5 6 q w t
//
// You could also assign a list of column names or a list of index names.
//
// >>> df = pd.DataFrame({
// ... "lev1": [1, 1, 1, 2, 2, 2],
// ... "lev2": [1, 1, 2, 1, 1, 2],
// ... "lev3": [1, 2, 1, 2, 1, 2],
// ... "lev4": [1, 2, 3, 4, 5, 6],
// ... "values": [0, 1, 2, 3, 4, 5]})
// >>> df
//
// lev1 lev2 lev3 lev4 values
//
// 0 1 1 1 1 0
// 1 1 1 2 2 1
// 2 1 2 1 3 2
// 3 2 1 2 4 3
// 4 2 1 1 5 4
// 5 2 2 2 6 5
//
// >>> df.pivot(index="lev1", columns=["lev2", "lev3"], values="values")
// lev2 1 2
// lev3 1 2 1 2
// lev1
// 1 0.0 1.0 2.0 NaN
// 2 4.0 3.0 NaN 5.0
//
// >>> df.pivot(index=["lev1", "lev2"], columns=["lev3"], values="values")
//
// lev3 1 2
//
// lev1 lev2
//
// 1 1 0.0 1.0
// 2 2.0 NaN
// 2 1 4.0 3.0
// 2 NaN 5.0
//
// A ValueError is raised if there are any duplicates.
//
// >>> df = pd.DataFrame({"foo": ['one', 'one', 'two', 'two'],
// ... "bar": ['A', 'A', 'B', 'C'],
// ... "baz": [1, 2, 3, 4]})
// >>> df
//
// foo bar baz
//
// 0 one A 1
// 1 one A 2
// 2 two B 3
// 3 two C 4
//
// Notice that the first two rows are the same for our `index`
// and `columns` arguments.
//
// >>> df.pivot(index='foo', columns='bar', values='baz')
// Traceback (most recent call last):
//
// ...
//
// ValueError: Index contains duplicate entries, cannot reshape
//
//go:linkname Pivot py.pivot
func Pivot(data *py.Object) *py.Object
// Create a spreadsheet-style pivot table as a DataFrame.
//
// The levels in the pivot table will be stored in MultiIndex objects
// (hierarchical indexes) on the index and columns of the result DataFrame.
//
// Parameters
// ----------
// data : DataFrame
// values : list-like or scalar, optional
//
// Column or columns to aggregate.
//
// index : column, Grouper, array, or list of the previous
//
// Keys to group by on the pivot table index. If a list is passed,
// it can contain any of the other types (except list). If an array is
// passed, it must be the same length as the data and will be used in
// the same manner as column values.
//
// columns : column, Grouper, array, or list of the previous
//
// Keys to group by on the pivot table column. If a list is passed,
// it can contain any of the other types (except list). If an array is
// passed, it must be the same length as the data and will be used in
// the same manner as column values.
//
// aggfunc : function, list of functions, dict, default "mean"
//
// If a list of functions is passed, the resulting pivot table will have
// hierarchical columns whose top level are the function names
// (inferred from the function objects themselves).
// If a dict is passed, the key is column to aggregate and the value is
// function or list of functions. If ``margin=True``, aggfunc will be
// used to calculate the partial aggregates.
//
// fill_value : scalar, default None
//
// Value to replace missing values with (in the resulting pivot table,
// after aggregation).
//
// margins : bool, default False
//
// If ``margins=True``, special ``All`` columns and rows
// will be added with partial group aggregates across the categories
// on the rows and columns.
//
// dropna : bool, default True
//
// Do not include columns whose entries are all NaN. If True,
// rows with a NaN value in any column will be omitted before
// computing margins.
//
// margins_name : str, default 'All'
//
// Name of the row / column that will contain the totals
// when margins is True.
//
// observed : bool, default False
//
// This only applies if any of the groupers are Categoricals.
// If True: only show observed values for categorical groupers.
// If False: show all values for categorical groupers.
//
// .. deprecated:: 2.2.0
//
// The default value of ``False`` is deprecated and will change to
// ``True`` in a future version of pandas.
//
// sort : bool, default True
//
// Specifies if the result should be sorted.
//
// .. versionadded:: 1.3.0
//
// Returns
// -------
// DataFrame
//
// An Excel style pivot table.
//
// See Also
// --------
// DataFrame.pivot : Pivot without aggregation that can handle
//
// non-numeric data.
//
// DataFrame.melt: Unpivot a DataFrame from wide to long format,
//
// optionally leaving identifiers set.
//
// wide_to_long : Wide panel to long format. Less flexible but more
//
// user-friendly than melt.
//
// Notes
// -----
// Reference :ref:`the user guide <reshaping.pivot>` for more examples.
//
// Examples
// --------
// >>> df = pd.DataFrame({"A": ["foo", "foo", "foo", "foo", "foo",
// ... "bar", "bar", "bar", "bar"],
// ... "B": ["one", "one", "one", "two", "two",
// ... "one", "one", "two", "two"],
// ... "C": ["small", "large", "large", "small",
// ... "small", "large", "small", "small",
// ... "large"],
// ... "D": [1, 2, 2, 3, 3, 4, 5, 6, 7],
// ... "E": [2, 4, 5, 5, 6, 6, 8, 9, 9]})
// >>> df
//
// A B C D E
//
// 0 foo one small 1 2
// 1 foo one large 2 4
// 2 foo one large 2 5
// 3 foo two small 3 5
// 4 foo two small 3 6
// 5 bar one large 4 6
// 6 bar one small 5 8
// 7 bar two small 6 9
// 8 bar two large 7 9
//
// This first example aggregates values by taking the sum.
//
// >>> table = pd.pivot_table(df, values='D', index=['A', 'B'],
// ... columns=['C'], aggfunc="sum")
// >>> table
// C large small
// A B
// bar one 4.0 5.0
//
// two 7.0 6.0
//
// foo one 4.0 1.0
//
// two NaN 6.0
//
// We can also fill missing values using the `fill_value` parameter.
//
// >>> table = pd.pivot_table(df, values='D', index=['A', 'B'],
// ... columns=['C'], aggfunc="sum", fill_value=0)
// >>> table
// C large small
// A B
// bar one 4 5
//
// two 7 6
//
// foo one 4 1
//
// two 0 6
//
// The next example aggregates by taking the mean across multiple columns.
//
// >>> table = pd.pivot_table(df, values=['D', 'E'], index=['A', 'C'],
// ... aggfunc={'D': "mean", 'E': "mean"})
// >>> table
//
// D E
//
// A C
// bar large 5.500000 7.500000
//
// small 5.500000 8.500000
//
// foo large 2.000000 4.500000
//
// small 2.333333 4.333333
//
// We can also calculate multiple types of aggregations for any given
// value column.
//
// >>> table = pd.pivot_table(df, values=['D', 'E'], index=['A', 'C'],
// ... aggfunc={'D': "mean",
// ... 'E': ["min", "max", "mean"]})
// >>> table
//
// D E
// mean max mean min
//
// A C
// bar large 5.500000 9 7.500000 6
//
// small 5.500000 9 8.500000 8
//
// foo large 2.000000 5 4.500000 4
//
// small 2.333333 6 4.333333 2
//
//go:linkname PivotTable py.pivot_table
func PivotTable(data *py.Object, values *py.Object, index *py.Object, columns *py.Object, aggfunc *py.Object, fillValue *py.Object, margins *py.Object, dropna *py.Object, marginsName *py.Object, observed *py.Object, sort *py.Object) *py.Object
// Convert categorical variable into dummy/indicator variables.
//
// Each variable is converted in as many 0/1 variables as there are different
// values. Columns in the output are each named after a value; if the input is
// a DataFrame, the name of the original variable is prepended to the value.
//
// Parameters
// ----------
// data : array-like, Series, or DataFrame
//
// Data of which to get dummy indicators.
//
// prefix : str, list of str, or dict of str, default None
//
// String to append DataFrame column names.
// Pass a list with length equal to the number of columns
// when calling get_dummies on a DataFrame. Alternatively, `prefix`
// can be a dictionary mapping column names to prefixes.
//
// prefix_sep : str, default '_'
//
// If appending prefix, separator/delimiter to use. Or pass a
// list or dictionary as with `prefix`.
//
// dummy_na : bool, default False
//
// Add a column to indicate NaNs, if False NaNs are ignored.
//
// columns : list-like, default None
//
// Column names in the DataFrame to be encoded.
// If `columns` is None then all the columns with
// `object`, `string`, or `category` dtype will be converted.
//
// sparse : bool, default False
//
// Whether the dummy-encoded columns should be backed by
// a :class:`SparseArray` (True) or a regular NumPy array (False).
//
// drop_first : bool, default False
//
// Whether to get k-1 dummies out of k categorical levels by removing the
// first level.
//
// dtype : dtype, default bool
//
// Data type for new columns. Only a single dtype is allowed.
//
// Returns
// -------
// DataFrame
//
// Dummy-coded data. If `data` contains other columns than the
// dummy-coded one(s), these will be prepended, unaltered, to the result.
//
// See Also
// --------
// Series.str.get_dummies : Convert Series of strings to dummy codes.
// :func:`~pandas.from_dummies` : Convert dummy codes to categorical “DataFrame“.
//
// Notes
// -----
// Reference :ref:`the user guide <reshaping.dummies>` for more examples.
//
// Examples
// --------
// >>> s = pd.Series(list('abca'))
//
// >>> pd.get_dummies(s)
//
// a b c
//
// 0 True False False
// 1 False True False
// 2 False False True
// 3 True False False
//
// >>> s1 = ['a', 'b', np.nan]
//
// >>> pd.get_dummies(s1)
//
// a b
//
// 0 True False
// 1 False True
// 2 False False
//
// >>> pd.get_dummies(s1, dummy_na=True)
//
// a b NaN
//
// 0 True False False
// 1 False True False
// 2 False False True
//
// >>> df = pd.DataFrame({'A': ['a', 'b', 'a'], 'B': ['b', 'a', 'c'],
// ... 'C': [1, 2, 3]})
//
// >>> pd.get_dummies(df, prefix=['col1', 'col2'])
//
// C col1_a col1_b col2_a col2_b col2_c
//
// 0 1 True False False True False
// 1 2 False True True False False
// 2 3 True False False False True
//
// >>> pd.get_dummies(pd.Series(list('abcaa')))
//
// a b c
//
// 0 True False False
// 1 False True False
// 2 False False True
// 3 True False False
// 4 True False False
//
// >>> pd.get_dummies(pd.Series(list('abcaa')), drop_first=True)
//
// b c
//
// 0 False False
// 1 True False
// 2 False True
// 3 False False
// 4 False False
//
// >>> pd.get_dummies(pd.Series(list('abc')), dtype=float)
//
// a b c
//
// 0 1.0 0.0 0.0
// 1 0.0 1.0 0.0
// 2 0.0 0.0 1.0
//
//go:linkname GetDummies py.get_dummies
func GetDummies(data *py.Object, prefix *py.Object, prefixSep *py.Object, dummyNa *py.Object, columns *py.Object, sparse *py.Object, dropFirst *py.Object, dtype *py.Object) *py.Object
// Create a categorical “DataFrame“ from a “DataFrame“ of dummy variables.
//
// Inverts the operation performed by :func:`~pandas.get_dummies`.
//
// .. versionadded:: 1.5.0
//
// Parameters
// ----------
// data : DataFrame
//
// Data which contains dummy-coded variables in form of integer columns of
// 1's and 0's.
//
// sep : str, default None
//
// Separator used in the column names of the dummy categories they are
// character indicating the separation of the categorical names from the prefixes.
// For example, if your column names are 'prefix_A' and 'prefix_B',
// you can strip the underscore by specifying sep='_'.
//
// default_category : None, Hashable or dict of Hashables, default None
//
// The default category is the implied category when a value has none of the
// listed categories specified with a one, i.e. if all dummies in a row are
// zero. Can be a single value for all variables or a dict directly mapping
// the default categories to a prefix of a variable.
//
// Returns
// -------
// DataFrame
//
// Categorical data decoded from the dummy input-data.
//
// Raises
// ------
// ValueError
// - When the input “DataFrame“ “data“ contains NA values.
// - When the input “DataFrame“ “data“ contains column names with separators
// that do not match the separator specified with “sep“.
// - When a “dict“ passed to “default_category“ does not include an implied
// category for each prefix.
// - When a value in “data“ has more than one category assigned to it.
// - When “default_category=None“ and a value in “data“ has no category
// assigned to it.
//
// TypeError
// - When the input “data“ is not of type “DataFrame“.
// - When the input “DataFrame“ “data“ contains non-dummy data.
// - When the passed “sep“ is of a wrong data type.
// - When the passed “default_category“ is of a wrong data type.
//
// See Also
// --------
// :func:`~pandas.get_dummies` : Convert “Series“ or “DataFrame“ to dummy codes.
// :class:`~pandas.Categorical` : Represent a categorical variable in classic.
//
// Notes
// -----
// The columns of the passed dummy data should only include 1's and 0's,
// or boolean values.
//
// Examples
// --------
// >>> df = pd.DataFrame({"a": [1, 0, 0, 1], "b": [0, 1, 0, 0],
// ... "c": [0, 0, 1, 0]})
//
// >>> df
//
// a b c
//
// 0 1 0 0
// 1 0 1 0
// 2 0 0 1
// 3 1 0 0
//
// >>> pd.from_dummies(df)
// 0 a
// 1 b
// 2 c
// 3 a
//
// >>> df = pd.DataFrame({"col1_a": [1, 0, 1], "col1_b": [0, 1, 0],
// ... "col2_a": [0, 1, 0], "col2_b": [1, 0, 0],
// ... "col2_c": [0, 0, 1]})
//
// >>> df
//
// col1_a col1_b col2_a col2_b col2_c
//
// 0 1 0 0 1 0
// 1 0 1 1 0 0
// 2 1 0 0 0 1
//
// >>> pd.from_dummies(df, sep="_")
//
// col1 col2
//
// 0 a b
// 1 b a
// 2 a c
//
// >>> df = pd.DataFrame({"col1_a": [1, 0, 0], "col1_b": [0, 1, 0],
// ... "col2_a": [0, 1, 0], "col2_b": [1, 0, 0],
// ... "col2_c": [0, 0, 0]})
//
// >>> df
//
// col1_a col1_b col2_a col2_b col2_c
//
// 0 1 0 0 1 0
// 1 0 1 1 0 0
// 2 0 0 0 0 0
//
// >>> pd.from_dummies(df, sep="_", default_category={"col1": "d", "col2": "e"})
//
// col1 col2
//
// 0 a b
// 1 b a
// 2 d e
//
//go:linkname FromDummies py.from_dummies
func FromDummies(data *py.Object, sep *py.Object, defaultCategory *py.Object) *py.Object
// Bin values into discrete intervals.
//
// Use `cut` when you need to segment and sort data values into bins. This
// function is also useful for going from a continuous variable to a
// categorical variable. For example, `cut` could convert ages to groups of
// age ranges. Supports binning into an equal number of bins, or a
// pre-specified array of bins.
//
// Parameters
// ----------
// x : array-like
//
// The input array to be binned. Must be 1-dimensional.
//
// bins : int, sequence of scalars, or IntervalIndex
//
// The criteria to bin by.
//
// * int : Defines the number of equal-width bins in the range of `x`. The
// range of `x` is extended by .1% on each side to include the minimum
// and maximum values of `x`.
// * sequence of scalars : Defines the bin edges allowing for non-uniform
// width. No extension of the range of `x` is done.
// * IntervalIndex : Defines the exact bins to be used. Note that
// IntervalIndex for `bins` must be non-overlapping.
//
// right : bool, default True
//
// Indicates whether `bins` includes the rightmost edge or not. If
// ``right == True`` (the default), then the `bins` ``[1, 2, 3, 4]``
// indicate (1,2], (2,3], (3,4]. This argument is ignored when
// `bins` is an IntervalIndex.
//
// labels : array or False, default None
//
// Specifies the labels for the returned bins. Must be the same length as
// the resulting bins. If False, returns only integer indicators of the
// bins. This affects the type of the output container (see below).
// This argument is ignored when `bins` is an IntervalIndex. If True,
// raises an error. When `ordered=False`, labels must be provided.
//
// retbins : bool, default False
//
// Whether to return the bins or not. Useful when bins is provided
// as a scalar.
//
// precision : int, default 3
//
// The precision at which to store and display the bins labels.
//
// include_lowest : bool, default False
//
// Whether the first interval should be left-inclusive or not.
//
// duplicates : {default 'raise', 'drop'}, optional
//
// If bin edges are not unique, raise ValueError or drop non-uniques.
//
// ordered : bool, default True
//
// Whether the labels are ordered or not. Applies to returned types
// Categorical and Series (with Categorical dtype). If True,
// the resulting categorical will be ordered. If False, the resulting
// categorical will be unordered (labels must be provided).
//
// Returns
// -------
// out : Categorical, Series, or ndarray
//
// An array-like object representing the respective bin for each value
// of `x`. The type depends on the value of `labels`.
//
// * None (default) : returns a Series for Series `x` or a
// Categorical for all other inputs. The values stored within
// are Interval dtype.
//
// * sequence of scalars : returns a Series for Series `x` or a
// Categorical for all other inputs. The values stored within
// are whatever the type in the sequence is.
//
// * False : returns an ndarray of integers.
//
// bins : numpy.ndarray or IntervalIndex.
//
// The computed or specified bins. Only returned when `retbins=True`.
// For scalar or sequence `bins`, this is an ndarray with the computed
// bins. If set `duplicates=drop`, `bins` will drop non-unique bin. For
// an IntervalIndex `bins`, this is equal to `bins`.
//
// See Also
// --------
// qcut : Discretize variable into equal-sized buckets based on rank
//
// or based on sample quantiles.
//
// Categorical : Array type for storing data that come from a
//
// fixed set of values.
//
// Series : One-dimensional array with axis labels (including time series).
// IntervalIndex : Immutable Index implementing an ordered, sliceable set.
//
// Notes
// -----
// Any NA values will be NA in the result. Out of bounds values will be NA in
// the resulting Series or Categorical object.
//
// Reference :ref:`the user guide <reshaping.tile.cut>` for more examples.
//
// Examples
// --------
// Discretize into three equal-sized bins.
//
// >>> pd.cut(np.array([1, 7, 5, 4, 6, 3]), 3)
// ... # doctest: +ELLIPSIS
// [(0.994, 3.0], (5.0, 7.0], (3.0, 5.0], (3.0, 5.0], (5.0, 7.0], ...
// Categories (3, interval[float64, right]): [(0.994, 3.0] < (3.0, 5.0] ...
//
// >>> pd.cut(np.array([1, 7, 5, 4, 6, 3]), 3, retbins=True)
// ... # doctest: +ELLIPSIS
// ([(0.994, 3.0], (5.0, 7.0], (3.0, 5.0], (3.0, 5.0], (5.0, 7.0], ...
// Categories (3, interval[float64, right]): [(0.994, 3.0] < (3.0, 5.0] ...
// array([0.994, 3. , 5. , 7. ]))
//
// Discovers the same bins, but assign them specific labels. Notice that
// the returned Categorical's categories are `labels` and is ordered.
//
// >>> pd.cut(np.array([1, 7, 5, 4, 6, 3]),
// ... 3, labels=["bad", "medium", "good"])
// ['bad', 'good', 'medium', 'medium', 'good', 'bad']
// Categories (3, object): ['bad' < 'medium' < 'good']
//
// “ordered=False“ will result in unordered categories when labels are passed.
// This parameter can be used to allow non-unique labels:
//
// >>> pd.cut(np.array([1, 7, 5, 4, 6, 3]), 3,
// ... labels=["B", "A", "B"], ordered=False)
// ['B', 'B', 'A', 'A', 'B', 'B']
// Categories (2, object): ['A', 'B']
//
// “labels=False“ implies you just want the bins back.
//
// >>> pd.cut([0, 1, 1, 2], bins=4, labels=False)
// array([0, 1, 1, 3])
//
// Passing a Series as an input returns a Series with categorical dtype:
//
// >>> s = pd.Series(np.array([2, 4, 6, 8, 10]),
// ... index=['a', 'b', 'c', 'd', 'e'])
// >>> pd.cut(s, 3)
// ... # doctest: +ELLIPSIS
// a (1.992, 4.667]
// b (1.992, 4.667]
// c (4.667, 7.333]
// d (7.333, 10.0]
// e (7.333, 10.0]
// dtype: category
// Categories (3, interval[float64, right]): [(1.992, 4.667] < (4.667, ...
//
// Passing a Series as an input returns a Series with mapping value.
// It is used to map numerically to intervals based on bins.
//
// >>> s = pd.Series(np.array([2, 4, 6, 8, 10]),
// ... index=['a', 'b', 'c', 'd', 'e'])
// >>> pd.cut(s, [0, 2, 4, 6, 8, 10], labels=False, retbins=True, right=False)
// ... # doctest: +ELLIPSIS
// (a 1.0
//
// b 2.0
// c 3.0
// d 4.0
// e NaN
// dtype: float64,
// array([ 0, 2, 4, 6, 8, 10]))
//
// # Use `drop` optional when bins is not unique
//
// >>> pd.cut(s, [0, 2, 4, 6, 10, 10], labels=False, retbins=True,
// ... right=False, duplicates='drop')
// ... # doctest: +ELLIPSIS
// (a 1.0
//
// b 2.0
// c 3.0
// d 3.0
// e NaN
// dtype: float64,
// array([ 0, 2, 4, 6, 10]))
//
// Passing an IntervalIndex for `bins` results in those categories exactly.
// Notice that values not covered by the IntervalIndex are set to NaN. 0
// is to the left of the first bin (which is closed on the right), and 1.5
// falls between two bins.
//
// >>> bins = pd.IntervalIndex.from_tuples([(0, 1), (2, 3), (4, 5)])
// >>> pd.cut([0, 0.5, 1.5, 2.5, 4.5], bins)
// [NaN, (0.0, 1.0], NaN, (2.0, 3.0], (4.0, 5.0]]
// Categories (3, interval[int64, right]): [(0, 1] < (2, 3] < (4, 5]]
//
//go:linkname Cut py.cut
func Cut(x *py.Object, bins *py.Object, right *py.Object, labels *py.Object, retbins *py.Object, precision *py.Object, includeLowest *py.Object, duplicates *py.Object, ordered *py.Object) *py.Object
// Quantile-based discretization function.
//
// Discretize variable into equal-sized buckets based on rank or based
// on sample quantiles. For example 1000 values for 10 quantiles would
// produce a Categorical object indicating quantile membership for each data point.
//
// Parameters
// ----------
// x : 1d ndarray or Series
// q : int or list-like of float
//
// Number of quantiles. 10 for deciles, 4 for quartiles, etc. Alternately
// array of quantiles, e.g. [0, .25, .5, .75, 1.] for quartiles.
//
// labels : array or False, default None
//
// Used as labels for the resulting bins. Must be of the same length as
// the resulting bins. If False, return only integer indicators of the
// bins. If True, raises an error.
//
// retbins : bool, optional
//
// Whether to return the (bins, labels) or not. Can be useful if bins
// is given as a scalar.
//
// precision : int, optional
//
// The precision at which to store and display the bins labels.
//
// duplicates : {default 'raise', 'drop'}, optional
//
// If bin edges are not unique, raise ValueError or drop non-uniques.
//
// Returns
// -------
// out : Categorical or Series or array of integers if labels is False
//
// The return type (Categorical or Series) depends on the input: a Series
// of type category if input is a Series else Categorical. Bins are
// represented as categories when categorical data is returned.
//
// bins : ndarray of floats
//
// Returned only if `retbins` is True.
//
// Notes
// -----
// Out of bounds values will be NA in the resulting Categorical object
//
// Examples
// --------
// >>> pd.qcut(range(5), 4)
// ... # doctest: +ELLIPSIS
// [(-0.001, 1.0], (-0.001, 1.0], (1.0, 2.0], (2.0, 3.0], (3.0, 4.0]]
// Categories (4, interval[float64, right]): [(-0.001, 1.0] < (1.0, 2.0] ...
//
// >>> pd.qcut(range(5), 3, labels=["good", "medium", "bad"])
// ... # doctest: +SKIP
// [good, good, medium, bad, bad]
// Categories (3, object): [good < medium < bad]
//
// >>> pd.qcut(range(5), 4, labels=False)
// array([0, 0, 1, 2, 3])
//
//go:linkname Qcut py.qcut
func Qcut(x *py.Object, q *py.Object, labels *py.Object, retbins *py.Object, precision *py.Object, duplicates *py.Object) *py.Object
// Read a table of fixed-width formatted lines into DataFrame.
//
// Also supports optionally iterating or breaking of the file
// into chunks.
//
// Additional help can be found in the `online docs for IO Tools
// <https://pandas.pydata.org/pandas-docs/stable/user_guide/io.html>`_.
//
// Parameters
// ----------
// filepath_or_buffer : str, path object, or file-like object
//
// String, path object (implementing ``os.PathLike[str]``), or file-like
// object implementing a text ``read()`` function.The string could be a URL.
// Valid URL schemes include http, ftp, s3, and file. For file URLs, a host is
// expected. A local file could be:
// ``file://localhost/path/to/table.csv``.
//
// colspecs : list of tuple (int, int) or 'infer'. optional
//
// A list of tuples giving the extents of the fixed-width
// fields of each line as half-open intervals (i.e., [from, to[ ).
// String value 'infer' can be used to instruct the parser to try
// detecting the column specifications from the first 100 rows of
// the data which are not being skipped via skiprows (default='infer').
//
// widths : list of int, optional
//
// A list of field widths which can be used instead of 'colspecs' if
// the intervals are contiguous.
//
// infer_nrows : int, default 100
//
// The number of rows to consider when letting the parser determine the
// `colspecs`.
//
// dtype_backend : {'numpy_nullable', 'pyarrow'}, default 'numpy_nullable'
//
// Back-end data type applied to the resultant :class:`DataFrame`
// (still experimental). Behaviour is as follows:
//
// * ``"numpy_nullable"``: returns nullable-dtype-backed :class:`DataFrame`
// (default).
// * ``"pyarrow"``: returns pyarrow-backed nullable :class:`ArrowDtype`
// DataFrame.
//
// .. versionadded:: 2.0
//
// **kwds : optional
//
// Optional keyword arguments can be passed to ``TextFileReader``.
//
// Returns
// -------
// DataFrame or TextFileReader
//
// A comma-separated values (csv) file is returned as two-dimensional
// data structure with labeled axes.
//
// See Also
// --------
// DataFrame.to_csv : Write DataFrame to a comma-separated values (csv) file.
// read_csv : Read a comma-separated values (csv) file into DataFrame.
//
// Examples
// --------
// >>> pd.read_fwf('data.csv') # doctest: +SKIP
//
//go:linkname ReadFwf py.read_fwf
func ReadFwf(filepathOrBuffer *py.Object) *py.Object
// Read general delimited file into DataFrame.
//
// Also supports optionally iterating or breaking of the file
// into chunks.
//
// Additional help can be found in the online docs for
// `IO Tools <https://pandas.pydata.org/pandas-docs/stable/user_guide/io.html>`_.
//
// Parameters
// ----------
// filepath_or_buffer : str, path object or file-like object
//
// Any valid string path is acceptable. The string could be a URL. Valid
// URL schemes include http, ftp, s3, gs, and file. For file URLs, a host is
// expected. A local file could be: file://localhost/path/to/table.csv.
//
// If you want to pass in a path object, pandas accepts any ``os.PathLike``.
//
// By file-like object, we refer to objects with a ``read()`` method, such as
// a file handle (e.g. via builtin ``open`` function) or ``StringIO``.
//
// sep : str, default '\\t' (tab-stop)
//
// Character or regex pattern to treat as the delimiter. If ``sep=None``, the
// C engine cannot automatically detect
// the separator, but the Python parsing engine can, meaning the latter will
// be used and automatically detect the separator from only the first valid
// row of the file by Python's builtin sniffer tool, ``csv.Sniffer``.
// In addition, separators longer than 1 character and different from
// ``'\s+'`` will be interpreted as regular expressions and will also force
// the use of the Python parsing engine. Note that regex delimiters are prone
// to ignoring quoted data. Regex example: ``'\r\t'``.
//
// delimiter : str, optional
//
// Alias for ``sep``.
//
// header : int, Sequence of int, 'infer' or None, default 'infer'
//
// Row number(s) containing column labels and marking the start of the
// data (zero-indexed). Default behavior is to infer the column names: if no ``names``
// are passed the behavior is identical to ``header=0`` and column
// names are inferred from the first line of the file, if column
// names are passed explicitly to ``names`` then the behavior is identical to
// ``header=None``. Explicitly pass ``header=0`` to be able to
// replace existing names. The header can be a list of integers that
// specify row locations for a :class:`~pandas.MultiIndex` on the columns
// e.g. ``[0, 1, 3]``. Intervening rows that are not specified will be
// skipped (e.g. 2 in this example is skipped). Note that this
// parameter ignores commented lines and empty lines if
// ``skip_blank_lines=True``, so ``header=0`` denotes the first line of
// data rather than the first line of the file.
//
// names : Sequence of Hashable, optional
//
// Sequence of column labels to apply. If the file contains a header row,
// then you should explicitly pass ``header=0`` to override the column names.
// Duplicates in this list are not allowed.
//
// index_col : Hashable, Sequence of Hashable or False, optional
//
// Column(s) to use as row label(s), denoted either by column labels or column
// indices. If a sequence of labels or indices is given, :class:`~pandas.MultiIndex`
// will be formed for the row labels.
//
// Note: ``index_col=False`` can be used to force pandas to *not* use the first
// column as the index, e.g., when you have a malformed file with delimiters at
// the end of each line.
//
// usecols : Sequence of Hashable or Callable, optional
//
// Subset of columns to select, denoted either by column labels or column indices.
// If list-like, all elements must either
// be positional (i.e. integer indices into the document columns) or strings
// that correspond to column names provided either by the user in ``names`` or
// inferred from the document header row(s). If ``names`` are given, the document
// header row(s) are not taken into account. For example, a valid list-like
// ``usecols`` parameter would be ``[0, 1, 2]`` or ``['foo', 'bar', 'baz']``.
// Element order is ignored, so ``usecols=[0, 1]`` is the same as ``[1, 0]``.
// To instantiate a :class:`~pandas.DataFrame` from ``data`` with element order
// preserved use ``pd.read_csv(data, usecols=['foo', 'bar'])[['foo', 'bar']]``
// for columns in ``['foo', 'bar']`` order or
// ``pd.read_csv(data, usecols=['foo', 'bar'])[['bar', 'foo']]``
// for ``['bar', 'foo']`` order.
//
// If callable, the callable function will be evaluated against the column
// names, returning names where the callable function evaluates to ``True``. An
// example of a valid callable argument would be ``lambda x: x.upper() in
// ['AAA', 'BBB', 'DDD']``. Using this parameter results in much faster
// parsing time and lower memory usage.
//
// dtype : dtype or dict of {Hashable : dtype}, optional
//
// Data type(s) to apply to either the whole dataset or individual columns.
// E.g., ``{'a': np.float64, 'b': np.int32, 'c': 'Int64'}``
// Use ``str`` or ``object`` together with suitable ``na_values`` settings
// to preserve and not interpret ``dtype``.
// If ``converters`` are specified, they will be applied INSTEAD
// of ``dtype`` conversion.
//
// .. versionadded:: 1.5.0
//
// Support for ``defaultdict`` was added. Specify a ``defaultdict`` as input where
// the default determines the ``dtype`` of the columns which are not explicitly
// listed.
//
// engine : {'c', 'python', 'pyarrow'}, optional
//
// Parser engine to use. The C and pyarrow engines are faster, while the python engine
// is currently more feature-complete. Multithreading is currently only supported by
// the pyarrow engine.
//
// .. versionadded:: 1.4.0
//
// The 'pyarrow' engine was added as an *experimental* engine, and some features
// are unsupported, or may not work correctly, with this engine.
//
// converters : dict of {Hashable : Callable}, optional
//
// Functions for converting values in specified columns. Keys can either
// be column labels or column indices.
//
// true_values : list, optional
//
// Values to consider as ``True`` in addition to case-insensitive variants of 'True'.
//
// false_values : list, optional
//
// Values to consider as ``False`` in addition to case-insensitive variants of 'False'.
//
// skipinitialspace : bool, default False
//
// Skip spaces after delimiter.
//
// skiprows : int, list of int or Callable, optional
//
// Line numbers to skip (0-indexed) or number of lines to skip (``int``)
// at the start of the file.
//
// If callable, the callable function will be evaluated against the row
// indices, returning ``True`` if the row should be skipped and ``False`` otherwise.
// An example of a valid callable argument would be ``lambda x: x in [0, 2]``.
//
// skipfooter : int, default 0
//
// Number of lines at bottom of file to skip (Unsupported with ``engine='c'``).
//
// nrows : int, optional
//
// Number of rows of file to read. Useful for reading pieces of large files.
//
// na_values : Hashable, Iterable of Hashable or dict of {Hashable : Iterable}, optional
//
// Additional strings to recognize as ``NA``/``NaN``. If ``dict`` passed, specific
// per-column ``NA`` values. By default the following values are interpreted as
// ``NaN``: " ", "#N/A", "#N/A N/A", "#NA", "-1.#IND", "-1.#QNAN", "-NaN", "-nan",
// "1.#IND", "1.#QNAN", "<NA>", "N/A", "NA", "NULL", "NaN", "None",
// "n/a", "nan", "null ".
//
// keep_default_na : bool, default True
//
// Whether or not to include the default ``NaN`` values when parsing the data.
// Depending on whether ``na_values`` is passed in, the behavior is as follows:
//
// * If ``keep_default_na`` is ``True``, and ``na_values`` are specified, ``na_values``
// is appended to the default ``NaN`` values used for parsing.
// * If ``keep_default_na`` is ``True``, and ``na_values`` are not specified, only
// the default ``NaN`` values are used for parsing.
// * If ``keep_default_na`` is ``False``, and ``na_values`` are specified, only
// the ``NaN`` values specified ``na_values`` are used for parsing.
// * If ``keep_default_na`` is ``False``, and ``na_values`` are not specified, no
// strings will be parsed as ``NaN``.
//
// Note that if ``na_filter`` is passed in as ``False``, the ``keep_default_na`` and
// ``na_values`` parameters will be ignored.
//
// na_filter : bool, default True
//
// Detect missing value markers (empty strings and the value of ``na_values``). In
// data without any ``NA`` values, passing ``na_filter=False`` can improve the
// performance of reading a large file.
//
// verbose : bool, default False
//
// Indicate number of ``NA`` values placed in non-numeric columns.
//
// .. deprecated:: 2.2.0
//
// skip_blank_lines : bool, default True
//
// If ``True``, skip over blank lines rather than interpreting as ``NaN`` values.
//
// parse_dates : bool, list of Hashable, list of lists or dict of {Hashable : list}, default False
//
// The behavior is as follows:
//
// * ``bool``. If ``True`` -> try parsing the index. Note: Automatically set to
// ``True`` if ``date_format`` or ``date_parser`` arguments have been passed.
// * ``list`` of ``int`` or names. e.g. If ``[1, 2, 3]`` -> try parsing columns 1, 2, 3
// each as a separate date column.
// * ``list`` of ``list``. e.g. If ``[[1, 3]]`` -> combine columns 1 and 3 and parse
// as a single date column. Values are joined with a space before parsing.
// * ``dict``, e.g. ``{'foo' : [1, 3]}`` -> parse columns 1, 3 as date and call
// result 'foo'. Values are joined with a space before parsing.
//
// If a column or index cannot be represented as an array of ``datetime``,
// say because of an unparsable value or a mixture of timezones, the column
// or index will be returned unaltered as an ``object`` data type. For
// non-standard ``datetime`` parsing, use :func:`~pandas.to_datetime` after
// :func:`~pandas.read_csv`.
//
// Note: A fast-path exists for iso8601-formatted dates.
//
// infer_datetime_format : bool, default False
//
// If ``True`` and ``parse_dates`` is enabled, pandas will attempt to infer the
// format of the ``datetime`` strings in the columns, and if it can be inferred,
// switch to a faster method of parsing them. In some cases this can increase
// the parsing speed by 5-10x.
//
// .. deprecated:: 2.0.0
// A strict version of this argument is now the default, passing it has no effect.
//
// keep_date_col : bool, default False
//
// If ``True`` and ``parse_dates`` specifies combining multiple columns then
// keep the original columns.
//
// date_parser : Callable, optional
//
// Function to use for converting a sequence of string columns to an array of
// ``datetime`` instances. The default uses ``dateutil.parser.parser`` to do the
// conversion. pandas will try to call ``date_parser`` in three different ways,
// advancing to the next if an exception occurs: 1) Pass one or more arrays
// (as defined by ``parse_dates``) as arguments; 2) concatenate (row-wise) the
// string values from the columns defined by ``parse_dates`` into a single array
// and pass that; and 3) call ``date_parser`` once for each row using one or
// more strings (corresponding to the columns defined by ``parse_dates``) as
// arguments.
//
// .. deprecated:: 2.0.0
// Use ``date_format`` instead, or read in as ``object`` and then apply
// :func:`~pandas.to_datetime` as-needed.
//
// date_format : str or dict of column -> format, optional
//
// Format to use for parsing dates when used in conjunction with ``parse_dates``.
// The strftime to parse time, e.g. :const:`"%d/%m/%Y"`. See
// `strftime documentation
// <https://docs.python.org/3/library/datetime.html
// #strftime-and-strptime-behavior>`_ for more information on choices, though
// note that :const:`"%f"` will parse all the way up to nanoseconds.
// You can also pass:
//
// - "ISO8601", to parse any `ISO8601 <https://en.wikipedia.org/wiki/ISO_8601>`_
// time string (not necessarily in exactly the same format);
// - "mixed", to infer the format for each element individually. This is risky,
// and you should probably use it along with `dayfirst`.
//
// .. versionadded:: 2.0.0
//
// dayfirst : bool, default False
//
// DD/MM format dates, international and European format.
//
// cache_dates : bool, default True
//
// If ``True``, use a cache of unique, converted dates to apply the ``datetime``
// conversion. May produce significant speed-up when parsing duplicate
// date strings, especially ones with timezone offsets.
//
// iterator : bool, default False
//
// Return ``TextFileReader`` object for iteration or getting chunks with
// ``get_chunk()``.
//
// chunksize : int, optional
//
// Number of lines to read from the file per chunk. Passing a value will cause the
// function to return a ``TextFileReader`` object for iteration.
// See the `IO Tools docs
// <https://pandas.pydata.org/pandas-docs/stable/io.html#io-chunking>`_
// for more information on ``iterator`` and ``chunksize``.
//
// compression : str or dict, default 'infer'
//
// For on-the-fly decompression of on-disk data. If 'infer' and 'filepath_or_buffer' is
// path-like, then detect compression from the following extensions: '.gz',
// '.bz2', '.zip', '.xz', '.zst', '.tar', '.tar.gz', '.tar.xz' or '.tar.bz2'
// (otherwise no compression).
// If using 'zip' or 'tar', the ZIP file must contain only one data file to be read in.
// Set to ``None`` for no decompression.
// Can also be a dict with key ``'method'`` set
// to one of {``'zip'``, ``'gzip'``, ``'bz2'``, ``'zstd'``, ``'xz'``, ``'tar'``} and
// other key-value pairs are forwarded to
// ``zipfile.ZipFile``, ``gzip.GzipFile``,
// ``bz2.BZ2File``, ``zstandard.ZstdDecompressor``, ``lzma.LZMAFile`` or
// ``tarfile.TarFile``, respectively.
// As an example, the following could be passed for Zstandard decompression using a
// custom compression dictionary:
// ``compression={'method': 'zstd', 'dict_data': my_compression_dict}``.
//
// .. versionadded:: 1.5.0
// Added support for `.tar` files.
//
// .. versionchanged:: 1.4.0 Zstandard support.
//
// thousands : str (length 1), optional
//
// Character acting as the thousands separator in numerical values.
//
// decimal : str (length 1), default '.'
//
// Character to recognize as decimal point (e.g., use ',' for European data).
//
// lineterminator : str (length 1), optional
//
// Character used to denote a line break. Only valid with C parser.
//
// quotechar : str (length 1), optional
//
// Character used to denote the start and end of a quoted item. Quoted
// items can include the ``delimiter`` and it will be ignored.
//
// quoting : {0 or csv.QUOTE_MINIMAL, 1 or csv.QUOTE_ALL, 2 or csv.QUOTE_NONNUMERIC, 3 or csv.QUOTE_NONE}, default csv.QUOTE_MINIMAL
//
// Control field quoting behavior per ``csv.QUOTE_*`` constants. Default is
// ``csv.QUOTE_MINIMAL`` (i.e., 0) which implies that only fields containing special
// characters are quoted (e.g., characters defined in ``quotechar``, ``delimiter``,
// or ``lineterminator``.
//
// doublequote : bool, default True
//
// When ``quotechar`` is specified and ``quoting`` is not ``QUOTE_NONE``, indicate
// whether or not to interpret two consecutive ``quotechar`` elements INSIDE a
// field as a single ``quotechar`` element.
//
// escapechar : str (length 1), optional
//
// Character used to escape other characters.
//
// comment : str (length 1), optional
//
// Character indicating that the remainder of line should not be parsed.
// If found at the beginning
// of a line, the line will be ignored altogether. This parameter must be a
// single character. Like empty lines (as long as ``skip_blank_lines=True``),
// fully commented lines are ignored by the parameter ``header`` but not by
// ``skiprows``. For example, if ``comment='#'``, parsing
// ``#empty\na,b,c\n1,2,3`` with ``header=0`` will result in ``'a,b,c'`` being
// treated as the header.
//
// encoding : str, optional, default 'utf-8'
//
// Encoding to use for UTF when reading/writing (ex. ``'utf-8'``). `List of Python
// standard encodings
// <https://docs.python.org/3/library/codecs.html#standard-encodings>`_ .
//
// encoding_errors : str, optional, default 'strict'
//
// How encoding errors are treated. `List of possible values
// <https://docs.python.org/3/library/codecs.html#error-handlers>`_ .
//
// .. versionadded:: 1.3.0
//
// dialect : str or csv.Dialect, optional
//
// If provided, this parameter will override values (default or not) for the
// following parameters: ``delimiter``, ``doublequote``, ``escapechar``,
// ``skipinitialspace``, ``quotechar``, and ``quoting``. If it is necessary to
// override values, a ``ParserWarning`` will be issued. See ``csv.Dialect``
// documentation for more details.
//
// on_bad_lines : {'error', 'warn', 'skip'} or Callable, default 'error'
//
// Specifies what to do upon encountering a bad line (a line with too many fields).
// Allowed values are :
//
// - ``'error'``, raise an Exception when a bad line is encountered.
// - ``'warn'``, raise a warning when a bad line is encountered and skip that line.
// - ``'skip'``, skip bad lines without raising or warning when they are encountered.
//
// .. versionadded:: 1.3.0
//
// .. versionadded:: 1.4.0
//
// - Callable, function with signature
// ``(bad_line: list[str]) -> list[str] | None`` that will process a single
// bad line. ``bad_line`` is a list of strings split by the ``sep``.
// If the function returns ``None``, the bad line will be ignored.
// If the function returns a new ``list`` of strings with more elements than
// expected, a ``ParserWarning`` will be emitted while dropping extra elements.
// Only supported when ``engine='python'``
//
// .. versionchanged:: 2.2.0
//
// - Callable, function with signature
// as described in `pyarrow documentation
// <https://arrow.apache.org/docs/python/generated/pyarrow.csv.ParseOptions.html
// #pyarrow.csv.ParseOptions.invalid_row_handler>`_ when ``engine='pyarrow'``
//
// delim_whitespace : bool, default False
//
// Specifies whether or not whitespace (e.g. ``' '`` or ``'\t'``) will be
// used as the ``sep`` delimiter. Equivalent to setting ``sep='\s+'``. If this option
// is set to ``True``, nothing should be passed in for the ``delimiter``
// parameter.
//
// .. deprecated:: 2.2.0
// Use ``sep="\s+"`` instead.
//
// low_memory : bool, default True
//
// Internally process the file in chunks, resulting in lower memory use
// while parsing, but possibly mixed type inference. To ensure no mixed
// types either set ``False``, or specify the type with the ``dtype`` parameter.
// Note that the entire file is read into a single :class:`~pandas.DataFrame`
// regardless, use the ``chunksize`` or ``iterator`` parameter to return the data in
// chunks. (Only valid with C parser).
//
// memory_map : bool, default False
//
// If a filepath is provided for ``filepath_or_buffer``, map the file object
// directly onto memory and access the data directly from there. Using this
// option can improve performance because there is no longer any I/O overhead.
//
// float_precision : {'high', 'legacy', 'round_trip'}, optional
//
// Specifies which converter the C engine should use for floating-point
// values. The options are ``None`` or ``'high'`` for the ordinary converter,
// ``'legacy'`` for the original lower precision pandas converter, and
// ``'round_trip'`` for the round-trip converter.
//
// storage_options : dict, optional
//
// Extra options that make sense for a particular storage connection, e.g.
// host, port, username, password, etc. For HTTP(S) URLs the key-value pairs
// are forwarded to ``urllib.request.Request`` as header options. For other
// URLs (e.g. starting with "s3://", and "gcs://") the key-value pairs are
// forwarded to ``fsspec.open``. Please see ``fsspec`` and ``urllib`` for more
// details, and for more examples on storage options refer `here
// <https://pandas.pydata.org/docs/user_guide/io.html?
// highlight=storage_options#reading-writing-remote-files>`_.
//
// dtype_backend : {'numpy_nullable', 'pyarrow'}, default 'numpy_nullable'
//
// Back-end data type applied to the resultant :class:`DataFrame`
// (still experimental). Behaviour is as follows:
//
// * ``"numpy_nullable"``: returns nullable-dtype-backed :class:`DataFrame`
// (default).
// * ``"pyarrow"``: returns pyarrow-backed nullable :class:`ArrowDtype`
// DataFrame.
//
// .. versionadded:: 2.0
//
// Returns
// -------
// DataFrame or TextFileReader
//
// A comma-separated values (csv) file is returned as two-dimensional
// data structure with labeled axes.
//
// See Also
// --------
// DataFrame.to_csv : Write DataFrame to a comma-separated values (csv) file.
// read_csv : Read a comma-separated values (csv) file into DataFrame.
// read_fwf : Read a table of fixed-width formatted lines into DataFrame.
//
// Examples
// --------
// >>> pd.read_table('data.csv') # doctest: +SKIP
//
//go:linkname ReadTable py.read_table
func ReadTable(filepathOrBuffer *py.Object) *py.Object
// Load pickled pandas object (or any object) from file.
//
// .. warning::
//
// Loading pickled data received from untrusted sources can be
// unsafe. See `here <https://docs.python.org/3/library/pickle.html>`__.
//
// Parameters
// ----------
// filepath_or_buffer : str, path object, or file-like object
//
// String, path object (implementing ``os.PathLike[str]``), or file-like
// object implementing a binary ``readlines()`` function.
// Also accepts URL. URL is not limited to S3 and GCS.
//
// compression : str or dict, default 'infer'
//
// For on-the-fly decompression of on-disk data. If 'infer' and 'filepath_or_buffer' is
// path-like, then detect compression from the following extensions: '.gz',
// '.bz2', '.zip', '.xz', '.zst', '.tar', '.tar.gz', '.tar.xz' or '.tar.bz2'
// (otherwise no compression).
// If using 'zip' or 'tar', the ZIP file must contain only one data file to be read in.
// Set to ``None`` for no decompression.
// Can also be a dict with key ``'method'`` set
// to one of {``'zip'``, ``'gzip'``, ``'bz2'``, ``'zstd'``, ``'xz'``, ``'tar'``} and
// other key-value pairs are forwarded to
// ``zipfile.ZipFile``, ``gzip.GzipFile``,
// ``bz2.BZ2File``, ``zstandard.ZstdDecompressor``, ``lzma.LZMAFile`` or
// ``tarfile.TarFile``, respectively.
// As an example, the following could be passed for Zstandard decompression using a
// custom compression dictionary:
// ``compression={'method': 'zstd', 'dict_data': my_compression_dict}``.
//
// .. versionadded:: 1.5.0
// Added support for `.tar` files.
//
// .. versionchanged:: 1.4.0 Zstandard support.
//
// storage_options : dict, optional
//
// Extra options that make sense for a particular storage connection, e.g.
// host, port, username, password, etc. For HTTP(S) URLs the key-value pairs
// are forwarded to ``urllib.request.Request`` as header options. For other
// URLs (e.g. starting with "s3://", and "gcs://") the key-value pairs are
// forwarded to ``fsspec.open``. Please see ``fsspec`` and ``urllib`` for more
// details, and for more examples on storage options refer `here
// <https://pandas.pydata.org/docs/user_guide/io.html?
// highlight=storage_options#reading-writing-remote-files>`_.
//
// Returns
// -------
// same type as object stored in file
//
// See Also
// --------
// DataFrame.to_pickle : Pickle (serialize) DataFrame object to file.
// Series.to_pickle : Pickle (serialize) Series object to file.
// read_hdf : Read HDF5 file into a DataFrame.
// read_sql : Read SQL query or database table into a DataFrame.
// read_parquet : Load a parquet object, returning a DataFrame.
//
// Notes
// -----
// read_pickle is only guaranteed to be backwards compatible to pandas 0.20.3
// provided the object was serialized with to_pickle.
//
// Examples
// --------
// >>> original_df = pd.DataFrame(
// ... {"foo": range(5), "bar": range(5, 10)}
// ... ) # doctest: +SKIP
// >>> original_df # doctest: +SKIP
//
// foo bar
//
// 0 0 5
// 1 1 6
// 2 2 7
// 3 3 8
// 4 4 9
// >>> pd.to_pickle(original_df, "./dummy.pkl") # doctest: +SKIP
//
// >>> unpickled_df = pd.read_pickle("./dummy.pkl") # doctest: +SKIP
// >>> unpickled_df # doctest: +SKIP
//
// foo bar
//
// 0 0 5
// 1 1 6
// 2 2 7
// 3 3 8
// 4 4 9
//
//go:linkname ReadPickle py.read_pickle
func ReadPickle(filepathOrBuffer *py.Object, compression *py.Object, storageOptions *py.Object) *py.Object
// Pickle (serialize) object to file.
//
// Parameters
// ----------
// obj : any object
//
// Any python object.
//
// filepath_or_buffer : str, path object, or file-like object
//
// String, path object (implementing ``os.PathLike[str]``), or file-like
// object implementing a binary ``write()`` function.
// Also accepts URL. URL has to be of S3 or GCS.
//
// compression : str or dict, default 'infer'
//
// For on-the-fly compression of the output data. If 'infer' and 'filepath_or_buffer' is
// path-like, then detect compression from the following extensions: '.gz',
// '.bz2', '.zip', '.xz', '.zst', '.tar', '.tar.gz', '.tar.xz' or '.tar.bz2'
// (otherwise no compression).
// Set to ``None`` for no compression.
// Can also be a dict with key ``'method'`` set
// to one of {``'zip'``, ``'gzip'``, ``'bz2'``, ``'zstd'``, ``'xz'``, ``'tar'``} and
// other key-value pairs are forwarded to
// ``zipfile.ZipFile``, ``gzip.GzipFile``,
// ``bz2.BZ2File``, ``zstandard.ZstdCompressor``, ``lzma.LZMAFile`` or
// ``tarfile.TarFile``, respectively.
// As an example, the following could be passed for faster compression and to create
// a reproducible gzip archive:
// ``compression={'method': 'gzip', 'compresslevel': 1, 'mtime': 1}``.
//
// .. versionadded:: 1.5.0
// Added support for `.tar` files.
//
// .. versionchanged:: 1.4.0 Zstandard support.
//
// protocol : int
//
// Int which indicates which protocol should be used by the pickler,
// default HIGHEST_PROTOCOL (see [1], paragraph 12.1.2). The possible
// values for this parameter depend on the version of Python. For Python
// 2.x, possible values are 0, 1, 2. For Python>=3.0, 3 is a valid value.
// For Python >= 3.4, 4 is a valid value. A negative value for the
// protocol parameter is equivalent to setting its value to
// HIGHEST_PROTOCOL.
//
// storage_options : dict, optional
//
// Extra options that make sense for a particular storage connection, e.g.
// host, port, username, password, etc. For HTTP(S) URLs the key-value pairs
// are forwarded to ``urllib.request.Request`` as header options. For other
// URLs (e.g. starting with "s3://", and "gcs://") the key-value pairs are
// forwarded to ``fsspec.open``. Please see ``fsspec`` and ``urllib`` for more
// details, and for more examples on storage options refer `here
// <https://pandas.pydata.org/docs/user_guide/io.html?
// highlight=storage_options#reading-writing-remote-files>`_.
//
// .. [1] https://docs.python.org/3/library/pickle.html
//
// See Also
// --------
// read_pickle : Load pickled pandas object (or any object) from file.
// DataFrame.to_hdf : Write DataFrame to an HDF5 file.
// DataFrame.to_sql : Write DataFrame to a SQL database.
// DataFrame.to_parquet : Write a DataFrame to the binary parquet format.
//
// Examples
// --------
// >>> original_df = pd.DataFrame({"foo": range(5), "bar": range(5, 10)}) # doctest: +SKIP
// >>> original_df # doctest: +SKIP
//
// foo bar
//
// 0 0 5
// 1 1 6
// 2 2 7
// 3 3 8
// 4 4 9
// >>> pd.to_pickle(original_df, "./dummy.pkl") # doctest: +SKIP
//
// >>> unpickled_df = pd.read_pickle("./dummy.pkl") # doctest: +SKIP
// >>> unpickled_df # doctest: +SKIP
//
// foo bar
//
// 0 0 5
// 1 1 6
// 2 2 7
// 3 3 8
// 4 4 9
//
//go:linkname ToPickle py.to_pickle
func ToPickle(obj *py.Object, filepathOrBuffer *py.Object, compression *py.Object, protocol *py.Object, storageOptions *py.Object) *py.Object
// Read from the store, close it if we opened it.
//
// Retrieve pandas object stored in file, optionally based on where
// criteria.
//
// .. warning::
//
// Pandas uses PyTables for reading and writing HDF5 files, which allows
// serializing object-dtype data with pickle when using the "fixed" format.
// Loading pickled data received from untrusted sources can be unsafe.
//
// See: https://docs.python.org/3/library/pickle.html for more.
//
// Parameters
// ----------
// path_or_buf : str, path object, pandas.HDFStore
//
// Any valid string path is acceptable. Only supports the local file system,
// remote URLs and file-like objects are not supported.
//
// If you want to pass in a path object, pandas accepts any
// ``os.PathLike``.
//
// Alternatively, pandas accepts an open :class:`pandas.HDFStore` object.
//
// key : object, optional
//
// The group identifier in the store. Can be omitted if the HDF file
// contains a single pandas object.
//
// mode : {'r', 'r+', 'a'}, default 'r'
//
// Mode to use when opening the file. Ignored if path_or_buf is a
// :class:`pandas.HDFStore`. Default is 'r'.
//
// errors : str, default 'strict'
//
// Specifies how encoding and decoding errors are to be handled.
// See the errors argument for :func:`open` for a full list
// of options.
//
// where : list, optional
//
// A list of Term (or convertible) objects.
//
// start : int, optional
//
// Row number to start selection.
//
// stop : int, optional
//
// Row number to stop selection.
//
// columns : list, optional
//
// A list of columns names to return.
//
// iterator : bool, optional
//
// Return an iterator object.
//
// chunksize : int, optional
//
// Number of rows to include in an iteration when using an iterator.
//
// **kwargs
//
// Additional keyword arguments passed to HDFStore.
//
// Returns
// -------
// object
//
// The selected object. Return type depends on the object stored.
//
// See Also
// --------
// DataFrame.to_hdf : Write a HDF file from a DataFrame.
// HDFStore : Low-level access to HDF files.
//
// Examples
// --------
// >>> df = pd.DataFrame([[1, 1.0, 'a']], columns=['x', 'y', 'z']) # doctest: +SKIP
// >>> df.to_hdf('./store.h5', 'data') # doctest: +SKIP
// >>> reread = pd.read_hdf('./store.h5') # doctest: +SKIP
//
//go:linkname ReadHdf py.read_hdf
func ReadHdf(pathOrBuf *py.Object, key *py.Object, mode *py.Object, errors *py.Object, where *py.Object, start *py.Object, stop *py.Object, columns *py.Object, iterator *py.Object, chunksize *py.Object) *py.Object
// Read SQL query or database table into a DataFrame.
//
// This function is a convenience wrapper around “read_sql_table“ and
// “read_sql_query“ (for backward compatibility). It will delegate
// to the specific function depending on the provided input. A SQL query
// will be routed to “read_sql_query“, while a database table name will
// be routed to “read_sql_table“. Note that the delegated function might
// have more specific notes about their functionality not listed here.
//
// Parameters
// ----------
// sql : str or SQLAlchemy Selectable (select or text object)
//
// SQL query to be executed or a table name.
//
// con : ADBC Connection, SQLAlchemy connectable, str, or sqlite3 connection
//
// ADBC provides high performance I/O with native type support, where available.
// Using SQLAlchemy makes it possible to use any DB supported by that
// library. If a DBAPI2 object, only sqlite3 is supported. The user is responsible
// for engine disposal and connection closure for the ADBC connection and
// SQLAlchemy connectable; str connections are closed automatically. See
// `here <https://docs.sqlalchemy.org/en/20/core/connections.html>`_.
//
// index_col : str or list of str, optional, default: None
//
// Column(s) to set as index(MultiIndex).
//
// coerce_float : bool, default True
//
// Attempts to convert values of non-string, non-numeric objects (like
// decimal.Decimal) to floating point, useful for SQL result sets.
//
// params : list, tuple or dict, optional, default: None
//
// List of parameters to pass to execute method. The syntax used
// to pass parameters is database driver dependent. Check your
// database driver documentation for which of the five syntax styles,
// described in PEP 249's paramstyle, is supported.
// Eg. for psycopg2, uses %(name)s so use params={'name' : 'value'}.
//
// parse_dates : list or dict, default: None
// - List of column names to parse as dates.
// - Dict of “{column_name: format string}“ where format string is
// strftime compatible in case of parsing string times, or is one of
// (D, s, ns, ms, us) in case of parsing integer timestamps.
// - Dict of “{column_name: arg dict}“, where the arg dict corresponds
// to the keyword arguments of :func:`pandas.to_datetime`
// Especially useful with databases without native Datetime support,
// such as SQLite.
//
// columns : list, default: None
//
// List of column names to select from SQL table (only used when reading
// a table).
//
// chunksize : int, default None
//
// If specified, return an iterator where `chunksize` is the
// number of rows to include in each chunk.
//
// dtype_backend : {'numpy_nullable', 'pyarrow'}, default 'numpy_nullable'
//
// Back-end data type applied to the resultant :class:`DataFrame`
// (still experimental). Behaviour is as follows:
//
// * ``"numpy_nullable"``: returns nullable-dtype-backed :class:`DataFrame`
// (default).
// * ``"pyarrow"``: returns pyarrow-backed nullable :class:`ArrowDtype`
// DataFrame.
//
// .. versionadded:: 2.0
//
// dtype : Type name or dict of columns
//
// Data type for data or columns. E.g. np.float64 or
// {'a': np.float64, 'b': np.int32, 'c': 'Int64'}.
// The argument is ignored if a table is passed instead of a query.
//
// .. versionadded:: 2.0.0
//
// Returns
// -------
// DataFrame or Iterator[DataFrame]
//
// See Also
// --------
// read_sql_table : Read SQL database table into a DataFrame.
// read_sql_query : Read SQL query into a DataFrame.
//
// Examples
// --------
// Read data from SQL via either a SQL query or a SQL tablename.
// When using a SQLite database only SQL queries are accepted,
// providing only the SQL tablename will result in an error.
//
// >>> from sqlite3 import connect
// >>> conn = connect(':memory:')
// >>> df = pd.DataFrame(data=[[0, '10/11/12'], [1, '12/11/10']],
// ... columns=['int_column', 'date_column'])
// >>> df.to_sql(name='test_data', con=conn)
// 2
//
// >>> pd.read_sql('SELECT int_column, date_column FROM test_data', conn)
//
// int_column date_column
//
// 0 0 10/11/12
// 1 1 12/11/10
//
// >>> pd.read_sql('test_data', 'postgres:///db_name') # doctest:+SKIP
//
// Apply date parsing to columns through the “parse_dates“ argument
// The “parse_dates“ argument calls “pd.to_datetime“ on the provided columns.
// Custom argument values for applying “pd.to_datetime“ on a column are specified
// via a dictionary format:
//
// >>> pd.read_sql('SELECT int_column, date_column FROM test_data',
// ... conn,
// ... parse_dates={"date_column": {"format": "%d/%m/%y"}})
//
// int_column date_column
//
// 0 0 2012-11-10
// 1 1 2010-11-12
//
// .. versionadded:: 2.2.0
//
// pandas now supports reading via ADBC drivers
//
// >>> from adbc_driver_postgresql import dbapi # doctest:+SKIP
// >>> with dbapi.connect('postgres:///db_name') as conn: # doctest:+SKIP
// ... pd.read_sql('SELECT int_column FROM test_data', conn)
//
// int_column
//
// 0 0
// 1 1
//
//go:linkname ReadSql py.read_sql
func ReadSql(sql *py.Object, con *py.Object, indexCol *py.Object, coerceFloat *py.Object, params *py.Object, parseDates *py.Object, columns *py.Object, chunksize *py.Object, dtypeBackend *py.Object, dtype *py.Object) *py.Object
// Read SQL query into a DataFrame.
//
// Returns a DataFrame corresponding to the result set of the query
// string. Optionally provide an `index_col` parameter to use one of the
// columns as the index, otherwise default integer index will be used.
//
// Parameters
// ----------
// sql : str SQL query or SQLAlchemy Selectable (select or text object)
//
// SQL query to be executed.
//
// con : SQLAlchemy connectable, str, or sqlite3 connection
//
// Using SQLAlchemy makes it possible to use any DB supported by that
// library. If a DBAPI2 object, only sqlite3 is supported.
//
// index_col : str or list of str, optional, default: None
//
// Column(s) to set as index(MultiIndex).
//
// coerce_float : bool, default True
//
// Attempts to convert values of non-string, non-numeric objects (like
// decimal.Decimal) to floating point. Useful for SQL result sets.
//
// params : list, tuple or mapping, optional, default: None
//
// List of parameters to pass to execute method. The syntax used
// to pass parameters is database driver dependent. Check your
// database driver documentation for which of the five syntax styles,
// described in PEP 249's paramstyle, is supported.
// Eg. for psycopg2, uses %(name)s so use params={'name' : 'value'}.
//
// parse_dates : list or dict, default: None
// - List of column names to parse as dates.
// - Dict of “{column_name: format string}“ where format string is
// strftime compatible in case of parsing string times, or is one of
// (D, s, ns, ms, us) in case of parsing integer timestamps.
// - Dict of “{column_name: arg dict}“, where the arg dict corresponds
// to the keyword arguments of :func:`pandas.to_datetime`
// Especially useful with databases without native Datetime support,
// such as SQLite.
//
// chunksize : int, default None
//
// If specified, return an iterator where `chunksize` is the number of
// rows to include in each chunk.
//
// dtype : Type name or dict of columns
//
// Data type for data or columns. E.g. np.float64 or
// {'a': np.float64, 'b': np.int32, 'c': 'Int64'}.
//
// .. versionadded:: 1.3.0
//
// dtype_backend : {'numpy_nullable', 'pyarrow'}, default 'numpy_nullable'
//
// Back-end data type applied to the resultant :class:`DataFrame`
// (still experimental). Behaviour is as follows:
//
// * ``"numpy_nullable"``: returns nullable-dtype-backed :class:`DataFrame`
// (default).
// * ``"pyarrow"``: returns pyarrow-backed nullable :class:`ArrowDtype`
// DataFrame.
//
// .. versionadded:: 2.0
//
// Returns
// -------
// DataFrame or Iterator[DataFrame]
//
// See Also
// --------
// read_sql_table : Read SQL database table into a DataFrame.
// read_sql : Read SQL query or database table into a DataFrame.
//
// Notes
// -----
// Any datetime values with time zone information parsed via the `parse_dates`
// parameter will be converted to UTC.
//
// Examples
// --------
// >>> from sqlalchemy import create_engine # doctest: +SKIP
// >>> engine = create_engine("sqlite:///database.db") # doctest: +SKIP
// >>> with engine.connect() as conn, conn.begin(): # doctest: +SKIP
// ... data = pd.read_sql_table("data", conn) # doctest: +SKIP
//
//go:linkname ReadSqlQuery py.read_sql_query
func ReadSqlQuery(sql *py.Object, con *py.Object, indexCol *py.Object, coerceFloat *py.Object, params *py.Object, parseDates *py.Object, chunksize *py.Object, dtype *py.Object, dtypeBackend *py.Object) *py.Object
// Read SQL database table into a DataFrame.
//
// Given a table name and a SQLAlchemy connectable, returns a DataFrame.
// This function does not support DBAPI connections.
//
// Parameters
// ----------
// table_name : str
//
// Name of SQL table in database.
//
// con : SQLAlchemy connectable or str
//
// A database URI could be provided as str.
// SQLite DBAPI connection mode not supported.
//
// schema : str, default None
//
// Name of SQL schema in database to query (if database flavor
// supports this). Uses default schema if None (default).
//
// index_col : str or list of str, optional, default: None
//
// Column(s) to set as index(MultiIndex).
//
// coerce_float : bool, default True
//
// Attempts to convert values of non-string, non-numeric objects (like
// decimal.Decimal) to floating point. Can result in loss of Precision.
//
// parse_dates : list or dict, default None
// - List of column names to parse as dates.
// - Dict of “{column_name: format string}“ where format string is
// strftime compatible in case of parsing string times or is one of
// (D, s, ns, ms, us) in case of parsing integer timestamps.
// - Dict of “{column_name: arg dict}“, where the arg dict corresponds
// to the keyword arguments of :func:`pandas.to_datetime`
// Especially useful with databases without native Datetime support,
// such as SQLite.
//
// columns : list, default None
//
// List of column names to select from SQL table.
//
// chunksize : int, default None
//
// If specified, returns an iterator where `chunksize` is the number of
// rows to include in each chunk.
//
// dtype_backend : {'numpy_nullable', 'pyarrow'}, default 'numpy_nullable'
//
// Back-end data type applied to the resultant :class:`DataFrame`
// (still experimental). Behaviour is as follows:
//
// * ``"numpy_nullable"``: returns nullable-dtype-backed :class:`DataFrame`
// (default).
// * ``"pyarrow"``: returns pyarrow-backed nullable :class:`ArrowDtype`
// DataFrame.
//
// .. versionadded:: 2.0
//
// Returns
// -------
// DataFrame or Iterator[DataFrame]
//
// A SQL table is returned as two-dimensional data structure with labeled
// axes.
//
// See Also
// --------
// read_sql_query : Read SQL query into a DataFrame.
// read_sql : Read SQL query or database table into a DataFrame.
//
// Notes
// -----
// Any datetime values with time zone information will be converted to UTC.
//
// Examples
// --------
// >>> pd.read_sql_table('table_name', 'postgres:///db_name') # doctest:+SKIP
//
//go:linkname ReadSqlTable py.read_sql_table
func ReadSqlTable(tableName *py.Object, con *py.Object, schema *py.Object, indexCol *py.Object, coerceFloat *py.Object, parseDates *py.Object, columns *py.Object, chunksize *py.Object, dtypeBackend *py.Object) *py.Object
// Read text from clipboard and pass to :func:`~pandas.read_csv`.
//
// Parses clipboard contents similar to how CSV files are parsed
// using :func:`~pandas.read_csv`.
//
// Parameters
// ----------
// sep : str, default '\\s+'
//
// A string or regex delimiter. The default of ``'\\s+'`` denotes
// one or more whitespace characters.
//
// dtype_backend : {'numpy_nullable', 'pyarrow'}, default 'numpy_nullable'
//
// Back-end data type applied to the resultant :class:`DataFrame`
// (still experimental). Behaviour is as follows:
//
// * ``"numpy_nullable"``: returns nullable-dtype-backed :class:`DataFrame`
// (default).
// * ``"pyarrow"``: returns pyarrow-backed nullable :class:`ArrowDtype`
// DataFrame.
//
// .. versionadded:: 2.0
//
// **kwargs
//
// See :func:`~pandas.read_csv` for the full argument list.
//
// Returns
// -------
// DataFrame
//
// A parsed :class:`~pandas.DataFrame` object.
//
// See Also
// --------
// DataFrame.to_clipboard : Copy object to the system clipboard.
// read_csv : Read a comma-separated values (csv) file into DataFrame.
// read_fwf : Read a table of fixed-width formatted lines into DataFrame.
//
// Examples
// --------
// >>> df = pd.DataFrame([[1, 2, 3], [4, 5, 6]], columns=['A', 'B', 'C'])
// >>> df.to_clipboard() # doctest: +SKIP
// >>> pd.read_clipboard() # doctest: +SKIP
//
// A B C
//
// 0 1 2 3
// 1 4 5 6
//
//go:linkname ReadClipboard py.read_clipboard
func ReadClipboard(sep *py.Object, dtypeBackend *py.Object) *py.Object
// Load a parquet object from the file path, returning a DataFrame.
//
// Parameters
// ----------
// path : str, path object or file-like object
//
// String, path object (implementing ``os.PathLike[str]``), or file-like
// object implementing a binary ``read()`` function.
// The string could be a URL. Valid URL schemes include http, ftp, s3,
// gs, and file. For file URLs, a host is expected. A local file could be:
// ``file://localhost/path/to/table.parquet``.
// A file URL can also be a path to a directory that contains multiple
// partitioned parquet files. Both pyarrow and fastparquet support
// paths to directories as well as file URLs. A directory path could be:
// ``file://localhost/path/to/tables`` or ``s3://bucket/partition_dir``.
//
// engine : {'auto', 'pyarrow', 'fastparquet'}, default 'auto'
//
// Parquet library to use. If 'auto', then the option
// ``io.parquet.engine`` is used. The default ``io.parquet.engine``
// behavior is to try 'pyarrow', falling back to 'fastparquet' if
// 'pyarrow' is unavailable.
//
// When using the ``'pyarrow'`` engine and no storage options are provided
// and a filesystem is implemented by both ``pyarrow.fs`` and ``fsspec``
// (e.g. "s3://"), then the ``pyarrow.fs`` filesystem is attempted first.
// Use the filesystem keyword with an instantiated fsspec filesystem
// if you wish to use its implementation.
//
// columns : list, default=None
//
// If not None, only these columns will be read from the file.
//
// storage_options : dict, optional
//
// Extra options that make sense for a particular storage connection, e.g.
// host, port, username, password, etc. For HTTP(S) URLs the key-value pairs
// are forwarded to ``urllib.request.Request`` as header options. For other
// URLs (e.g. starting with "s3://", and "gcs://") the key-value pairs are
// forwarded to ``fsspec.open``. Please see ``fsspec`` and ``urllib`` for more
// details, and for more examples on storage options refer `here
// <https://pandas.pydata.org/docs/user_guide/io.html?
// highlight=storage_options#reading-writing-remote-files>`_.
//
// .. versionadded:: 1.3.0
//
// use_nullable_dtypes : bool, default False
//
// If True, use dtypes that use ``pd.NA`` as missing value indicator
// for the resulting DataFrame. (only applicable for the ``pyarrow``
// engine)
// As new dtypes are added that support ``pd.NA`` in the future, the
// output with this option will change to use those dtypes.
// Note: this is an experimental option, and behaviour (e.g. additional
// support dtypes) may change without notice.
//
// .. deprecated:: 2.0
//
// dtype_backend : {'numpy_nullable', 'pyarrow'}, default 'numpy_nullable'
//
// Back-end data type applied to the resultant :class:`DataFrame`
// (still experimental). Behaviour is as follows:
//
// * ``"numpy_nullable"``: returns nullable-dtype-backed :class:`DataFrame`
// (default).
// * ``"pyarrow"``: returns pyarrow-backed nullable :class:`ArrowDtype`
// DataFrame.
//
// .. versionadded:: 2.0
//
// filesystem : fsspec or pyarrow filesystem, default None
//
// Filesystem object to use when reading the parquet file. Only implemented
// for ``engine="pyarrow"``.
//
// .. versionadded:: 2.1.0
//
// filters : List[Tuple] or List[List[Tuple]], default None
//
// To filter out data.
// Filter syntax: [[(column, op, val), ...],...]
// where op is [==, =, >, >=, <, <=, !=, in, not in]
// The innermost tuples are transposed into a set of filters applied
// through an `AND` operation.
// The outer list combines these sets of filters through an `OR`
// operation.
// A single list of tuples can also be used, meaning that no `OR`
// operation between set of filters is to be conducted.
//
// Using this argument will NOT result in row-wise filtering of the final
// partitions unless ``engine="pyarrow"`` is also specified. For
// other engines, filtering is only performed at the partition level, that is,
// to prevent the loading of some row-groups and/or files.
//
// .. versionadded:: 2.1.0
//
// **kwargs
//
// Any additional kwargs are passed to the engine.
//
// Returns
// -------
// DataFrame
//
// See Also
// --------
// DataFrame.to_parquet : Create a parquet object that serializes a DataFrame.
//
// Examples
// --------
// >>> original_df = pd.DataFrame(
// ... {"foo": range(5), "bar": range(5, 10)}
// ... )
// >>> original_df
//
// foo bar
//
// 0 0 5
// 1 1 6
// 2 2 7
// 3 3 8
// 4 4 9
// >>> df_parquet_bytes = original_df.to_parquet()
// >>> from io import BytesIO
// >>> restored_df = pd.read_parquet(BytesIO(df_parquet_bytes))
// >>> restored_df
//
// foo bar
//
// 0 0 5
// 1 1 6
// 2 2 7
// 3 3 8
// 4 4 9
// >>> restored_df.equals(original_df)
// True
// >>> restored_bar = pd.read_parquet(BytesIO(df_parquet_bytes), columns=["bar"])
// >>> restored_bar
//
// bar
//
// 0 5
// 1 6
// 2 7
// 3 8
// 4 9
// >>> restored_bar.equals(original_df[['bar']])
// True
//
// The function uses `kwargs` that are passed directly to the engine.
// In the following example, we use the `filters` argument of the pyarrow
// engine to filter the rows of the DataFrame.
//
// Since `pyarrow` is the default engine, we can omit the `engine` argument.
// Note that the `filters` argument is implemented by the `pyarrow` engine,
// which can benefit from multithreading and also potentially be more
// economical in terms of memory.
//
// >>> sel = [("foo", ">", 2)]
// >>> restored_part = pd.read_parquet(BytesIO(df_parquet_bytes), filters=sel)
// >>> restored_part
//
// foo bar
//
// 0 3 8
// 1 4 9
//
//go:linkname ReadParquet py.read_parquet
func ReadParquet(path *py.Object, engine *py.Object, columns *py.Object, storageOptions *py.Object, useNullableDtypes *py.Object, dtypeBackend *py.Object, filesystem *py.Object, filters *py.Object) *py.Object
// Load an ORC object from the file path, returning a DataFrame.
//
// Parameters
// ----------
// path : str, path object, or file-like object
//
// String, path object (implementing ``os.PathLike[str]``), or file-like
// object implementing a binary ``read()`` function. The string could be a URL.
// Valid URL schemes include http, ftp, s3, and file. For file URLs, a host is
// expected. A local file could be:
// ``file://localhost/path/to/table.orc``.
//
// columns : list, default None
//
// If not None, only these columns will be read from the file.
// Output always follows the ordering of the file and not the columns list.
// This mirrors the original behaviour of
// :external+pyarrow:py:meth:`pyarrow.orc.ORCFile.read`.
//
// dtype_backend : {'numpy_nullable', 'pyarrow'}, default 'numpy_nullable'
//
// Back-end data type applied to the resultant :class:`DataFrame`
// (still experimental). Behaviour is as follows:
//
// * ``"numpy_nullable"``: returns nullable-dtype-backed :class:`DataFrame`
// (default).
// * ``"pyarrow"``: returns pyarrow-backed nullable :class:`ArrowDtype`
// DataFrame.
//
// .. versionadded:: 2.0
//
// filesystem : fsspec or pyarrow filesystem, default None
//
// Filesystem object to use when reading the parquet file.
//
// .. versionadded:: 2.1.0
//
// **kwargs
//
// Any additional kwargs are passed to pyarrow.
//
// Returns
// -------
// DataFrame
//
// Notes
// -----
// Before using this function you should read the :ref:`user guide about ORC <io.orc>`
// and :ref:`install optional dependencies <install.warn_orc>`.
//
// If “path“ is a URI scheme pointing to a local or remote file (e.g. "s3://"),
// a “pyarrow.fs“ filesystem will be attempted to read the file. You can also pass a
// pyarrow or fsspec filesystem object into the filesystem keyword to override this
// behavior.
//
// Examples
// --------
// >>> result = pd.read_orc("example_pa.orc") # doctest: +SKIP
//
//go:linkname ReadOrc py.read_orc
func ReadOrc(path *py.Object, columns *py.Object, dtypeBackend *py.Object, filesystem *py.Object) *py.Object
// Load a feather-format object from the file path.
//
// Parameters
// ----------
// path : str, path object, or file-like object
//
// String, path object (implementing ``os.PathLike[str]``), or file-like
// object implementing a binary ``read()`` function. The string could be a URL.
// Valid URL schemes include http, ftp, s3, and file. For file URLs, a host is
// expected. A local file could be: ``file://localhost/path/to/table.feather``.
//
// columns : sequence, default None
//
// If not provided, all columns are read.
//
// use_threads : bool, default True
//
// Whether to parallelize reading using multiple threads.
//
// storage_options : dict, optional
//
// Extra options that make sense for a particular storage connection, e.g.
// host, port, username, password, etc. For HTTP(S) URLs the key-value pairs
// are forwarded to ``urllib.request.Request`` as header options. For other
// URLs (e.g. starting with "s3://", and "gcs://") the key-value pairs are
// forwarded to ``fsspec.open``. Please see ``fsspec`` and ``urllib`` for more
// details, and for more examples on storage options refer `here
// <https://pandas.pydata.org/docs/user_guide/io.html?
// highlight=storage_options#reading-writing-remote-files>`_.
//
// dtype_backend : {'numpy_nullable', 'pyarrow'}, default 'numpy_nullable'
//
// Back-end data type applied to the resultant :class:`DataFrame`
// (still experimental). Behaviour is as follows:
//
// * ``"numpy_nullable"``: returns nullable-dtype-backed :class:`DataFrame`
// (default).
// * ``"pyarrow"``: returns pyarrow-backed nullable :class:`ArrowDtype`
// DataFrame.
//
// .. versionadded:: 2.0
//
// Returns
// -------
// type of object stored in file
//
// Examples
// --------
// >>> df = pd.read_feather("path/to/file.feather") # doctest: +SKIP
//
//go:linkname ReadFeather py.read_feather
func ReadFeather(path *py.Object, columns *py.Object, useThreads *py.Object, storageOptions *py.Object, dtypeBackend *py.Object) *py.Object
// Load data from Google BigQuery.
//
// .. deprecated:: 2.2.0
//
// Please use ``pandas_gbq.read_gbq`` instead.
//
// This function requires the `pandas-gbq package
// <https://pandas-gbq.readthedocs.io>`__.
//
// See the `How to authenticate with Google BigQuery
// <https://pandas-gbq.readthedocs.io/en/latest/howto/authentication.html>`__
// guide for authentication instructions.
//
// Parameters
// ----------
// query : str
//
// SQL-Like Query to return data values.
//
// project_id : str, optional
//
// Google BigQuery Account project ID. Optional when available from
// the environment.
//
// index_col : str, optional
//
// Name of result column to use for index in results DataFrame.
//
// col_order : list(str), optional
//
// List of BigQuery column names in the desired order for results
// DataFrame.
//
// reauth : bool, default False
//
// Force Google BigQuery to re-authenticate the user. This is useful
// if multiple accounts are used.
//
// auth_local_webserver : bool, default True
//
// Use the `local webserver flow`_ instead of the `console flow`_
// when getting user credentials.
//
// .. _local webserver flow:
// https://google-auth-oauthlib.readthedocs.io/en/latest/reference/google_auth_oauthlib.flow.html#google_auth_oauthlib.flow.InstalledAppFlow.run_local_server
// .. _console flow:
// https://google-auth-oauthlib.readthedocs.io/en/latest/reference/google_auth_oauthlib.flow.html#google_auth_oauthlib.flow.InstalledAppFlow.run_console
//
// *New in version 0.2.0 of pandas-gbq*.
//
// .. versionchanged:: 1.5.0
// Default value is changed to ``True``. Google has deprecated the
// ``auth_local_webserver = False`` `"out of band" (copy-paste)
// flow
// <https://developers.googleblog.com/2022/02/making-oauth-flows-safer.html?m=1#disallowed-oob>`_.
//
// dialect : str, default 'legacy'
//
// Note: The default value is changing to 'standard' in a future version.
//
// SQL syntax dialect to use. Value can be one of:
//
// ``'legacy'``
// Use BigQuery's legacy SQL dialect. For more information see
// `BigQuery Legacy SQL Reference
// <https://cloud.google.com/bigquery/docs/reference/legacy-sql>`__.
// ``'standard'``
// Use BigQuery's standard SQL, which is
// compliant with the SQL 2011 standard. For more information
// see `BigQuery Standard SQL Reference
// <https://cloud.google.com/bigquery/docs/reference/standard-sql/>`__.
//
// location : str, optional
//
// Location where the query job should run. See the `BigQuery locations
// documentation
// <https://cloud.google.com/bigquery/docs/dataset-locations>`__ for a
// list of available locations. The location must match that of any
// datasets used in the query.
//
// *New in version 0.5.0 of pandas-gbq*.
//
// configuration : dict, optional
//
// Query config parameters for job processing.
// For example:
//
// configuration = {'query': {'useQueryCache': False}}
//
// For more information see `BigQuery REST API Reference
// <https://cloud.google.com/bigquery/docs/reference/rest/v2/jobs#configuration.query>`__.
//
// credentials : google.auth.credentials.Credentials, optional
//
// Credentials for accessing Google APIs. Use this parameter to override
// default credentials, such as to use Compute Engine
// :class:`google.auth.compute_engine.Credentials` or Service Account
// :class:`google.oauth2.service_account.Credentials` directly.
//
// *New in version 0.8.0 of pandas-gbq*.
//
// use_bqstorage_api : bool, default False
//
// Use the `BigQuery Storage API
// <https://cloud.google.com/bigquery/docs/reference/storage/>`__ to
// download query results quickly, but at an increased cost. To use this
// API, first `enable it in the Cloud Console
// <https://console.cloud.google.com/apis/library/bigquerystorage.googleapis.com>`__.
// You must also have the `bigquery.readsessions.create
// <https://cloud.google.com/bigquery/docs/access-control#roles>`__
// permission on the project you are billing queries to.
//
// This feature requires version 0.10.0 or later of the ``pandas-gbq``
// package. It also requires the ``google-cloud-bigquery-storage`` and
// ``fastavro`` packages.
//
// max_results : int, optional
//
// If set, limit the maximum number of rows to fetch from the query
// results.
//
// progress_bar_type : Optional, str
//
// If set, use the `tqdm <https://tqdm.github.io/>`__ library to
// display a progress bar while the data downloads. Install the
// ``tqdm`` package to use this feature.
//
// Possible values of ``progress_bar_type`` include:
//
// ``None``
// No progress bar.
// ``'tqdm'``
// Use the :func:`tqdm.tqdm` function to print a progress bar
// to :data:`sys.stderr`.
// ``'tqdm_notebook'``
// Use the :func:`tqdm.tqdm_notebook` function to display a
// progress bar as a Jupyter notebook widget.
// ``'tqdm_gui'``
// Use the :func:`tqdm.tqdm_gui` function to display a
// progress bar as a graphical dialog box.
//
// Returns
// -------
// df: DataFrame
//
// DataFrame representing results of query.
//
// See Also
// --------
// pandas_gbq.read_gbq : This function in the pandas-gbq library.
// DataFrame.to_gbq : Write a DataFrame to Google BigQuery.
//
// Examples
// --------
// Example taken from `Google BigQuery documentation
// <https://cloud.google.com/bigquery/docs/pandas-gbq-migration>`_
//
// >>> sql = "SELECT name FROM table_name WHERE state = 'TX' LIMIT 100;"
// >>> df = pd.read_gbq(sql, dialect="standard") # doctest: +SKIP
// >>> project_id = "your-project-id" # doctest: +SKIP
// >>> df = pd.read_gbq(sql,
// ... project_id=project_id,
// ... dialect="standard"
// ... ) # doctest: +SKIP
//
//go:linkname ReadGbq py.read_gbq
func ReadGbq(query *py.Object, projectId *py.Object, indexCol *py.Object, colOrder *py.Object, reauth *py.Object, authLocalWebserver *py.Object, dialect *py.Object, location *py.Object, configuration *py.Object, credentials *py.Object, useBqstorageApi *py.Object, maxResults *py.Object, progressBarType *py.Object) *py.Object
// Read HTML tables into a “list“ of “DataFrame“ objects.
//
// Parameters
// ----------
// io : str, path object, or file-like object
//
// String, path object (implementing ``os.PathLike[str]``), or file-like
// object implementing a string ``read()`` function.
// The string can represent a URL or the HTML itself. Note that
// lxml only accepts the http, ftp and file url protocols. If you have a
// URL that starts with ``'https'`` you might try removing the ``'s'``.
//
// .. deprecated:: 2.1.0
// Passing html literal strings is deprecated.
// Wrap literal string/bytes input in ``io.StringIO``/``io.BytesIO`` instead.
//
// match : str or compiled regular expression, optional
//
// The set of tables containing text matching this regex or string will be
// returned. Unless the HTML is extremely simple you will probably need to
// pass a non-empty string here. Defaults to '.+' (match any non-empty
// string). The default value will return all tables contained on a page.
// This value is converted to a regular expression so that there is
// consistent behavior between Beautiful Soup and lxml.
//
// flavor : {"lxml", "html5lib", "bs4"} or list-like, optional
//
// The parsing engine (or list of parsing engines) to use. 'bs4' and
// 'html5lib' are synonymous with each other, they are both there for
// backwards compatibility. The default of ``None`` tries to use ``lxml``
// to parse and if that fails it falls back on ``bs4`` + ``html5lib``.
//
// header : int or list-like, optional
//
// The row (or list of rows for a :class:`~pandas.MultiIndex`) to use to
// make the columns headers.
//
// index_col : int or list-like, optional
//
// The column (or list of columns) to use to create the index.
//
// skiprows : int, list-like or slice, optional
//
// Number of rows to skip after parsing the column integer. 0-based. If a
// sequence of integers or a slice is given, will skip the rows indexed by
// that sequence. Note that a single element sequence means 'skip the nth
// row' whereas an integer means 'skip n rows'.
//
// attrs : dict, optional
//
// This is a dictionary of attributes that you can pass to use to identify
// the table in the HTML. These are not checked for validity before being
// passed to lxml or Beautiful Soup. However, these attributes must be
// valid HTML table attributes to work correctly. For example, ::
//
// attrs = {'id': 'table'}
//
// is a valid attribute dictionary because the 'id' HTML tag attribute is
// a valid HTML attribute for *any* HTML tag as per `this document
// <https://html.spec.whatwg.org/multipage/dom.html#global-attributes>`__. ::
//
// attrs = {'asdf': 'table'}
//
// is *not* a valid attribute dictionary because 'asdf' is not a valid
// HTML attribute even if it is a valid XML attribute. Valid HTML 4.01
// table attributes can be found `here
// <http://www.w3.org/TR/REC-html40/struct/tables.html#h-11.2>`__. A
// working draft of the HTML 5 spec can be found `here
// <https://html.spec.whatwg.org/multipage/tables.html>`__. It contains the
// latest information on table attributes for the modern web.
//
// parse_dates : bool, optional
//
// See :func:`~read_csv` for more details.
//
// thousands : str, optional
//
// Separator to use to parse thousands. Defaults to ``','``.
//
// encoding : str, optional
//
// The encoding used to decode the web page. Defaults to ``None``.``None``
// preserves the previous encoding behavior, which depends on the
// underlying parser library (e.g., the parser library will try to use
// the encoding provided by the document).
//
// decimal : str, default '.'
//
// Character to recognize as decimal point (e.g. use ',' for European
// data).
//
// converters : dict, default None
//
// Dict of functions for converting values in certain columns. Keys can
// either be integers or column labels, values are functions that take one
// input argument, the cell (not column) content, and return the
// transformed content.
//
// na_values : iterable, default None
//
// Custom NA values.
//
// keep_default_na : bool, default True
//
// If na_values are specified and keep_default_na is False the default NaN
// values are overridden, otherwise they're appended to.
//
// displayed_only : bool, default True
//
// Whether elements with "display: none" should be parsed.
//
// extract_links : {None, "all", "header", "body", "footer"}
//
// Table elements in the specified section(s) with <a> tags will have their
// href extracted.
//
// .. versionadded:: 1.5.0
//
// dtype_backend : {'numpy_nullable', 'pyarrow'}, default 'numpy_nullable'
//
// Back-end data type applied to the resultant :class:`DataFrame`
// (still experimental). Behaviour is as follows:
//
// * ``"numpy_nullable"``: returns nullable-dtype-backed :class:`DataFrame`
// (default).
// * ``"pyarrow"``: returns pyarrow-backed nullable :class:`ArrowDtype`
// DataFrame.
//
// .. versionadded:: 2.0
//
// storage_options : dict, optional
//
// Extra options that make sense for a particular storage connection, e.g.
// host, port, username, password, etc. For HTTP(S) URLs the key-value pairs
// are forwarded to ``urllib.request.Request`` as header options. For other
// URLs (e.g. starting with "s3://", and "gcs://") the key-value pairs are
// forwarded to ``fsspec.open``. Please see ``fsspec`` and ``urllib`` for more
// details, and for more examples on storage options refer `here
// <https://pandas.pydata.org/docs/user_guide/io.html?
// highlight=storage_options#reading-writing-remote-files>`_.
//
// .. versionadded:: 2.1.0
//
// Returns
// -------
// dfs
//
// A list of DataFrames.
//
// See Also
// --------
// read_csv : Read a comma-separated values (csv) file into DataFrame.
//
// Notes
// -----
// Before using this function you should read the :ref:`gotchas about the
// HTML parsing libraries <io.html.gotchas>`.
//
// Expect to do some cleanup after you call this function. For example, you
// might need to manually assign column names if the column names are
// converted to NaN when you pass the `header=0` argument. We try to assume as
// little as possible about the structure of the table and push the
// idiosyncrasies of the HTML contained in the table to the user.
//
// This function searches for “<table>“ elements and only for “<tr>“
// and “<th>“ rows and “<td>“ elements within each “<tr>“ or “<th>“
// element in the table. “<td>“ stands for "table data". This function
// attempts to properly handle “colspan“ and “rowspan“ attributes.
// If the function has a “<thead>“ argument, it is used to construct
// the header, otherwise the function attempts to find the header within
// the body (by putting rows with only “<th>“ elements into the header).
//
// Similar to :func:`~read_csv` the `header` argument is applied
// **after** `skiprows` is applied.
//
// This function will *always* return a list of :class:`DataFrame` *or*
// it will fail, e.g., it will *not* return an empty list.
//
// Examples
// --------
// See the :ref:`read_html documentation in the IO section of the docs
// <io.read_html>` for some examples of reading in HTML tables.
//
//go:linkname ReadHtml py.read_html
func ReadHtml(io *py.Object) *py.Object
// Read XML document into a :class:`~pandas.DataFrame` object.
//
// .. versionadded:: 1.3.0
//
// Parameters
// ----------
// path_or_buffer : str, path object, or file-like object
//
// String, path object (implementing ``os.PathLike[str]``), or file-like
// object implementing a ``read()`` function. The string can be any valid XML
// string or a path. The string can further be a URL. Valid URL schemes
// include http, ftp, s3, and file.
//
// .. deprecated:: 2.1.0
// Passing xml literal strings is deprecated.
// Wrap literal xml input in ``io.StringIO`` or ``io.BytesIO`` instead.
//
// xpath : str, optional, default './\*'
//
// The ``XPath`` to parse required set of nodes for migration to
// :class:`~pandas.DataFrame`.``XPath`` should return a collection of elements
// and not a single element. Note: The ``etree`` parser supports limited ``XPath``
// expressions. For more complex ``XPath``, use ``lxml`` which requires
// installation.
//
// namespaces : dict, optional
//
// The namespaces defined in XML document as dicts with key being
// namespace prefix and value the URI. There is no need to include all
// namespaces in XML, only the ones used in ``xpath`` expression.
// Note: if XML document uses default namespace denoted as
// `xmlns='<URI>'` without a prefix, you must assign any temporary
// namespace prefix such as 'doc' to the URI in order to parse
// underlying nodes and/or attributes. For example, ::
//
// namespaces = {"doc": "https://example.com"}
//
// elems_only : bool, optional, default False
//
// Parse only the child elements at the specified ``xpath``. By default,
// all child elements and non-empty text nodes are returned.
//
// attrs_only : bool, optional, default False
//
// Parse only the attributes at the specified ``xpath``.
// By default, all attributes are returned.
//
// names : list-like, optional
//
// Column names for DataFrame of parsed XML data. Use this parameter to
// rename original element names and distinguish same named elements and
// attributes.
//
// dtype : Type name or dict of column -> type, optional
//
// Data type for data or columns. E.g. {'a': np.float64, 'b': np.int32,
// 'c': 'Int64'}
// Use `str` or `object` together with suitable `na_values` settings
// to preserve and not interpret dtype.
// If converters are specified, they will be applied INSTEAD
// of dtype conversion.
//
// .. versionadded:: 1.5.0
//
// converters : dict, optional
//
// Dict of functions for converting values in certain columns. Keys can either
// be integers or column labels.
//
// .. versionadded:: 1.5.0
//
// parse_dates : bool or list of int or names or list of lists or dict, default False
//
// Identifiers to parse index or columns to datetime. The behavior is as follows:
//
// * boolean. If True -> try parsing the index.
// * list of int or names. e.g. If [1, 2, 3] -> try parsing columns 1, 2, 3
// each as a separate date column.
// * list of lists. e.g. If [[1, 3]] -> combine columns 1 and 3 and parse as
// a single date column.
// * dict, e.g. {'foo' : [1, 3]} -> parse columns 1, 3 as date and call
// result 'foo'
//
// .. versionadded:: 1.5.0
//
// encoding : str, optional, default 'utf-8'
//
// Encoding of XML document.
//
// parser : {'lxml','etree'}, default 'lxml'
//
// Parser module to use for retrieval of data. Only 'lxml' and
// 'etree' are supported. With 'lxml' more complex ``XPath`` searches
// and ability to use XSLT stylesheet are supported.
//
// stylesheet : str, path object or file-like object
//
// A URL, file-like object, or a raw string containing an XSLT script.
// This stylesheet should flatten complex, deeply nested XML documents
// for easier parsing. To use this feature you must have ``lxml`` module
// installed and specify 'lxml' as ``parser``. The ``xpath`` must
// reference nodes of transformed XML document generated after XSLT
// transformation and not the original XML document. Only XSLT 1.0
// scripts and not later versions is currently supported.
//
// iterparse : dict, optional
//
// The nodes or attributes to retrieve in iterparsing of XML document
// as a dict with key being the name of repeating element and value being
// list of elements or attribute names that are descendants of the repeated
// element. Note: If this option is used, it will replace ``xpath`` parsing
// and unlike ``xpath``, descendants do not need to relate to each other but can
// exist any where in document under the repeating element. This memory-
// efficient method should be used for very large XML files (500MB, 1GB, or 5GB+).
// For example, ::
//
// iterparse = {"row_element": ["child_elem", "attr", "grandchild_elem"]}
//
// .. versionadded:: 1.5.0
//
// compression : str or dict, default 'infer'
//
// For on-the-fly decompression of on-disk data. If 'infer' and 'path_or_buffer' is
// path-like, then detect compression from the following extensions: '.gz',
// '.bz2', '.zip', '.xz', '.zst', '.tar', '.tar.gz', '.tar.xz' or '.tar.bz2'
// (otherwise no compression).
// If using 'zip' or 'tar', the ZIP file must contain only one data file to be read in.
// Set to ``None`` for no decompression.
// Can also be a dict with key ``'method'`` set
// to one of {``'zip'``, ``'gzip'``, ``'bz2'``, ``'zstd'``, ``'xz'``, ``'tar'``} and
// other key-value pairs are forwarded to
// ``zipfile.ZipFile``, ``gzip.GzipFile``,
// ``bz2.BZ2File``, ``zstandard.ZstdDecompressor``, ``lzma.LZMAFile`` or
// ``tarfile.TarFile``, respectively.
// As an example, the following could be passed for Zstandard decompression using a
// custom compression dictionary:
// ``compression={'method': 'zstd', 'dict_data': my_compression_dict}``.
//
// .. versionadded:: 1.5.0
// Added support for `.tar` files.
//
// .. versionchanged:: 1.4.0 Zstandard support.
//
// storage_options : dict, optional
//
// Extra options that make sense for a particular storage connection, e.g.
// host, port, username, password, etc. For HTTP(S) URLs the key-value pairs
// are forwarded to ``urllib.request.Request`` as header options. For other
// URLs (e.g. starting with "s3://", and "gcs://") the key-value pairs are
// forwarded to ``fsspec.open``. Please see ``fsspec`` and ``urllib`` for more
// details, and for more examples on storage options refer `here
// <https://pandas.pydata.org/docs/user_guide/io.html?
// highlight=storage_options#reading-writing-remote-files>`_.
//
// dtype_backend : {'numpy_nullable', 'pyarrow'}, default 'numpy_nullable'
//
// Back-end data type applied to the resultant :class:`DataFrame`
// (still experimental). Behaviour is as follows:
//
// * ``"numpy_nullable"``: returns nullable-dtype-backed :class:`DataFrame`
// (default).
// * ``"pyarrow"``: returns pyarrow-backed nullable :class:`ArrowDtype`
// DataFrame.
//
// .. versionadded:: 2.0
//
// Returns
// -------
// df
//
// A DataFrame.
//
// See Also
// --------
// read_json : Convert a JSON string to pandas object.
// read_html : Read HTML tables into a list of DataFrame objects.
//
// Notes
// -----
// This method is best designed to import shallow XML documents in
// following format which is the ideal fit for the two-dimensions of a
// “DataFrame“ (row by column). ::
//
// <root>
// <row>
// <column1>data</column1>
// <column2>data</column2>
// <column3>data</column3>
// ...
// </row>
// <row>
// ...
// </row>
// ...
// </root>
//
// As a file format, XML documents can be designed any way including
// layout of elements and attributes as long as it conforms to W3C
// specifications. Therefore, this method is a convenience handler for
// a specific flatter design and not all possible XML structures.
//
// However, for more complex XML documents, “stylesheet“ allows you to
// temporarily redesign original document with XSLT (a special purpose
// language) for a flatter version for migration to a DataFrame.
//
// This function will *always* return a single :class:`DataFrame` or raise
// exceptions due to issues with XML document, “xpath“, or other
// parameters.
//
// See the :ref:`read_xml documentation in the IO section of the docs
// <io.read_xml>` for more information in using this method to parse XML
// files to DataFrames.
//
// Examples
// --------
// >>> from io import StringIO
// >>> xml = ”'<?xml version='1.0' encoding='utf-8'?>
// ... <data xmlns="http://example.com">
// ... <row>
// ... <shape>square</shape>
// ... <degrees>360</degrees>
// ... <sides>4.0</sides>
// ... </row>
// ... <row>
// ... <shape>circle</shape>
// ... <degrees>360</degrees>
// ... <sides/>
// ... </row>
// ... <row>
// ... <shape>triangle</shape>
// ... <degrees>180</degrees>
// ... <sides>3.0</sides>
// ... </row>
// ... </data>”'
//
// >>> df = pd.read_xml(StringIO(xml))
// >>> df
//
// shape degrees sides
//
// 0 square 360 4.0
// 1 circle 360 NaN
// 2 triangle 180 3.0
//
// >>> xml = ”'<?xml version='1.0' encoding='utf-8'?>
// ... <data>
// ... <row shape="square" degrees="360" sides="4.0"/>
// ... <row shape="circle" degrees="360"/>
// ... <row shape="triangle" degrees="180" sides="3.0"/>
// ... </data>”'
//
// >>> df = pd.read_xml(StringIO(xml), xpath=".//row")
// >>> df
//
// shape degrees sides
//
// 0 square 360 4.0
// 1 circle 360 NaN
// 2 triangle 180 3.0
//
// >>> xml = ”'<?xml version='1.0' encoding='utf-8'?>
// ... <doc:data xmlns:doc="https://example.com">
// ... <doc:row>
// ... <doc:shape>square</doc:shape>
// ... <doc:degrees>360</doc:degrees>
// ... <doc:sides>4.0</doc:sides>
// ... </doc:row>
// ... <doc:row>
// ... <doc:shape>circle</doc:shape>
// ... <doc:degrees>360</doc:degrees>
// ... <doc:sides/>
// ... </doc:row>
// ... <doc:row>
// ... <doc:shape>triangle</doc:shape>
// ... <doc:degrees>180</doc:degrees>
// ... <doc:sides>3.0</doc:sides>
// ... </doc:row>
// ... </doc:data>”'
//
// >>> df = pd.read_xml(StringIO(xml),
// ... xpath="//doc:row",
// ... namespaces={"doc": "https://example.com"})
// >>> df
//
// shape degrees sides
//
// 0 square 360 4.0
// 1 circle 360 NaN
// 2 triangle 180 3.0
//
// >>> xml_data = ”'
// ... <data>
// ... <row>
// ... <index>0</index>
// ... <a>1</a>
// ... <b>2.5</b>
// ... <c>True</c>
// ... <d>a</d>
// ... <e>2019-12-31 00:00:00</e>
// ... </row>
// ... <row>
// ... <index>1</index>
// ... <b>4.5</b>
// ... <c>False</c>
// ... <d>b</d>
// ... <e>2019-12-31 00:00:00</e>
// ... </row>
// ... </data>
// ... ”'
//
// >>> df = pd.read_xml(StringIO(xml_data),
// ... dtype_backend="numpy_nullable",
// ... parse_dates=["e"])
// >>> df
//
// index a b c d e
//
// 0 0 1 2.5 True a 2019-12-31
// 1 1 <NA> 4.5 False b 2019-12-31
//
//go:linkname ReadXml py.read_xml
func ReadXml(pathOrBuffer *py.Object) *py.Object
// Convert a JSON string to pandas object.
//
// Parameters
// ----------
// path_or_buf : a valid JSON str, path object or file-like object
//
// Any valid string path is acceptable. The string could be a URL. Valid
// URL schemes include http, ftp, s3, and file. For file URLs, a host is
// expected. A local file could be:
// ``file://localhost/path/to/table.json``.
//
// If you want to pass in a path object, pandas accepts any
// ``os.PathLike``.
//
// By file-like object, we refer to objects with a ``read()`` method,
// such as a file handle (e.g. via builtin ``open`` function)
// or ``StringIO``.
//
// .. deprecated:: 2.1.0
// Passing json literal strings is deprecated.
//
// orient : str, optional
//
// Indication of expected JSON string format.
// Compatible JSON strings can be produced by ``to_json()`` with a
// corresponding orient value.
// The set of possible orients is:
//
// - ``'split'`` : dict like
// ``{index -> [index], columns -> [columns], data -> [values]}``
// - ``'records'`` : list like
// ``[{column -> value}, ... , {column -> value}]``
// - ``'index'`` : dict like ``{index -> {column -> value}}``
// - ``'columns'`` : dict like ``{column -> {index -> value}}``
// - ``'values'`` : just the values array
// - ``'table'`` : dict like ``{'schema': {schema}, 'data': {data}}``
//
// The allowed and default values depend on the value
// of the `typ` parameter.
//
// * when ``typ == 'series'``,
//
// - allowed orients are ``{'split','records','index'}``
// - default is ``'index'``
// - The Series index must be unique for orient ``'index'``.
//
// * when ``typ == 'frame'``,
//
// - allowed orients are ``{'split','records','index',
// 'columns','values', 'table'}``
// - default is ``'columns'``
// - The DataFrame index must be unique for orients ``'index'`` and
// ``'columns'``.
// - The DataFrame columns must be unique for orients ``'index'``,
// ``'columns'``, and ``'records'``.
//
// typ : {'frame', 'series'}, default 'frame'
//
// The type of object to recover.
//
// dtype : bool or dict, default None
//
// If True, infer dtypes; if a dict of column to dtype, then use those;
// if False, then don't infer dtypes at all, applies only to the data.
//
// For all ``orient`` values except ``'table'``, default is True.
//
// convert_axes : bool, default None
//
// Try to convert the axes to the proper dtypes.
//
// For all ``orient`` values except ``'table'``, default is True.
//
// convert_dates : bool or list of str, default True
//
// If True then default datelike columns may be converted (depending on
// keep_default_dates).
// If False, no dates will be converted.
// If a list of column names, then those columns will be converted and
// default datelike columns may also be converted (depending on
// keep_default_dates).
//
// keep_default_dates : bool, default True
//
// If parsing dates (convert_dates is not False), then try to parse the
// default datelike columns.
// A column label is datelike if
//
// * it ends with ``'_at'``,
//
// * it ends with ``'_time'``,
//
// * it begins with ``'timestamp'``,
//
// * it is ``'modified'``, or
//
// * it is ``'date'``.
//
// precise_float : bool, default False
//
// Set to enable usage of higher precision (strtod) function when
// decoding string to double values. Default (False) is to use fast but
// less precise builtin functionality.
//
// date_unit : str, default None
//
// The timestamp unit to detect if converting dates. The default behaviour
// is to try and detect the correct precision, but if this is not desired
// then pass one of 's', 'ms', 'us' or 'ns' to force parsing only seconds,
// milliseconds, microseconds or nanoseconds respectively.
//
// encoding : str, default is 'utf-8'
//
// The encoding to use to decode py3 bytes.
//
// encoding_errors : str, optional, default "strict"
//
// How encoding errors are treated. `List of possible values
// <https://docs.python.org/3/library/codecs.html#error-handlers>`_ .
//
// .. versionadded:: 1.3.0
//
// lines : bool, default False
//
// Read the file as a json object per line.
//
// chunksize : int, optional
//
// Return JsonReader object for iteration.
// See the `line-delimited json docs
// <https://pandas.pydata.org/pandas-docs/stable/user_guide/io.html#line-delimited-json>`_
// for more information on ``chunksize``.
// This can only be passed if `lines=True`.
// If this is None, the file will be read into memory all at once.
//
// compression : str or dict, default 'infer'
//
// For on-the-fly decompression of on-disk data. If 'infer' and 'path_or_buf' is
// path-like, then detect compression from the following extensions: '.gz',
// '.bz2', '.zip', '.xz', '.zst', '.tar', '.tar.gz', '.tar.xz' or '.tar.bz2'
// (otherwise no compression).
// If using 'zip' or 'tar', the ZIP file must contain only one data file to be read in.
// Set to ``None`` for no decompression.
// Can also be a dict with key ``'method'`` set
// to one of {``'zip'``, ``'gzip'``, ``'bz2'``, ``'zstd'``, ``'xz'``, ``'tar'``} and
// other key-value pairs are forwarded to
// ``zipfile.ZipFile``, ``gzip.GzipFile``,
// ``bz2.BZ2File``, ``zstandard.ZstdDecompressor``, ``lzma.LZMAFile`` or
// ``tarfile.TarFile``, respectively.
// As an example, the following could be passed for Zstandard decompression using a
// custom compression dictionary:
// ``compression={'method': 'zstd', 'dict_data': my_compression_dict}``.
//
// .. versionadded:: 1.5.0
// Added support for `.tar` files.
//
// .. versionchanged:: 1.4.0 Zstandard support.
//
// nrows : int, optional
//
// The number of lines from the line-delimited jsonfile that has to be read.
// This can only be passed if `lines=True`.
// If this is None, all the rows will be returned.
//
// storage_options : dict, optional
//
// Extra options that make sense for a particular storage connection, e.g.
// host, port, username, password, etc. For HTTP(S) URLs the key-value pairs
// are forwarded to ``urllib.request.Request`` as header options. For other
// URLs (e.g. starting with "s3://", and "gcs://") the key-value pairs are
// forwarded to ``fsspec.open``. Please see ``fsspec`` and ``urllib`` for more
// details, and for more examples on storage options refer `here
// <https://pandas.pydata.org/docs/user_guide/io.html?
// highlight=storage_options#reading-writing-remote-files>`_.
//
// dtype_backend : {'numpy_nullable', 'pyarrow'}, default 'numpy_nullable'
//
// Back-end data type applied to the resultant :class:`DataFrame`
// (still experimental). Behaviour is as follows:
//
// * ``"numpy_nullable"``: returns nullable-dtype-backed :class:`DataFrame`
// (default).
// * ``"pyarrow"``: returns pyarrow-backed nullable :class:`ArrowDtype`
// DataFrame.
//
// .. versionadded:: 2.0
//
// engine : {"ujson", "pyarrow"}, default "ujson"
//
// Parser engine to use. The ``"pyarrow"`` engine is only available when
// ``lines=True``.
//
// .. versionadded:: 2.0
//
// Returns
// -------
// Series, DataFrame, or pandas.api.typing.JsonReader
//
// A JsonReader is returned when ``chunksize`` is not ``0`` or ``None``.
// Otherwise, the type returned depends on the value of ``typ``.
//
// See Also
// --------
// DataFrame.to_json : Convert a DataFrame to a JSON string.
// Series.to_json : Convert a Series to a JSON string.
// json_normalize : Normalize semi-structured JSON data into a flat table.
//
// Notes
// -----
// Specific to “orient='table'“, if a :class:`DataFrame` with a literal
// :class:`Index` name of `index` gets written with :func:`to_json`, the
// subsequent read operation will incorrectly set the :class:`Index` name to
// “None“. This is because `index` is also used by :func:`DataFrame.to_json`
// to denote a missing :class:`Index` name, and the subsequent
// :func:`read_json` operation cannot distinguish between the two. The same
// limitation is encountered with a :class:`MultiIndex` and any names
// beginning with “'level_'“.
//
// Examples
// --------
// >>> from io import StringIO
// >>> df = pd.DataFrame([['a', 'b'], ['c', 'd']],
// ... index=['row 1', 'row 2'],
// ... columns=['col 1', 'col 2'])
//
// Encoding/decoding a Dataframe using “'split'“ formatted JSON:
//
// >>> df.to_json(orient='split')
//
// '{"columns":["col 1","col 2"],"index":["row 1","row 2"],"data":[["a","b"],["c","d"]]}'
//
// >>> pd.read_json(StringIO(_), orient='split')
//
// col 1 col 2
//
// row 1 a b
// row 2 c d
//
// Encoding/decoding a Dataframe using “'index'“ formatted JSON:
//
// >>> df.to_json(orient='index')
// '{"row 1":{"col 1":"a","col 2":"b"},"row 2":{"col 1":"c","col 2":"d"}}'
//
// >>> pd.read_json(StringIO(_), orient='index')
//
// col 1 col 2
//
// row 1 a b
// row 2 c d
//
// Encoding/decoding a Dataframe using “'records'“ formatted JSON.
// Note that index labels are not preserved with this encoding.
//
// >>> df.to_json(orient='records')
// '[{"col 1":"a","col 2":"b"},{"col 1":"c","col 2":"d"}]'
// >>> pd.read_json(StringIO(_), orient='records')
//
// col 1 col 2
//
// 0 a b
// 1 c d
//
// # Encoding with Table Schema
//
// >>> df.to_json(orient='table')
//
// '{"schema":{"fields":[{"name":"index","type":"string"},{"name":"col 1","type":"string"},{"name":"col 2","type":"string"}],"primaryKey":["index"],"pandas_version":"1.4.0"},"data":[{"index":"row 1","col 1":"a","col 2":"b"},{"index":"row 2","col 1":"c","col 2":"d"}]}'
//
// The following example uses “dtype_backend="numpy_nullable"“
//
// >>> data = ”'{"index": {"0": 0, "1": 1},
// ... "a": {"0": 1, "1": null},
// ... "b": {"0": 2.5, "1": 4.5},
// ... "c": {"0": true, "1": false},
// ... "d": {"0": "a", "1": "b"},
// ... "e": {"0": 1577.2, "1": 1577.1}}”'
// >>> pd.read_json(StringIO(data), dtype_backend="numpy_nullable")
//
// index a b c d e
//
// 0 0 1 2.5 True a 1577.2
// 1 1 <NA> 4.5 False b 1577.1
//
//go:linkname ReadJson py.read_json
func ReadJson(pathOrBuf *py.Object) *py.Object
// Read Stata file into DataFrame.
//
// Parameters
// ----------
// filepath_or_buffer : str, path object or file-like object
//
// Any valid string path is acceptable. The string could be a URL. Valid
// URL schemes include http, ftp, s3, and file. For file URLs, a host is
// expected. A local file could be: ``file://localhost/path/to/table.dta``.
//
// If you want to pass in a path object, pandas accepts any ``os.PathLike``.
//
// By file-like object, we refer to objects with a ``read()`` method,
// such as a file handle (e.g. via builtin ``open`` function)
// or ``StringIO``.
//
// convert_dates : bool, default True
//
// Convert date variables to DataFrame time values.
//
// convert_categoricals : bool, default True
//
// Read value labels and convert columns to Categorical/Factor variables.
//
// index_col : str, optional
//
// Column to set as index.
//
// convert_missing : bool, default False
//
// Flag indicating whether to convert missing values to their Stata
// representations. If False, missing values are replaced with nan.
// If True, columns containing missing values are returned with
// object data types and missing values are represented by
// StataMissingValue objects.
//
// preserve_dtypes : bool, default True
//
// Preserve Stata datatypes. If False, numeric data are upcast to pandas
// default types for foreign data (float64 or int64).
//
// columns : list or None
//
// Columns to retain. Columns will be returned in the given order. None
// returns all columns.
//
// order_categoricals : bool, default True
//
// Flag indicating whether converted categorical data are ordered.
//
// chunksize : int, default None
//
// Return StataReader object for iterations, returns chunks with
// given number of lines.
//
// iterator : bool, default False
//
// Return StataReader object.
//
// compression : str or dict, default 'infer'
//
// For on-the-fly decompression of on-disk data. If 'infer' and 'filepath_or_buffer' is
// path-like, then detect compression from the following extensions: '.gz',
// '.bz2', '.zip', '.xz', '.zst', '.tar', '.tar.gz', '.tar.xz' or '.tar.bz2'
// (otherwise no compression).
// If using 'zip' or 'tar', the ZIP file must contain only one data file to be read in.
// Set to ``None`` for no decompression.
// Can also be a dict with key ``'method'`` set
// to one of {``'zip'``, ``'gzip'``, ``'bz2'``, ``'zstd'``, ``'xz'``, ``'tar'``} and
// other key-value pairs are forwarded to
// ``zipfile.ZipFile``, ``gzip.GzipFile``,
// ``bz2.BZ2File``, ``zstandard.ZstdDecompressor``, ``lzma.LZMAFile`` or
// ``tarfile.TarFile``, respectively.
// As an example, the following could be passed for Zstandard decompression using a
// custom compression dictionary:
// ``compression={'method': 'zstd', 'dict_data': my_compression_dict}``.
//
// .. versionadded:: 1.5.0
// Added support for `.tar` files.
//
// storage_options : dict, optional
//
// Extra options that make sense for a particular storage connection, e.g.
// host, port, username, password, etc. For HTTP(S) URLs the key-value pairs
// are forwarded to ``urllib.request.Request`` as header options. For other
// URLs (e.g. starting with "s3://", and "gcs://") the key-value pairs are
// forwarded to ``fsspec.open``. Please see ``fsspec`` and ``urllib`` for more
// details, and for more examples on storage options refer `here
// <https://pandas.pydata.org/docs/user_guide/io.html?
// highlight=storage_options#reading-writing-remote-files>`_.
//
// Returns
// -------
// DataFrame or pandas.api.typing.StataReader
//
// See Also
// --------
// io.stata.StataReader : Low-level reader for Stata data files.
// DataFrame.to_stata: Export Stata data files.
//
// Notes
// -----
// Categorical variables read through an iterator may not have the same
// categories and dtype. This occurs when a variable stored in a DTA
// file is associated to an incomplete set of value labels that only
// label a strict subset of the values.
//
// Examples
// --------
//
// # Creating a dummy stata for this example
//
// >>> df = pd.DataFrame({'animal': ['falcon', 'parrot', 'falcon', 'parrot'],
// ... 'speed': [350, 18, 361, 15]}) # doctest: +SKIP
// >>> df.to_stata('animals.dta') # doctest: +SKIP
//
// Read a Stata dta file:
//
// >>> df = pd.read_stata('animals.dta') # doctest: +SKIP
//
// Read a Stata dta file in 10,000 line chunks:
//
// >>> values = np.random.randint(0, 10, size=(20_000, 1), dtype="uint8") # doctest: +SKIP
// >>> df = pd.DataFrame(values, columns=["i"]) # doctest: +SKIP
// >>> df.to_stata('filename.dta') # doctest: +SKIP
//
// >>> with pd.read_stata('filename.dta', chunksize=10000) as itr: # doctest: +SKIP
// >>> for chunk in itr:
// ... # Operate on a single chunk, e.g., chunk.mean()
// ... pass # doctest: +SKIP
//
//go:linkname ReadStata py.read_stata
func ReadStata(filepathOrBuffer *py.Object) *py.Object
// Read SAS files stored as either XPORT or SAS7BDAT format files.
//
// Parameters
// ----------
// filepath_or_buffer : str, path object, or file-like object
//
// String, path object (implementing ``os.PathLike[str]``), or file-like
// object implementing a binary ``read()`` function. The string could be a URL.
// Valid URL schemes include http, ftp, s3, and file. For file URLs, a host is
// expected. A local file could be:
// ``file://localhost/path/to/table.sas7bdat``.
//
// format : str {'xport', 'sas7bdat'} or None
//
// If None, file format is inferred from file extension. If 'xport' or
// 'sas7bdat', uses the corresponding format.
//
// index : identifier of index column, defaults to None
//
// Identifier of column that should be used as index of the DataFrame.
//
// encoding : str, default is None
//
// Encoding for text data. If None, text data are stored as raw bytes.
//
// chunksize : int
//
// Read file `chunksize` lines at a time, returns iterator.
//
// iterator : bool, defaults to False
//
// If True, returns an iterator for reading the file incrementally.
//
// compression : str or dict, default 'infer'
//
// For on-the-fly decompression of on-disk data. If 'infer' and 'filepath_or_buffer' is
// path-like, then detect compression from the following extensions: '.gz',
// '.bz2', '.zip', '.xz', '.zst', '.tar', '.tar.gz', '.tar.xz' or '.tar.bz2'
// (otherwise no compression).
// If using 'zip' or 'tar', the ZIP file must contain only one data file to be read in.
// Set to ``None`` for no decompression.
// Can also be a dict with key ``'method'`` set
// to one of {``'zip'``, ``'gzip'``, ``'bz2'``, ``'zstd'``, ``'xz'``, ``'tar'``} and
// other key-value pairs are forwarded to
// ``zipfile.ZipFile``, ``gzip.GzipFile``,
// ``bz2.BZ2File``, ``zstandard.ZstdDecompressor``, ``lzma.LZMAFile`` or
// ``tarfile.TarFile``, respectively.
// As an example, the following could be passed for Zstandard decompression using a
// custom compression dictionary:
// ``compression={'method': 'zstd', 'dict_data': my_compression_dict}``.
//
// .. versionadded:: 1.5.0
// Added support for `.tar` files.
//
// Returns
// -------
// DataFrame if iterator=False and chunksize=None, else SAS7BDATReader
// or XportReader
//
// Examples
// --------
// >>> df = pd.read_sas("sas_data.sas7bdat") # doctest: +SKIP
//
//go:linkname ReadSas py.read_sas
func ReadSas(filepathOrBuffer *py.Object) *py.Object
// Load an SPSS file from the file path, returning a DataFrame.
//
// Parameters
// ----------
// path : str or Path
//
// File path.
//
// usecols : list-like, optional
//
// Return a subset of the columns. If None, return all columns.
//
// convert_categoricals : bool, default is True
//
// Convert categorical columns into pd.Categorical.
//
// dtype_backend : {'numpy_nullable', 'pyarrow'}, default 'numpy_nullable'
//
// Back-end data type applied to the resultant :class:`DataFrame`
// (still experimental). Behaviour is as follows:
//
// * ``"numpy_nullable"``: returns nullable-dtype-backed :class:`DataFrame`
// (default).
// * ``"pyarrow"``: returns pyarrow-backed nullable :class:`ArrowDtype`
// DataFrame.
//
// .. versionadded:: 2.0
//
// Returns
// -------
// DataFrame
//
// Examples
// --------
// >>> df = pd.read_spss("spss_data.sav") # doctest: +SKIP
//
//go:linkname ReadSpss py.read_spss
func ReadSpss(path *py.Object, usecols *py.Object, convertCategoricals *py.Object, dtypeBackend *py.Object) *py.Object
// Normalize semi-structured JSON data into a flat table.
//
// Parameters
// ----------
// data : dict or list of dicts
//
// Unserialized JSON objects.
//
// record_path : str or list of str, default None
//
// Path in each object to list of records. If not passed, data will be
// assumed to be an array of records.
//
// meta : list of paths (str or list of str), default None
//
// Fields to use as metadata for each record in resulting table.
//
// meta_prefix : str, default None
//
// If True, prefix records with dotted (?) path, e.g. foo.bar.field if
// meta is ['foo', 'bar'].
//
// record_prefix : str, default None
//
// If True, prefix records with dotted (?) path, e.g. foo.bar.field if
// path to records is ['foo', 'bar'].
//
// errors : {'raise', 'ignore'}, default 'raise'
//
// Configures error handling.
//
// * 'ignore' : will ignore KeyError if keys listed in meta are not
// always present.
// * 'raise' : will raise KeyError if keys listed in meta are not
// always present.
//
// sep : str, default '.'
//
// Nested records will generate names separated by sep.
// e.g., for sep='.', {'foo': {'bar': 0}} -> foo.bar.
//
// max_level : int, default None
//
// Max number of levels(depth of dict) to normalize.
// if None, normalizes all levels.
//
// Returns
// -------
// frame : DataFrame
// Normalize semi-structured JSON data into a flat table.
//
// Examples
// --------
// >>> data = [
// ... {"id": 1, "name": {"first": "Coleen", "last": "Volk"}},
// ... {"name": {"given": "Mark", "family": "Regner"}},
// ... {"id": 2, "name": "Faye Raker"},
// ... ]
// >>> pd.json_normalize(data)
//
// id name.first name.last name.given name.family name
//
// 0 1.0 Coleen Volk NaN NaN NaN
// 1 NaN NaN NaN Mark Regner NaN
// 2 2.0 NaN NaN NaN NaN Faye Raker
//
// >>> data = [
// ... {
// ... "id": 1,
// ... "name": "Cole Volk",
// ... "fitness": {"height": 130, "weight": 60},
// ... },
// ... {"name": "Mark Reg", "fitness": {"height": 130, "weight": 60}},
// ... {
// ... "id": 2,
// ... "name": "Faye Raker",
// ... "fitness": {"height": 130, "weight": 60},
// ... },
// ... ]
// >>> pd.json_normalize(data, max_level=0)
//
// id name fitness
//
// 0 1.0 Cole Volk {'height': 130, 'weight': 60}
// 1 NaN Mark Reg {'height': 130, 'weight': 60}
// 2 2.0 Faye Raker {'height': 130, 'weight': 60}
//
// Normalizes nested data up to level 1.
//
// >>> data = [
// ... {
// ... "id": 1,
// ... "name": "Cole Volk",
// ... "fitness": {"height": 130, "weight": 60},
// ... },
// ... {"name": "Mark Reg", "fitness": {"height": 130, "weight": 60}},
// ... {
// ... "id": 2,
// ... "name": "Faye Raker",
// ... "fitness": {"height": 130, "weight": 60},
// ... },
// ... ]
// >>> pd.json_normalize(data, max_level=1)
//
// id name fitness.height fitness.weight
//
// 0 1.0 Cole Volk 130 60
// 1 NaN Mark Reg 130 60
// 2 2.0 Faye Raker 130 60
//
// >>> data = [
// ... {
// ... "state": "Florida",
// ... "shortname": "FL",
// ... "info": {"governor": "Rick Scott"},
// ... "counties": [
// ... {"name": "Dade", "population": 12345},
// ... {"name": "Broward", "population": 40000},
// ... {"name": "Palm Beach", "population": 60000},
// ... ],
// ... },
// ... {
// ... "state": "Ohio",
// ... "shortname": "OH",
// ... "info": {"governor": "John Kasich"},
// ... "counties": [
// ... {"name": "Summit", "population": 1234},
// ... {"name": "Cuyahoga", "population": 1337},
// ... ],
// ... },
// ... ]
// >>> result = pd.json_normalize(
// ... data, "counties", ["state", "shortname", ["info", "governor"]]
// ... )
// >>> result
//
// name population state shortname info.governor
//
// 0 Dade 12345 Florida FL Rick Scott
// 1 Broward 40000 Florida FL Rick Scott
// 2 Palm Beach 60000 Florida FL Rick Scott
// 3 Summit 1234 Ohio OH John Kasich
// 4 Cuyahoga 1337 Ohio OH John Kasich
//
// >>> data = {"A": [1, 2]}
// >>> pd.json_normalize(data, "A", record_prefix="Prefix.")
//
// Prefix.0
//
// 0 1
// 1 2
//
// Returns normalized data with columns prefixed with the given string.
//
//go:linkname JsonNormalize py.json_normalize
func JsonNormalize(data *py.Object, recordPath *py.Object, meta *py.Object, metaPrefix *py.Object, recordPrefix *py.Object, errors *py.Object, sep *py.Object, maxLevel *py.Object) *py.Object
// Run the pandas test suite using pytest.
//
// By default, runs with the marks -m "not slow and not network and not db"
//
// Parameters
// ----------
// extra_args : list[str], default None
//
// Extra marks to run the tests.
//
// run_doctests : bool, default False
//
// Whether to only run the Python and Cython doctests. If you would like to run
// both doctests/regular tests, just append "--doctest-modules"/"--doctest-cython"
// to extra_args.
//
// Examples
// --------
// >>> pd.test() # doctest: +SKIP
// running: pytest...
//
//go:linkname Test py.test
func Test(extraArgs *py.Object, runDoctests *py.Object) *py.Object
Reference in New Issue View Git Blame Copy Permalink