o ҷh @s(ddlmZddlmZddlmZddlmZddlm Z ddl m Z m Z m Z mZmZmZddlZddlZddlmZmZdd lmZmZmZmZmZmZmZmZm Z m!Z"dd l#m$Z$dd l%m&Z&m'Z'dd l(m)Z)dd l*m+Z+m,Z,m-Z-m.Z.ddl/m0Z0ddl1m2Z2m3Z3m4Z4m5Z5m6Z6m7Z7ddl8m9Z9m:Z:ddl;mm?Z?ddl@mAZAmBZBmCZCddlDmEZEddlFmGZGddlHmIZIddlJmKZKddlLmMZMmNZNmOZOddlPmQZQddlRmSZSddlTmUZUe rddlVmWZWddlXmYZYddlZm[Z[ddl\m]Z]m^Z^ee_e`e+fZaeebecfZdeedeejefZfeefeafZgee_ede`edd fe+fZhGd!d"d"e d#d$ZiGd%d&d&eid'd$Zjeejd(fZkd)Zlddd.d/Zm ddd8d9Zndd?d@Zo dddGdHZp dddKdLZqddPdQZr  '  R   #dddXdYZsdd[d\Ztdd]d^Zud_d`Zve dddddeZwe dddgdeZwe dddjdeZwdRd'd'd'dejxdejxdkd#f ddqdeZwidrdrdsdrdtdtdudtdvdvdwdvdxdydzdyd{d|d}d|d~ddddddddddddddddddZydddZzdddZ{gdZ|dS)) annotations)abc)date)partial)islice) TYPE_CHECKINGCallable TypedDictUnioncastoverloadN)libtslib) OutOfBoundsDatetime Timedelta Timestampastype_overflowsafeget_unit_from_dtypeiNaTis_supported_unit nat_stringsparsing timezones)precision_from_unit)DateParseErrorguess_datetime_format)array_strptime) AnyArrayLike ArrayLikeDateTimeErrorChoicesnpt)find_stack_level) ensure_objectis_float is_integeris_integer_dtype is_list_likeis_numeric_dtype) ArrowDtypeDatetimeTZDtype) ABCDataFrame ABCSeries)notna) DatetimeArray IntegerArrayNumpyExtensionArray) algorithms)unique)ArrowExtensionArray)ExtensionArray)maybe_convert_dtypeobjects_to_datetime64ns tz_to_dtype) extract_array)Index) DatetimeIndex)Hashable)NaTType) UnitChoices) DataFrameSeries.c@s&eZdZUded<ded<ded<dS)YearMonthDayDictDatetimeDictArgyearmonthdayN__name__ __module__ __qualname____annotations__rIrIN/var/www/html/venv/lib/python3.10/site-packages/pandas/core/tools/datetimes.pyr?ls  r?T)totalc@sVeZdZUded<ded<ded<ded<ded<ded<ded<ded <ded <d S) FulldatetimeDictr@hourhoursminuteminutessecondsecondsmsusnsNrDrIrIrIrJrLrs  rLFr=2dayfirst bool | Nonereturn str | NonecCsnt|}dkr5t||}tur5t||d}|dur|St||dddkr5tjdttddS)NrWzCould not infer format, so each element will be parsed individually, falling back to `dateutil`. To ensure parsing is consistent and as-expected, please specify a format. stacklevel) rfirst_non_nulltypestrrwarningswarn UserWarningr!)arrrWr`first_non_nan_elementguessed_formatrIrIrJ _guess_datetime_format_for_arraysriffffff?argArrayConvertible unique_sharefloat check_count int | NoneboolcCsd}|durt|tkrdSt|dkrt|d}nd}nd|kr-t|ks2JdJd|dkr8dSd|krEd ksJJd Jd z tt||}Wn ty]YdSwt|||krhd}|S) a Decides whether to do caching. If the percent of unique elements among `check_count` elements less than `unique_share * 100` then we can do caching. Parameters ---------- arg: listlike, tuple, 1-d array, Series unique_share: float, default=0.7, optional 0 < unique_share < 1 check_count: int, optional 0 <= check_count <= len(arg) Returns ------- do_caching: bool Notes ----- By default for a sequence of less than 50 items in size, we don't do caching; for the number of elements less than 5000, we take ten percent of all elements to check for a uniqueness share; if the sequence size is more than 5000, then we check only the first 500 elements. All constants were chosen empirically by. TNFi irz1check_count must be in next bounds: [0; len(arg)]r]z+unique_share must be in next bounds: (0; 1))lenstart_caching_atsetr TypeError)rkrmro do_cachingunique_elementsrIrIrJ should_caches.  $ ryformatcacheconvert_listlikerr>cCsddlm}|td}|rTt|s|St|tjttt fs"t |}t |}t |t |krT|||}z |||dd}Wn t yG|YSw|jjsT||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 rr>dtypeF)indexcopy)pandasr>objectry isinstancenpndarrayr3r8r+arrayr1rsrr is_unique duplicated)rkrzr{r|r> cache_array unique_dates cache_datesrIrIrJ _maybe_caches$     rdt_arrayrutcnameHashable | Noner8cCs8t|jdr|r dnd}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. utc : bool Whether to convert/localize timestamps to 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 MrNtzr)rr)r is_np_dtyperr9r8)rrrrrIrIrJ_box_as_indexlike s r DatetimeScalarOrArrayConvertiblercCs2ddlm}|||jjd|}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 rr}r~Frr)rr>rrmapr_values)rkrrr>resultrIrIrJ_convert_and_box_cache's rr np.ndarrayrbc Cstjt|td}t}t|D]1}||k}t|||}|r2|jdur,|d}n| d}n | s=| ||||<qt|dkrQt jdttdt||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 utc : bool Whether to convert/localize timestamps to UTC. name : string, default None Name for a DatetimeIndex Returns ------- tz_result : Index-like of parsed dates with timezone r~Nrr]a0In 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`r^r)remptyrsrrur1r- tz_localizetzinfo tz_convertisnaalladdrcrd FutureWarningr!r8) rrrr tz_resultsnon_na_timezoneszonemaskdtarIrIrJ_return_parsed_timezone_resultsAs&         rraiseuniterrorsr yearfirstexactc Cst|ttfrtj|dd}n t|trt|}t|dd} |r#dnd} t| trDt|tt fs8t || |dS|rB| d d}|St| t r| j tur|rt|trrtt|j} | jjdurg| d} n| d} t| }|S| jjdur|d}|S|d}|St| drtt| stt|td |d kd }t|tt fst || |dS|r| dS|S|dur|durtd t|||||St|d ddkrtdzt |dt!"| d\}} Wn2ty|d krtjdgdd#t$|} t | |dYS|dkrt||d}|YSwt%|}|dur(t&||d}|dur;|dkr;t'||||||St(|||||dd\}}|dur[t|t)|d}t j*||dSt+|||dS)a 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 utc : bool Whether to convert/localize timestamps to UTC. unit : str None or string of the frequency of the passed data errors : str error handing behaviors from to_datetime, 'raise', 'coerce', 'ignore' 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 Or~rNrrUTCrzM8[s]coerce) is_coercez#cannot specify both format and unitndimr]zAarg must be a string, datetime, list, tuple, 1-d array, or SeriesF)rrNaTzdatetime64[ns]rignorer\mixedT)rWrrr allow_objectr),rlisttuplerrr/getattrr)r-r9rrr(rarr8r r2 pyarrow_dtyper_dt_tz_convert_dt_tz_localizer rrrrasarrayr ValueError_to_datetime_with_unitrvr4 libtimezones maybe_get_tzrepeatrsr"ri_array_strptime_with_fallbackr5r6 _simple_newr)rkrzrrrrrWrr arg_dtyper arg_array_npvaluesidxr tz_parsedrrIrIrJ_convert_listlike_datetimesqs&                     rfmtcCsDt|||||d\}}tdd|Drt||||St|||dS)zL Call array_strptime, with fallback behavior depending on 'errors'. )rrrcss|]}|duVqdSNrI).0rrIrIrJ sz0_array_strptime_with_fallback..r)ranyrr)rkrrrrrrrrIrIrJrs rc Cst|dd}t|tr|d|d}d}nt|}|jjdvrX|jd|ddd}z t|td dd}Wnt yT|d krE|t }t |||||YSwd}nn|jjd krt |\}}t ||tkB} ||jd dd} d | | <| tjjks| tjjkr|d kr|t }t |||||St d|d| jd dd}tdd|| <d}n|jt dd}tj|||d\}}|dkrtj||d} nt||d} t| ts| S| d|} |r| jdur| d} | S| d} | S)zF to_datetime specalized to the case where a 'unit' is passed. T) extract_numpyz datetime64[]NiuFrM8[ns]rff8rz cannot convert input with unit ''rrUrrrrr)r7rr.astyperrrkindrrrrrisnanrrmin_valuermax datetime64rarray_with_unit_to_datetimer8 _with_inferr9rrr) rkrrrrrfrmultrrfvaluesrrIrIrJrs\               rc Cs|dkrQ|}td}|dkrtdz||}Wnty+}ztd|d}~wwtj|}tj|}t||ksHt||krOt|d|St |skt |skt t |sktd|d |d zt||d }Wn)ty}z td |d |d}~wty}z td |d|d}~ww|j durtd|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) julianrDz$unit must be 'D' for origin='julian'z3incompatible 'arg' type for given 'origin'='julian'Nz% is Out of Bounds for origin='julian'rz!' is not compatible with origin='z+'; it must be numeric with a unit specified)rzorigin z is Out of Boundsz# cannot be converted to a Timestampzorigin offset z must be tz-naiver])rto_julian_daterrvrrrrrr$r#r'rrrr&rr+r8r) rkoriginroriginalj0errj_maxj_minoffset td_offsetioffsetrIrIrJ_adjust_to_originVsh  #     rDatetimeScalarinfer_datetime_formatrc CdSrrI rkrrWrrrzrrrrr{rIrIrJ to_datetimerSeries | DictConvertiblec CrrrIrrIrIrJrr list | tuple | Index | ArrayLiker9c CrrrIrrIrIrJrrunix2DatetimeScalarOrArrayConvertible | DictConvertiblebool | lib.NoDefaultlib.NoDefault | boolr8DatetimeIndex | Series | DatetimeScalar | NaTType | Nonec  Cs"|tjur |dvr td|tjurtjdtd|dur dS| dkr*t|| |}tt||||||d} t |t rQ|} |rO|j durJ| d} | S| d} | St |tryt||| | } | jsg|| } | S| |j|}|j||j|jd } | St |ttjfrt|||} | St |trt||| | } | jst|| |jd } | S| |||jd } | St|rztttt t!t"j#d tf|}t||| | } Wnt$y|d krӂd dl%m&}|gt'd} Ynw| jst|| } | S| ||} | S| t"(|g|d } t |t)rt | t"j*rt)| } | S)as; 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 ` 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 `_. format : str, default None The strftime to parse time, e.g. :const:`"%d/%m/%Y"`. See `strftime documentation `_ 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 `_ 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 millisecond difference 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 `_. - 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** 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') '13000101' >>> 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) >rISO8601z8Cannot use 'exact' when 'format' is 'mixed' or 'ISO8601'zThe argument 'infer_datetime_format' is deprecated and will be removed in a future version. A strict version of it is now the default, see https://pandas.pydata.org/pdeps/0004-consistent-to-datetime-parsing.html. You can safely remove this argument.r^Nr)rrrWrrrr)rrrr>rrr}r~)+r no_defaultrrcrdr!rrrrrrrrr+rrrr _constructorrrr*rMutableMapping_assemble_from_unit_mappingsr8rr&r r rrr3rrrrr>rrrqbool_)rkrrWrrrzrrrrr{r|rrvaluesargcr>rIrIrJrs`     1 /  + ( & "      rAyearsrBmonthsrCdaysrMhrNrOmrPrQsrRrS millisecond millisecondsrT microsecondrU) microsecondsrU nanosecond nanosecondsc sddlm}mm}||}|jjstdddfdd|D}dd|D}gd }t t |t |}t |rOd |} td | d t t |t t } t | rnd | } td | dfdd} | ||dd| ||dd| ||d} z t| d|d} Wnttfy}ztd||d}~wwgd}|D]8}||}|dur||vrz| || |||d7} Wqttfy}z td|d||d}~wwq| 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 utc : bool Whether to convert/localize timestamps to UTC. Returns ------- Series r)r= to_numeric to_timedeltaz#cannot assemble with duplicate keyscSs,|tvrt|S|tvrt|S|Sr) _unit_maplower)valuerIrIrJrs   z'_assemble_from_unit_mappings..fcsi|]}||qSrIrI)rk)rrIrJ z0_assemble_from_unit_mappings..cSsi|]\}}||qSrIrI)rrvrIrIrJrr)rArBrC,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 )rrrIrJrs z,_assemble_from_unit_mappings..coercerA'rBdrCz%Y%m%d)rzrrzcannot assemble the datetimes: N)rrrrSrTrU)rrzcannot assemble the datetimes [z]: )rr=rrcolumnsrrkeysitemssortedrursjoinrr rrvget)rkrrr=rrunit_revrequiredreq _requiredexcess_excessrr runitsurrI)rrrrJrsf      rnpt.NDArray[np.object_]np.ndarray | Nonec sfddfdd}z |tjWStttfy!Ynwz|tj}||t|WStttfy<Ynwzt |t t }|||WStttfyYYdSw)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>|jtdd}t|d|dd|d}tj|ddS)NFrr"r#rr)rrrtry_parse_year_month_dayrarray_to_datetime)cargparsedrrIrJcalcs z_attempt_YYYYMMDD..calccsRtj|jdd}|d}t||<||tjtj}|d||<|S)Nrr~i8)rrshapeviewrrfloat64r!)r6rriresult masked_result)r8rIrJcalc_with_masks   z)_attempt_YYYYMMDD..calc_with_maskN) rrr!r OverflowErrorrvr<r,r0isinrr)rkrr?r6rrI)r8rrJ_attempt_YYYYMMDDs(    rB)rryr)F)rWrXrYrZ)rjN)rkrlrmrnrorprYrq) rkrlrzrZr{rqr|rrYr>)FN)rrrrqrrrYr8r)rkrrr>rrrYr8)rrrrqrrbrYr8)NFNrNNT)rzrZrrrrqrrZrrrWrXrrXrrq) rrqrrbrrqrrbrYr8)rrqrrbrYr8) ..........)rkrrrrWrqrrqrrqrzrZrrqrrZrrqr{rqrYr)rkrrrrWrqrrqrrqrzrZrrqrrZrrqr{rqrYr>)rkrrrrWrqrrqrrqrzrZrrqrrZrrqr{rqrYr9)rkrrrrWrqrrqrrqrzrZrrrrZrrrrbr{rqrYr)rrrrq)rkr2rrbrYr3)} __future__r collectionsrdatetimer functoolsr itertoolsrtypingrrr r r r rcnumpyr pandas._libsr rpandas._libs.tslibsrrrrrrrrrrrpandas._libs.tslibs.conversionrpandas._libs.tslibs.parsingrrpandas._libs.tslibs.strptimerpandas._typingrrrr pandas.util._exceptionsr!pandas.core.dtypes.commonr"r#r$r%r&r'pandas.core.dtypes.dtypesr(r)pandas.core.dtypes.genericr*r+pandas.core.dtypes.missingr, pandas.arraysr-r.r/ pandas.corer0pandas.core.algorithmsr1pandas.core.arraysr2pandas.core.arrays.baser3pandas.core.arrays.datetimesr4r5r6pandas.core.constructionr7pandas.core.indexes.baser8pandas.core.indexes.datetimesr9collections.abcr:pandas._libs.tslibs.nattyper;pandas._libs.tslibs.timedeltasr<rr=r>rrrlrnrbScalarrrrr@r?rLDictConvertiblertriryrrrrrrrrrrrrrB__all__rIrIrIrJs8     0                    <3  3  HH 7       ^ 4