neulab/docprompting-conala huggingface dataset:
pandas.Timestamp.round   Timestamp.round(freq, ambiguous='raise', nonexistent='raise')
 
Round the Timestamp to the specified resolution.  Parameters 
 
freq:str


Frequency string indicating the rounding resolution.  
ambiguous:bool or {‘raise’, ‘NaT’}, default ‘raise’


The behavior is as follows:  bool contains flags to determine if time is dst or not (note that this flag is only applicable for ambiguous fall dst dates). ‘NaT’ will return NaT for an ambiguous time. ‘raise’ will raise an AmbiguousTimeError for an ambiguous time.   
nonexistent:{‘raise’, ‘shift_forward’, ‘shift_backward, ‘NaT’, timedelta}, default ‘raise’


A nonexistent time does not exist in a particular timezone where clocks moved forward due to DST.  ‘shift_forward’ will shift the nonexistent time forward to the closest existing time. ‘shift_backward’ will shift the nonexistent time backward to the closest existing time. ‘NaT’ will return NaT where there are nonexistent times. timedelta objects will shift nonexistent times by the timedelta. ‘raise’ will raise an NonExistentTimeError if there are nonexistent times.     Returns 
 a new Timestamp rounded to the given resolution of freq

  Raises 
 ValueError if the freq cannot be converted
   Notes If the Timestamp has a timezone, rounding will take place relative to the local (“wall”) time and re-localized to the same timezone. When rounding near daylight savings time, use nonexistent and ambiguous to control the re-localization behavior. Examples Create a timestamp object: 
>>> ts = pd.Timestamp('2020-03-14T15:32:52.192548651')
  A timestamp can be rounded using multiple frequency units: 
>>> ts.round(freq='H') # hour
Timestamp('2020-03-14 16:00:00')
  
>>> ts.round(freq='T') # minute
Timestamp('2020-03-14 15:33:00')
  
>>> ts.round(freq='S') # seconds
Timestamp('2020-03-14 15:32:52')
  
>>> ts.round(freq='L') # milliseconds
Timestamp('2020-03-14 15:32:52.193000')
  freq can also be a multiple of a single unit, like ‘5T’ (i.e. 5 minutes): 
>>> ts.round(freq='5T')
Timestamp('2020-03-14 15:35:00')
  or a combination of multiple units, like ‘1H30T’ (i.e. 1 hour and 30 minutes): 
>>> ts.round(freq='1H30T')
Timestamp('2020-03-14 15:00:00')
  Analogous for pd.NaT: 
>>> pd.NaT.round()
NaT
  When rounding near a daylight savings time transition, use ambiguous or nonexistent to control how the timestamp should be re-localized. 
>>> ts_tz = pd.Timestamp("2021-10-31 01:30:00").tz_localize("Europe/Amsterdam")
  
>>> ts_tz.round("H", ambiguous=False)
Timestamp('2021-10-31 02:00:00+0100', tz='Europe/Amsterdam')
  
>>> ts_tz.round("H", ambiguous=True)
Timestamp('2021-10-31 02:00:00+0200', tz='Europe/Amsterdam')
pandas.Timestamp.strftime   Timestamp.strftime(format)
 
Return a string representing the given POSIX timestamp controlled by an explicit format string.  Parameters 
 
format:str


Format string to convert Timestamp to string. See strftime documentation for more information on the format string: https://docs.python.org/3/library/datetime.html#strftime-and-strptime-behavior.     Examples 
>>> ts = pd.Timestamp('2020-03-14T15:32:52.192548651')
>>> ts.strftime('%Y-%m-%d %X')
'2020-03-14 15:32:52'
pandas.Timestamp.strptime   classmethodTimestamp.strptime(string, format)
 
Function is not implemented. Use pd.to_datetime().
pandas.Timestamp.time   Timestamp.time()
 
Return time object with same time but with tzinfo=None.
pandas.Timestamp.timestamp   Timestamp.timestamp()
 
