U +if*@sddlmZddlmZddlmZddlmZddlmZddl m Z m Z m Z m Z mZmZmZmZddlZddlZddlmZdd lmZmZmZmZmZmZmZdd lm Z m!Z!m"Z"dd l#m$Z$dd l%m&Z&m'Z'm(Z(dd l)m*Z*ddl+m,Z,m-Z-m.Z.m/Z/m0Z0m1Z1m2Z2m3Z3m4Z4m5Z5ddl6m7Z7m8Z8ddl9m:Z:ddl;mm?Z?ddl@mAZAddlBmCZCmDZDmEZEddlFmGZGddlHmIZIddlJmKZKe rddlLmMZMddlNmOZOee ee&dfZPeeQeReSfZTedeTeZUeeUePfZVdZWddZXdld d!d"d#d$d%d&ZYd d'd#d(dd)d*d+ZZdmd,d-d.d/d0d1d2Z[dnd3dd'd/d4d5d6Z\d7d/d8d9d:Z]dod'd.d>d'd?d#d-d-d#d@ dAdBZ^d?d#d?d#dCdDdEdFZ_d?d#d?d#dCdDdGdHZ`d?d/dIdJdKZadLdMZbedpdd?d#d#d-d'd#d'd#d#dOdP dQdRZcedqdd?d#d#d-d'd#d'd#d#ddP dSdRZcedrdTd?d#d#d-d'd#d'd#d#dUdP dVdRZcdsd3d?d#d#d-d'd#d'd#d#dXdP dYdRZcdZdZd[d[d\d\d]d]d^d^d_d_d`d`d`dadadadbdbdbdcZddddeZed7d?dfdgdhdiZfdtdjdkZgdS)u) annotations)abc)datetime)partial)islice) TYPE_CHECKINGCallableHashableListTupleTypeVarUnionoverloadN)tslib)OutOfBoundsDatetime Timedelta Timestamp conversioniNaT nat_stringsparsing)DateParseError format_is_isoguess_datetime_format)array_strptime) AnyArrayLike ArrayLikeTimezone)find_stack_level) ensure_objectis_datetime64_dtypeis_datetime64_ns_dtypeis_datetime64tz_dtypeis_float is_integeris_integer_dtype is_list_likeis_numeric_dtype is_scalar) ABCDataFrame ABCSeries)notna) DatetimeArray IntegerArray) algorithms)unique)maybe_convert_dtypeobjects_to_datetime64ns tz_to_dtype) extract_array)Index) DatetimeIndex)NaTTypeSeriesr8DatetimeScalar2cKs0t|d}t|r,t||df|SdS)Nr)r+Znonzerolenr)arrkwargsZnon_nan_elementsr>N/home/mars/bis/venv/lib/python3.8/site-packages/pandas/core/tools/datetimes.py _guess_datetime_format_for_array_sr@ffffff?ArrayConvertiblefloatz int | Nonebool)arg unique_share check_countreturncCsd}|dkrr>r? should_cachefs0   rOz str | Noner)rEformatcacheconvert_listlikerHcCspddlm}|td}|rlt|s&|St|}t|t|krl|||}|||d}|jjsl||j}|S)a Create a cache of unique dates from an array of dates Parameters ---------- arg : listlike, tuple, 1-d array, Series format : string Strftime format to parse time cache : bool True attempts to create a cache of converted values convert_listlike : function Conversion function to apply on dates Returns ------- cache_array : Series Cache of converted, unique dates. Can be empty rr7dtype)index) pandasr8objectrOr/r;rU is_uniqueZ duplicated)rErPrQrRr8 cache_arrayZ unique_datesZ cache_datesr>r>r? _maybe_caches    rZrz bool | Noner r4)dt_arrayutcnamerHcCs2t|r"|rdnd}t|||dSt|||jdS)a Properly boxes the ndarray of datetimes to DatetimeIndex if it is possible or to generic Index instead Parameters ---------- dt_array: 1-d array Array of datetimes to be wrapped in an Index. tz : object None or 'utc' name : string, default None Name for a resulting index Returns ------- result : datetime of converted dates - DatetimeIndex if convertible to sole datetime64 type - general Index otherwise r\Ntzr])r]rT)r r5r4rT)r[r\r]r_r>r>r?_box_as_indexlikes r` DatetimeScalarOrArrayConvertible)rErYr]rHcCs*ddlm}|||}t|jd|dS)a Convert array of dates with a cache and wrap the result in an Index. Parameters ---------- arg : integer, float, string, datetime, list, tuple, 1-d array, Series cache_array : Series Cache of converted, unique dates name : string, default None Name for a DatetimeIndex Returns ------- result : Index-like of converted dates rr7Nr\r])rVr8mapr`_values)rErYr]r8resultr>r>r?_convert_and_box_caches rfz np.ndarray)rerHcsFtddt||D}dk r:tfdd|D}t||dS)a Return results from array_strptime if a %z or %Z directive was passed. Parameters ---------- result : ndarray[int64] int64 date representations of the dates timezones : ndarray pytz timezone objects tz : object None or pytz timezone object name : string, default None Name for a DatetimeIndex Returns ------- tz_result : Index-like of parsed dates with timezone cSsg|]\}}t||qSr>)r tz_localize).0reszoner>r>r? sz3_return_parsed_timezone_results..Ncsg|]}|qSr>) tz_convert)rhZ tz_resultr_r>r?rksr])nparrayzipr4)re timezonesr_r]Z tz_resultsr>rmr?_return_parsed_timezone_resultss rsraiseFTzTimezone | Nonestr) rPr]r_uniterrorsinfer_datetime_formatdayfirst yearfirstexactc  Csjt|ttfrtj|dd}t|dd} t| rht|ttfsLt|||dS|dkrd| d |}|St | rt|ttfszt|||dWSt k rYqXn|r| |S|S|dk r|dk rt dt |||||St|dd d krtd |} zt|d d \}} Wnjtk r||d krXtjdgddt|} t| |dYS|dkrvt||d}|YSYnXt|}d }|r|dkrt||d}|dk rt|}|r| }d}|dk rt|| |||| ||}|dk r|S|dks |s t|dk}t||||||dd\}}|dk rTt|t|d}tj||dS|dk}t|||dS)aS Helper function for to_datetime. Performs the conversions of 1D listlike of dates Parameters ---------- arg : list, tuple, ndarray, Series, Index date to be parsed name : object None or string for the Index name tz : object None or 'utc' unit : str None or string of the frequency of the passed data errors : str error handing behaviors from to_datetime, 'raise', 'coerce', 'ignore' infer_datetime_format : bool, default False inferring format behavior from to_datetime dayfirst : bool dayfirst parsing behavior from to_datetime yearfirst : bool yearfirst parsing behavior from to_datetime exact : bool, default True exact format matching behavior from to_datetime Returns ------- Index-like of parsed dates OrSrTNr^r\z#cannot specify both format and unitndimrJzAarg must be a string, datetime, list, tuple, 1-d array, or SeriesFcopycoerceZNaTzdatetime64[ns]rnignore)ryT)ryrzr\rwrequire_iso8601Z allow_objectrb) isinstancelisttuplerorpgetattrr"r,r5rlrgr! ValueError_to_datetime_with_unitrNr0repeatr;r4rr@r_to_datetime_with_formatrLr1r2 _simple_newr`)rErPr]r_rvrwrxryrzr{Z arg_dtypeorig_arg_ZnpvaluesidxrZformat_is_iso8601rir\re tz_parseddtar>r>r?_convert_listlike_datetimes!s)          rz Index | None)fmtr{rwrxrHc Cs|dk}z8t||||d\}} d|ks.d|kr>t|| ||WSWntk r|dkr\n2|dkrtj|jdd}|d } | tn|}Yn^t k r|s|dkrq|dkrtj|jdd}|d } | tq|}nYd SYnXt |||d S) zL Call array_strptime, with fallback behavior depending on 'errors'. r\)r{rwz%Zz%zrtrM8[ns]rSi8Nrb) rrsrroemptyshapeviewfillrrr`) rEr]r_rr{rwrxr\rerriresultr>r>r?_array_strptime_with_fallbacks0      rc Csd}z|dkrzt|}zt||d}Wn2tttfk rX} ztd| W5d} ~ XYnX|dk rz|dk} t|| |dWSt|||||||} | WStk r } zZz6t|\} }t | t |d} t j | |dWWY$Sttfk r| YnXW5d} ~ XYnXdS) zG Try parsing with the given format, returning None on failure. N%Y%m%drwz0cannot convert the input to '%Y%m%d' date formatr\rbrSrn) r_attempt_YYYYMMDDrrNrr`rrZdatetime_to_datetime64r,r2r5r)rErr]r_rr{rwrxreerrr\rivaluesrr>r>r?rs@ r)rwrHcCst|dd}t|tr.|d|d}d}nt|}tj|||d\}}|dkrdtj ||d}n t ||d}t|t s~|S| d  |}|dk r|j dkr| |}n | |}|S) zF to_datetime specalized to the case where a 'unit' is passed. T)Z extract_numpyz datetime64[]NrrrnUTC)r3rr-astyperoasarrayrZarray_with_unit_to_datetimer4Z _with_inferr5rgrlr_)rErvr]r_rwr<rrer>r>r?rs"        rc Cs|dkr|}td}|dkr(tdz ||}Wn,tk r`}ztd|W5d}~XYnXtj|}tj|}t||kst||krt|dnt |rt |st |st t |std|d |d z t|}Wnjtk r*}ztd |d |W5d}~XYn6tk r^}ztd |d |W5d}~XYnX|jdk r|td|d|td} | td|d} t|rt|tttjfst |}|| }|S)a Helper function for to_datetime. Adjust input argument to the specified origin Parameters ---------- arg : list, tuple, ndarray, Series, Index date to be adjusted origin : 'julian' or Timestamp origin offset for the arg unit : str passed unit from to_datetime, must be 'D' Returns ------- ndarray or scalar of adjusted date(s) ZjulianrDz$unit must be 'D' for origin='julian'z3incompatible 'arg' type for given 'origin'='julian'Nz% is Out of Bounds for origin='julian''z!' is not compatible with origin='z+'; it must be numeric with a unit specifiedzorigin z is Out of Boundsz# cannot be converted to a Timestampzorigin offset z must be tz-naiverJ)rv)rZto_julian_daterrNmaxminroanyrr(r$r#r'rr_rr&rr*r4Zndarray) rEoriginrvoriginalZj0rZj_maxZj_minoffsetZ td_offsetZioffsetr>r>r?_adjust_to_origin*s`    "    r.zDatetimeScalar | NaTType) rErwryrzr\rPr{rvrxrQrHc CsdSNr> rErwryrzr\rPr{rvrxrrQr>r>r? to_datetimessrc CsdSrr>rr>r>r?rszlist | tuple | np.ndarrayr5c CsdSrr>rr>r>r?rsunixz8DatetimeIndex | Series | DatetimeScalar | NaTType | Nonec  Cs|dkr dS| dkr t|| |}|r(dnd} tt| ||||||d} t|tr~|} | dk rz|jdk rp|| } n || } n>t|trt ||| | }|j s| |} n | |j |}|j ||j|jd} nt|ttjfrt||| } nt|tr.t ||| | }|j st|||jd} n| |||jd} nt|rzt ||| | }Wn:tk r|dkrhdd lm}|gtd }YnX|j st||} n | ||} n| t|g|d} | S) u9 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"`. 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. If a delimited date string cannot be parsed in accordance with the given `dayfirst` option, e.g. ``to_datetime(['31-12-2021'])``, then a warning will be shown. 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 None 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 ` section for details. See also: pandas general documentation about `timezone conversion and localization `_. format : str, default None The strftime to parse time, e.g. :const:`"%d/%m/%Y"`. Note that :const:`"%f"` will parse all the way up to nanoseconds. See `strftime documentation `_ for more information on choices. 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. 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'`` (the default), 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. 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, origin is set to Timestamp identified by origin. 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. .. versionchanged:: 0.25.0 changed default value from :const:`False` to :const:`True`. 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 `_. - 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] Passing ``infer_datetime_format=True`` can often-times speedup a parsing if its not an ISO8601 format exactly, but in a regular format. >>> s = pd.Series(['3/11/2000', '3/12/2000', '3/13/2000'] * 1000) >>> s.head() 0 3/11/2000 1 3/12/2000 2 3/13/2000 3 3/11/2000 4 3/12/2000 dtype: object >>> %timeit pd.to_datetime(s, infer_datetime_format=True) # doctest: +SKIP 100 loops, best of 3: 10.4 ms per loop >>> %timeit pd.to_datetime(s, infer_datetime_format=False) # doctest: +SKIP 1 loop, best of 3: 471 ms per loop 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) **Non-convertible date/times** If a date does not meet the `timestamp limitations `_, passing ``errors='ignore'`` will return the original input instead of raising any exception. 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='ignore') datetime.datetime(1300, 1, 1, 0, 0) >>> 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', '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, pytz.FixedOffset(-300)]', 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`. Instead a simple :class:`Index` containing :class:`datetime.datetime` objects is returned: >>> pd.to_datetime(['2020-10-25 02:00 +0200', '2020-10-25 04:00 +0100']) 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 converted to a timezone-aware :class:`DatetimeIndex` if the offsets of the timezone-aware are constant: >>> from datetime import datetime >>> pd.to_datetime(["2020-01-01 01:00 -01:00", datetime(2020, 1, 1, 3, 0)]) DatetimeIndex(['2020-01-01 01:00:00-01:00', '2020-01-01 02:00:00-01:00'], dtype='datetime64[ns, pytz.FixedOffset(-60)]', freq=None) - Finally, mixing timezone-aware strings and :class:`datetime.datetime` always raises an error, even if the elements all have the same time offset. >>> from datetime import datetime, timezone, timedelta >>> d = datetime(2020, 1, 1, 18, tzinfo=timezone(-timedelta(hours=1))) >>> pd.to_datetime(["2020-01-01 17:00 -0100", d]) Traceback (most recent call last): ... ValueError: Tz-aware datetime.datetime cannot be converted to datetime64 unless utc=True | 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 naive and aware, string or datetime, the above rules still apply >>> pd.to_datetime(['2018-10-26 12:00', '2018-10-26 12:00 -0530', ... datetime(2020, 1, 1, 18), ... datetime(2020, 1, 1, 18, ... tzinfo=timezone(-timedelta(hours=1)))], ... utc=True) DatetimeIndex(['2018-10-26 12:00:00+00:00', '2018-10-26 17:30:00+00:00', '2020-01-01 18:00:00+00:00', '2020-01-01 19:00:00+00:00'], dtype='datetime64[ns, UTC]', freq=None) Nrr\)r_rvryrzrwr{rx)rUr]rnrtrr7rS)rrrrrr_rlrgr*rZrrcrdZ _constructorrUr]r)rMutableMapping_assemble_from_unit_mappingsr4rfr&rrVr8rWrorp)rErwryrzr\rPr{rvrxrrQr_rRrerYrr8r>r>r?rsbW              yearmonthdayhmsmsusns)rZyearsrmonthsrdayshourhoursminuteminutessecondsecondsrZ millisecondZ millisecondsr microsecond microsecondsrZ nanosecond nanosecondsc sddlm}mm}||}|jjs,tdddfdd|D}dd|D}d d d g}t t |t |}t |rd |} td | dt t |t t } t | rd | } td| dfdd} | ||d d| ||d d| ||d } zt| d|d} Wn8ttfk rp}ztd||W5d}~XYnXdD]}||}|dk rv||krvz| || |||d7} Wn>ttfk r}ztd|d||W5d}~XYnXqv| S)a assemble the unit specified fields from the arg (DataFrame) Return a Series for actual parsing Parameters ---------- arg : DataFrame 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 tz : None or 'utc' Returns ------- Series r) DataFrame to_numeric to_timedeltaz#cannot assemble with duplicate keyscSs,|tkrt|S|tkr(t|S|Sr) _unit_maplower)valuer>r>r?fvs   z'_assemble_from_unit_mappings..fcsi|]}||qSr>r>)rhk)rr>r? sz0_assemble_from_unit_mappings..cSsi|]\}}||qSr>r>)rhrvr>r>r?rsrrr,zNto assemble mappings requires at least that [year, month, day] be specified: [z ] is missingz9extra keys have been passed to the datetime assemblage: [rcs&|d}t|r"|jddd}|S)Nrint64Fr~)r%r)r)rwrr>r?rs z,_assemble_from_unit_mappings..coerce'dr)rPrwr\zcannot assemble the datetimes: N)rrrrrr)rvrwzcannot assemble the datetimes [z]: )rVrrrcolumnsrXrkeysitemssortedrMr;joinrrrrNget)rErwr_rrrvZunit_revrequiredreqZ _requiredexcessZ_excessrrrurr>)rwrrr?rXsV       " rznp.ndarray | None)rErwrHc sfddfdd}z|tjWStttfk rDYnXz|tj}||t|WStttfk r|YnXzt |t t }|||WStttfk rYnXdS)a* try to parse the YYYYMMDD/%Y%m%d format, try to deal with NaT-like, arg is a passed in as an object dtype, but could really be ints/strings with nan-like/or floats (e.g. with nan) Parameters ---------- arg : np.ndarray[object] errors : {'raise','ignore','coerce'} cs:|t}t|d|dd|d}tj|ddS)Nrrrr)rrWrZtry_parse_year_month_dayrZarray_to_datetime)cargparsedrr>r?calcs  z_attempt_YYYYMMDD..calccsRtj|jdd}|d}t||<||tjtj}|d||<|S)NrrSr)rorrrrrfloat64r)rmaskrerZ masked_result)rr>r?calc_with_masks   z)_attempt_YYYYMMDD..calc_with_maskN) rrorr OverflowErrorrNrr+r.isinrr)rErwrrrr>)rrwr?rs"    rcCs,tjdttdddlm}|||||S)Nzz`to_time` has been moved, should be imported from pandas.core.tools.times. This alias will be removed in a future version.) stacklevelr)to_time)warningswarn FutureWarningrZpandas.core.tools.timesr)rErPZinfer_time_formatrwrr>r>r?rs r)rAN)NN)N)NNNrtFNNT) ..........) ..........) ..........) rtFFNNTNFrT)NFrt)h __future__r collectionsrr functoolsr itertoolsrtypingrrr r r r r rrnumpyroZ pandas._libsrZpandas._libs.tslibsrrrrrrrZpandas._libs.tslibs.parsingrrrZpandas._libs.tslibs.strptimerZpandas._typingrrrZpandas.util._exceptionsrZpandas.core.dtypes.commonrr r!r"r#r$r%r&r'r(Zpandas.core.dtypes.genericr)r*Zpandas.core.dtypes.missingr+Z pandas.arraysr,r-Z pandas.corer.Zpandas.core.algorithmsr/Zpandas.core.arrays.datetimesr0r1r2Zpandas.core.constructionr3Zpandas.core.indexes.baser4Zpandas.core.indexes.datetimesr5Zpandas._libs.tslibs.nattyper6rVr8rBintrCruZScalarr9rarKr@rOrZr`rfrsrrrrrrrrrrr>r>r>r?s     (  $   0           <,   /0%I&&&$\6