Return POSIX timestamp as float. Examples 
>>> ts = pd.Timestamp('2020-03-14T15:32:52.192548')
>>> ts.timestamp()
1584199972.192548
pandas.Timestamp.timetuple   Timestamp.timetuple()
 
Return time tuple, compatible with time.localtime().
pandas.Timestamp.timetz   Timestamp.timetz()
 
Return time object with same time and tzinfo.
pandas.Timestamp.to_datetime64   Timestamp.to_datetime64()
 
Return a numpy.datetime64 object with ‘ns’ precision.
pandas.Timestamp.to_julian_date   Timestamp.to_julian_date()
 
Convert TimeStamp to a Julian Date. 0 Julian date is noon January 1, 4713 BC. Examples 
>>> ts = pd.Timestamp('2020-03-14T15:32:52')
>>> ts.to_julian_date()
2458923.147824074
pandas.Timestamp.to_numpy   Timestamp.to_numpy()
 
Convert the Timestamp to a NumPy datetime64.  New in version 0.25.0.  This is an alias method for Timestamp.to_datetime64(). The dtype and copy parameters are available here only for compatibility. Their values will not affect the return value.  Returns 
 numpy.datetime64
    See also  DatetimeIndex.to_numpy

Similar method for DatetimeIndex.    Examples 
>>> ts = pd.Timestamp('2020-03-14T15:32:52.192548651')
>>> ts.to_numpy()
numpy.datetime64('2020-03-14T15:32:52.192548651')
  Analogous for pd.NaT: 
>>> pd.NaT.to_numpy()
numpy.datetime64('NaT')
pandas.Timestamp.to_period   Timestamp.to_period()
 
Return an period of which this timestamp is an observation. Examples 
>>> ts = pd.Timestamp('2020-03-14T15:32:52.192548651')
>>> # Year end frequency
>>> ts.to_period(freq='Y')
Period('2020', 'A-DEC')
  
>>> # Month end frequency
>>> ts.to_period(freq='M')
Period('2020-03', 'M')
  
>>> # Weekly frequency
>>> ts.to_period(freq='W')
Period('2020-03-09/2020-03-15', 'W-SUN')
  
>>> # Quarter end frequency
>>> ts.to_period(freq='Q')
Period('2020Q1', 'Q-DEC')
pandas.Timestamp.to_pydatetime   Timestamp.to_pydatetime()
 
Convert a Timestamp object to a native Python datetime object. If warn=True, issue a warning if nanoseconds is nonzero. Examples 
>>> ts = pd.Timestamp('2020-03-14T15:32:52.192548')
>>> ts.to_pydatetime()
datetime.datetime(2020, 3, 14, 15, 32, 52, 192548)
  Analogous for pd.NaT: 
>>> pd.NaT.to_pydatetime()
NaT
pandas.Timestamp.today   classmethodTimestamp.today(cls, tz=None)
 
Return the current time in the local timezone. This differs from datetime.today() in that it can be localized to a passed timezone.  Parameters 
 
tz:str or timezone object, default None


Timezone to localize to.     Examples 
>>> pd.Timestamp.today()    
Timestamp('2020-11-16 22:37:39.969883')
  Analogous for pd.NaT: 
>>> pd.NaT.today()
NaT
pandas.Timestamp.toordinal   Timestamp.toordinal()
 
Return proleptic Gregorian ordinal. January 1 of year 1 is day 1.
pandas.Timestamp.tz   propertyTimestamp.tz
 
Alias for tzinfo. Examples 
>>> ts = pd.Timestamp(1584226800, unit='s', tz='Europe/Stockholm')
>>> ts.tz
<DstTzInfo 'Europe/Stockholm' CET+1:00:00 STD>
pandas.Timestamp.tz_convert   Timestamp.tz_convert(tz)
 
Convert timezone-aware Timestamp to another time zone.  Parameters 
 
tz:str, pytz.timezone, dateutil.tz.tzfile or None


Time zone for time which Timestamp will be converted to. None will remove timezone holding UTC time.    Returns 
 
converted:Timestamp

  Raises 
 TypeError

If Timestamp is tz-naive.     Examples Create a timestamp object with UTC timezone: 
>>> ts = pd.Timestamp('2020-03-14T15:32:52.192548651', tz='UTC')
>>> ts
Timestamp('2020-03-14 15:32:52.192548651+0000', tz='UTC')
  Change to Tokyo timezone: 
>>> ts.tz_convert(tz='Asia/Tokyo')
Timestamp('2020-03-15 00:32:52.192548651+0900', tz='Asia/Tokyo')
  Can also use astimezone: 
>>> ts.astimezone(tz='Asia/Tokyo')
Timestamp('2020-03-15 00:32:52.192548651+0900', tz='Asia/Tokyo')
  Analogous for pd.NaT: 
>>> pd.NaT.tz_convert(tz='Asia/Tokyo')
NaT
pandas.Timestamp.tz_localize   Timestamp.tz_localize(tz, ambiguous='raise', nonexistent='raise')
 
Convert naive Timestamp to local time zone, or remove timezone from timezone-aware Timestamp.  Parameters 
 
tz:str, pytz.timezone, dateutil.tz.tzfile or None


Time zone for time which Timestamp will be converted to. None will remove timezone holding local time.  
ambiguous:bool, ‘NaT’, default ‘raise’


When clocks moved backward due to DST, ambiguous times may arise. For example in Central European Time (UTC+01), when going from 03:00 DST to 02:00 non-DST, 02:30:00 local time occurs both at 00:30:00 UTC and at 01:30:00 UTC. In such a situation, the ambiguous parameter dictates how ambiguous times should be handled. The behavior is as follows:  bool contains flags to determine if time is dst or not (note that this flag is only applicable for ambiguous fall dst dates). ‘NaT’ will return NaT for an ambiguous time. ‘raise’ will raise an AmbiguousTimeError for an ambiguous time.   
nonexistent:‘shift_forward’, ‘shift_backward, ‘NaT’, timedelta, default ‘raise’


A nonexistent time does not exist in a particular timezone where clocks moved forward due to DST. The behavior is as follows:  ‘shift_forward’ will shift the nonexistent time forward to the closest existing time. ‘shift_backward’ will shift the nonexistent time backward to the closest existing time. ‘NaT’ will return NaT where there are nonexistent times. timedelta objects will shift nonexistent times by the timedelta. ‘raise’ will raise an NonExistentTimeError if there are nonexistent times.     Returns 
 
localized:Timestamp

  Raises 
 TypeError

If the Timestamp is tz-aware and tz is not None.     Examples Create a naive timestamp object: 
>>> ts = pd.Timestamp('2020-03-14T15:32:52.192548651')
>>> ts
Timestamp('2020-03-14 15:32:52.192548651')
  Add ‘Europe/Stockholm’ as timezone: 
>>> ts.tz_localize(tz='Europe/Stockholm')
Timestamp('2020-03-14 15:32:52.192548651+0100', tz='Europe/Stockholm')
  Analogous for pd.NaT: 
>>> pd.NaT.tz_localize()
NaT
pandas.Timestamp.tzname   Timestamp.tzname()
 
Return self.tzinfo.tzname(self).
pandas.Timestamp.utcfromtimestamp   classmethodTimestamp.utcfromtimestamp(ts)
 
Construct a naive UTC datetime from a POSIX timestamp. Examples 
>>> pd.Timestamp.utcfromtimestamp(1584199972)
Timestamp('2020-03-14 15:32:52')
pandas.Timestamp.utcnow   classmethodTimestamp.utcnow()
 
Return a new Timestamp representing UTC day and time. Examples 
>>> pd.Timestamp.utcnow()   
Timestamp('2020-11-16 22:50:18.092888+0000', tz='UTC')
pandas.Timestamp.utcoffset   Timestamp.utcoffset()
 
Return self.tzinfo.utcoffset(self).
pandas.Timestamp.utctimetuple   Timestamp.utctimetuple()
 
Return UTC time tuple, compatible with time.localtime().
pandas.Timestamp.week   Timestamp.week
 
Return the week number of the year. Examples 
>>> ts = pd.Timestamp(2020, 3, 14)
>>> ts.week
11
pandas.Timestamp.weekday   Timestamp.weekday()
 
Return the day of the week represented by the date. Monday == 0 … Sunday == 6.
pandas.Timestamp.weekofyear   Timestamp.weekofyear
 
Return the week number of the year. Examples 
>>> ts = pd.Timestamp(2020, 3, 14)
>>> ts.week
11
pandas.to_numeric   pandas.to_numeric(arg, errors='raise', downcast=None)[source]
 
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 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.   
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.    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='ignore')
0    apple
1      1.0
2        2
3       -3
dtype: object
>>> 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
pandas.to_timedelta   pandas.to_timedelta(arg, unit=None, errors='raise')[source]
 
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.  Deprecated since version 1.2: Strings with units ‘M’, ‘Y’ and ‘y’ do not represent unambiguous timedelta values and will be removed in a future version   
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’ ‘m’ / ‘minute’ / ‘min’ / ‘minutes’ / ‘T’ ‘S’ / ‘seconds’ / ‘sec’ / ‘second’ ‘ms’ / ‘milliseconds’ / ‘millisecond’ / ‘milli’ / ‘millis’ / ‘L’ ‘us’ / ‘microseconds’ / ‘microsecond’ / ‘micro’ / ‘micros’ / ‘U’ ‘ns’ / ‘nanoseconds’ / ‘nano’ / ‘nanos’ / ‘nanosecond’ / ‘N’   Changed in version 1.1.0: Must not be specified when arg context strings and errors="raise".   
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)
pandas.tseries.frequencies.to_offset   pandas.tseries.frequencies.to_offset()
 
Return DateOffset object from string or tuple representation or datetime.timedelta object.  Parameters 
 
freq:str, datetime.timedelta, BaseOffset or None

  Returns 
 DateOffset or None
  Raises 
 ValueError

If freq is an invalid frequency      See also  BaseOffset

Standard kind of date increment used for a date range.    Examples 
>>> to_offset("5min")
<5 * Minutes>
  
>>> to_offset("1D1H")
<25 * Hours>
  
>>> to_offset("2W")
<2 * Weeks: weekday=6>
  
>>> to_offset("2B")
<2 * BusinessDays>
  
>>> to_offset(pd.Timedelta(days=1))
<Day>
  
>>> to_offset(Hour())
<Hour>
pandas.tseries.offsets.BDay   pandas.tseries.offsets.BDay
 
alias of pandas._libs.tslibs.offsets.BusinessDay
pandas.tseries.offsets.BMonthBegin   pandas.tseries.offsets.BMonthBegin
 
alias of pandas._libs.tslibs.offsets.BusinessMonthBegin
pandas.tseries.offsets.BMonthEnd   pandas.tseries.offsets.BMonthEnd
 
alias of pandas._libs.tslibs.offsets.BusinessMonthEnd
pandas.tseries.offsets.BQuarterBegin   classpandas.tseries.offsets.BQuarterBegin
 
DateOffset increments between the first business day of each Quarter. startingMonth = 1 corresponds to dates like 1/01/2007, 4/01/2007, … startingMonth = 2 corresponds to dates like 2/01/2007, 5/01/2007, … startingMonth = 3 corresponds to dates like 3/01/2007, 6/01/2007, … Examples 
>>> from pandas.tseries.offsets import BQuarterBegin
>>> ts = pd.Timestamp('2020-05-24 05:01:15')
>>> ts + BQuarterBegin()
Timestamp('2020-06-01 05:01:15')
>>> ts + BQuarterBegin(2)
Timestamp('2020-09-01 05:01:15')
>>> ts + BQuarterBegin(startingMonth=2)
Timestamp('2020-08-03 05:01:15')
>>> ts + BQuarterBegin(-1)
Timestamp('2020-03-02 05:01:15')
  Attributes       
base Returns a copy of the calling offset object with n=1 and all other attributes equal.          
freqstr   
kwds   
n   
name   
nanos   
normalize   
rule_code   
startingMonth     Methods       
__call__(*args, **kwargs) Call self as a function.  
rollback Roll provided date backward to next offset only if not on offset.  
rollforward Roll provided date forward to next offset only if not on offset.          
apply   
apply_index   
copy   
isAnchored   
is_anchored   
is_month_end   
is_month_start   
is_on_offset   
is_quarter_end   
is_quarter_start   
is_year_end   
is_year_start   
onOffset
pandas.tseries.offsets.BQuarterBegin.__call__   BQuarterBegin.__call__(*args, **kwargs)
 
Call self as a function.
pandas.tseries.offsets.BQuarterBegin.apply   BQuarterBegin.apply()
pandas.tseries.offsets.BQuarterBegin.apply_index   BQuarterBegin.apply_index(other)
pandas.tseries.offsets.BQuarterBegin.base   BQuarterBegin.base
 
Returns a copy of the calling offset object with n=1 and all other attributes equal.
pandas.tseries.offsets.BQuarterBegin.copy   BQuarterBegin.copy()
pandas.tseries.offsets.BQuarterBegin.freqstr   BQuarterBegin.freqstr
pandas.tseries.offsets.BQuarterBegin.is_anchored   BQuarterBegin.is_anchored()
pandas.tseries.offsets.BQuarterBegin.is_month_end   BQuarterBegin.is_month_end()
pandas.tseries.offsets.BQuarterBegin.is_month_start   BQuarterBegin.is_month_start()
pandas.tseries.offsets.BQuarterBegin.is_on_offset   BQuarterBegin.is_on_offset()
pandas.tseries.offsets.BQuarterBegin.is_quarter_end   BQuarterBegin.is_quarter_end()
pandas.tseries.offsets.BQuarterBegin.is_quarter_start   BQuarterBegin.is_quarter_start()
pandas.tseries.offsets.BQuarterBegin.is_year_end   BQuarterBegin.is_year_end()
pandas.tseries.offsets.BQuarterBegin.is_year_start   BQuarterBegin.is_year_start()
pandas.tseries.offsets.BQuarterBegin.isAnchored   BQuarterBegin.isAnchored()
pandas.tseries.offsets.BQuarterBegin.kwds   BQuarterBegin.kwds
pandas.tseries.offsets.BQuarterBegin.n   BQuarterBegin.n
pandas.tseries.offsets.BQuarterBegin.name   BQuarterBegin.name
pandas.tseries.offsets.BQuarterBegin.nanos   BQuarterBegin.nanos
pandas.tseries.offsets.BQuarterBegin.normalize   BQuarterBegin.normalize
pandas.tseries.offsets.BQuarterBegin.onOffset   BQuarterBegin.onOffset()
pandas.tseries.offsets.BQuarterBegin.rollback   BQuarterBegin.rollback()
 
Roll provided date backward to next offset only if not on offset.  Returns 
 TimeStamp

Rolled timestamp if not on offset, otherwise unchanged timestamp.
pandas.tseries.offsets.BQuarterBegin.rollforward   BQuarterBegin.rollforward()
 
Roll provided date forward to next offset only if not on offset.  Returns 
 TimeStamp

Rolled timestamp if not on offset, otherwise unchanged timestamp.
pandas.tseries.offsets.BQuarterBegin.rule_code   BQuarterBegin.rule_code
pandas.tseries.offsets.BQuarterBegin.startingMonth   BQuarterBegin.startingMonth
pandas.tseries.offsets.BQuarterEnd   classpandas.tseries.offsets.BQuarterEnd
 
DateOffset increments between the last business day of each Quarter. startingMonth = 1 corresponds to dates like 1/31/2007, 4/30/2007, … startingMonth = 2 corresponds to dates like 2/28/2007, 5/31/2007, … startingMonth = 3 corresponds to dates like 3/30/2007, 6/29/2007, … Examples 
>>> from pandas.tseries.offsets import BQuarterEnd
>>> ts = pd.Timestamp('2020-05-24 05:01:15')
>>> ts + BQuarterEnd()
Timestamp('2020-06-30 05:01:15')
>>> ts + BQuarterEnd(2)
Timestamp('2020-09-30 05:01:15')
>>> ts + BQuarterEnd(1, startingMonth=2)
Timestamp('2020-05-29 05:01:15')
>>> ts + BQuarterEnd(startingMonth=2)
Timestamp('2020-05-29 05:01:15')
  Attributes       
base Returns a copy of the calling offset object with n=1 and all other attributes equal.          
freqstr   
kwds   
n   
name   
nanos   
normalize   
rule_code   
startingMonth     Methods       
__call__(*args, **kwargs) Call self as a function.  
rollback Roll provided date backward to next offset only if not on offset.  
rollforward Roll provided date forward to next offset only if not on offset.          
apply   
apply_index   
copy   
isAnchored   
is_anchored   
is_month_end   
is_month_start   
is_on_offset   
is_quarter_end   
is_quarter_start   
is_year_end   
is_year_start   
onOffset
pandas.tseries.offsets.BQuarterEnd.__call__   BQuarterEnd.__call__(*args, **kwargs)
 
Call self as a function.
pandas.tseries.offsets.BQuarterEnd.apply   BQuarterEnd.apply()
pandas.tseries.offsets.BQuarterEnd.apply_index   BQuarterEnd.apply_index(other)
pandas.tseries.offsets.BQuarterEnd.base   BQuarterEnd.base
 
Returns a copy of the calling offset object with n=1 and all other attributes equal.
pandas.tseries.offsets.BQuarterEnd.copy   BQuarterEnd.copy()
pandas.tseries.offsets.BQuarterEnd.freqstr   BQuarterEnd.freqstr
pandas.tseries.offsets.BQuarterEnd.is_anchored   BQuarterEnd.is_anchored()
pandas.tseries.offsets.BQuarterEnd.is_month_end   BQuarterEnd.is_month_end()
pandas.tseries.offsets.BQuarterEnd.is_month_start   BQuarterEnd.is_month_start()
pandas.tseries.offsets.BQuarterEnd.is_on_offset   BQuarterEnd.is_on_offset()
pandas.tseries.offsets.BQuarterEnd.is_quarter_end   BQuarterEnd.is_quarter_end()
pandas.tseries.offsets.BQuarterEnd.is_quarter_start   BQuarterEnd.is_quarter_start()
pandas.tseries.offsets.BQuarterEnd.is_year_end   BQuarterEnd.is_year_end()
pandas.tseries.offsets.BQuarterEnd.is_year_start   BQuarterEnd.is_year_start()
pandas.tseries.offsets.BQuarterEnd.isAnchored   BQuarterEnd.isAnchored()
pandas.tseries.offsets.BQuarterEnd.kwds   BQuarterEnd.kwds
pandas.tseries.offsets.BQuarterEnd.n   BQuarterEnd.n
pandas.tseries.offsets.BQuarterEnd.name   BQuarterEnd.name
pandas.tseries.offsets.BQuarterEnd.nanos   BQuarterEnd.nanos
pandas.tseries.offsets.BQuarterEnd.normalize   BQuarterEnd.normalize
pandas.tseries.offsets.BQuarterEnd.onOffset   BQuarterEnd.onOffset()
pandas.tseries.offsets.BQuarterEnd.rollback   BQuarterEnd.rollback()
 
Roll provided date backward to next offset only if not on offset.  Returns 
 TimeStamp

Rolled timestamp if not on offset, otherwise unchanged timestamp.
pandas.tseries.offsets.BQuarterEnd.rollforward   BQuarterEnd.rollforward()
 
Roll provided date forward to next offset only if not on offset.  Returns 
 TimeStamp

Rolled timestamp if not on offset, otherwise unchanged timestamp.
pandas.tseries.offsets.BQuarterEnd.rule_code   BQuarterEnd.rule_code
pandas.tseries.offsets.BQuarterEnd.startingMonth   BQuarterEnd.startingMonth