uj UddlmZddlmZddlmZddlmZddlm Z ddl m Z m Z m Z mZmZmZddlZddlZddlmZmZdd lmZmZmZmZmZmZmZmZm Z m!Z"dd l#m$Z$m%Z%dd l&m'Z'dd l(m)Z)m*Z*dd l+m,Z,m-Z-ddl.m/Z/m0Z0m1Z1ddl2m3Z3ddl4m5Z5ddl6m7Z7m8Z8m9Z9m:Z:m;Z;mZ>ddl?m@Z@mAZAddlBmCZCmDZDddlEmFZFmGZGmHZHddlImJZJddlKmLZLddlMmNZNmOZOmPZPddlQmRZRddlSmTZTddlUmVZVddlWmXZXe r*ddlYmZZZm[Z[ddl\m]Z]ddl^m_Z_ddl.m`Z`dd lambZbmcZcdd!ldmeZemfZfegehze/zZid"ejd#<ekelzZmd"ejd$<emezejzZod"ejd%<eoeizZpd"ejd&<egemehemd'fze/zZqd"ejd(<Gd)d*e d+,ZrGd-d.erd/,Zseesd0fZtd1Zud\d]d2Zv d^ d_d3Zw d` dad4Zx db dcd5Zy d` ddd6Zz de dfd8Z{ dgd9Z| dhd:Z}didjd;Z~dkd<Ze dl dmd=Ze dl dnd>Ze dl dod?Ze3d@d7d/d/d/dejddAd+f dpdBZidCdCdDdCdEdEdFdEdGdGdHdGdIdJdKdJdLdMdNdMdOdPdQdPdRdRdSdRdTdRdUdUdVdUdUdWdWdWdXZdqdYZ drdZZgd[Zy)s) annotations)abc)date)partial)islice) TYPE_CHECKING TypeAlias TypedDictUnioncastoverloadN)libtslib) NaTOutOfBoundsDatetimeOutOfBoundsTimedelta Timedelta Timestampastype_overflowsafeiNaTis_supported_dtypeperiods_per_second timezones)cast_from_unit_vectorizeddatetime_from_fields)get_default_reso)DateParseErrorguess_datetime_format)array_strptime format_is_iso) AnyArrayLike ArrayLikeDateTimeErrorChoices) set_module)find_stack_level) ensure_object is_bool_dtypeis_floatis_float_dtype is_integeris_integer_dtype is_list_likeis_numeric_dtype) ArrowDtypeDatetimeTZDtype) ABCDataFrame ABCSeries) DatetimeArray IntegerArrayNumpyExtensionArray)unique)ExtensionArray)maybe_convert_dtypeobjects_to_datetime64 tz_to_dtype) extract_array)Index) DatetimeIndex) to_timedelta)CallableHashable)NaTType) UnitChoices)TimeUnit) DataFrameSeries)ArrowExtensionArrayTimedeltaArrayr ArrayConvertibleScalarDatetimeScalar DatetimeScalarOrArrayConvertible.DatetimeDictArgc,eZdZUded<ded<ded<y)YearMonthDayDictrKyearmonthdayN__name__ __module__ __qualname____annotations__f/var/www/html/python-recuperauto-other/env/lib/python3.12/site-packages/pandas/core/tools/datetimes.pyrMrMzs   rWrMT)totalcheZdZUded<ded<ded<ded<ded<ded<ded<ded <ded <y ) FulldatetimeDictrKhourhoursminuteminutessecondsecondsmsusnsNrQrVrWrXr[r[s8      rWr[FrC2c tj|x}dk7rit||x}turSt ||}||Stj||dzddk7r$t j dtty)NdayfirstzCould 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%)arrrirlfirst_non_nan_elementguessed_formats rX _guess_datetime_format_for_arrayrus..s33: ^)<<% = D2%N)%%##C(:(<$=>"D K /1  rWc8|y| t|ryt|dd}tj|ds2t |t s"t |t r|jturyd}|3t|tkryt|dkrt|dz}n,d}n)d |cxkrt|ksJd Jd |d k(ryd |cxkr d ksJd Jd  tt||}t|||zkDrd}|S#t$rYywxYw) 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) format : str or None, default None Strftime format to parse time. unit : str or None, default None The unit of the arg (e.g. 's', 'ms'). 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. NFdtypeMTi irz1check_count must be in next bounds: [0; len(arg)]rjz+unique_share must be in next bounds: (0; 1))r getattrr is_np_dtype isinstancer/r.rmrlenstart_caching_atsetr TypeError)arg unique_share check_countformatunit arg_dtype do_cachingunique_elementss rX should_cachersCX  mF3Wd+I  3' i 1 y* -)..I2MJ s8' ' s8t c(b.KKK+3s8+ ? + ? + !  | a N!NN N!NN fS+67 ?kL88  s#D DDcddlm}|t}|rt|||s|St |t j tttfst j|}t|}t|t|krI|||} |||d}|jjs||jj!}|S#t$r|cYSwxYw)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 unit : str, optional The unit of the arg. Returns ------- cache_array : Series Cache of converted, unique dates. Can be empty rrDrw)rrFindexcopy)pandasrDobjectrr|npndarrayr6r;r1arrayr5r}rr is_unique duplicated) rrcacheconvert_listlikerrD cache_array unique_dates cache_datess rX _maybe_cachers6v&K CT: # NE9MN((3-Cc{ | s3x '*<@K #$[ 5Q $$..);+<+<+G+G+I*IJ  ' #"" #s C C C ctj|jdr|rdnd}t|||St |||jS)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 rxutcNtzname)rrw)rr{rwr<r;)dt_arrayrrrs rX_box_as_indexliker6sA. x~~s+UtX"488 HNN ;;rWcddlm}|||jjj |}|j |j}t |jd|S)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 rrrFrr)rrDrrwmapastyper_values)rrrrDresults rX_convert_and_box_cacherSsS(C{0066 7 ; ;K HF ]];,, -F V^^T BBrWraisec ^t|ttfrtj|d}n%t|t rtj|}t |dd} |rdnd} t| trHt|ttfst|| |S|r |jdjd}|St| tr| jtur|rt|tr^t!d|j} | j"j$| j'd} n| j)d} t| d }|S| j"j$|j'd}|S|j)d}|St+j,| d r{t/| s7t1tj2|tj4d |d k(}t|ttfst|| |S|r|jdS|S|| t7dt9|||||||St |dddkDr t;d t=|d t?j@| \}} tI|}| tK||}||dk7rtM||||||StO|||||\}}|tjP|j4d}t!d|}tS||}|jUd|jVd}tjX||}tjX||St[|||S#t:$rI|d k(rBtjBtE|tjFdd} t| |cYSwxYw) 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' 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 OrrwNrrrEUTCFrrxzM8[s]coerce) is_coercez#cannot specify both format and unit)ri yearfirstndimrjzAarg must be a string, datetime, list, tuple, 1-d array, or Series)rrrrdrrhmixed)rirrerrorsrrBM8[]r).r|listtuplerrr4rzr/r2r< tz_convert tz_localizer.rmrr;r pyarrow_dtyper_dt_tz_convert_dt_tz_localizerr{rrasarrayrw ValueError_to_datetime_with_unitrr7 libtimezones maybe_get_tzfullr} datetime64r&ru_array_strptime_with_fallbackr8 datetime_datar9viewr _simple_newr)rrrrrrrirexactrr arg_array_npvaluesr tz_parsedout_unitrw dt64_valuesdtas rX_convert_listlike_datetimesrpswL#e}%hhs#& C, -hhsmWd+I4B)_-# }=> $7 7 ..&2259C Iz *y~~/J #u% !6 B **--9 ) 8 8 ?I ) 9 9% @IIE2  ((++7((/ ))%0 C (!),% 3! H,C # }=> $7 7 ??5) )   BC C% tS&8y   fa 1 $ O  $Su9R9RSU9VWQ  C ~1#If/,S$VUFSS-   FI##FLL1!4 H-Ix0kkC |1"56 '' 5A((488 V4 88C  X wws3xud)CDH 5 5 s$MAN,*N,ct|||||\}}|stj|jd}t d|}t ||} t j|| } |r| jd} t| |dS|jtk7rE|rCtj|jd}t d|}t|d |d |d } | St||j|d S) zL Call array_strptime, with fallback behavior depending on 'errors'. )rrrrrBrrrrF)rrrz, UTC])rwrr) rrrrwr r/r2rrr;r) rrrfmtrrrtz_outrrwrress rXrrs$CE&cRNFF  -a0J%65''e< ..'CSt%00  C -a0J%FCvV"44eL v||$U CCrWc t|d}t|tr>|jr |jnd}|j }|-|j }d||<nd}tj|}|jjdvr|jtjdk(r|tjtjjkD}|jrA|dk(rtd|d |j!t"}|d||<t%|||||||S|j!d |d d } |dvr1t'|} t)| tjd| d d } | t*| |<d} n|jjdk(rPtj,|}tj.d5|j!tj} dddtjtj} |tj0| j2k\|tj0| jkz}||| k(zzj5r't%| ||||||}t6|j |<|S|j!dd }tj.d5 t9||} ddd j;d} d} n5|j!t"d }t=j>||||||\} } tA| |}t|t@s|S|jCdjE| }|r0|jF|jCd}|S|jEd}|S#t$r6|dk(r|j!t"}|d||<t%|||||||cYSwxYw#1swYxYw#t$rL}|dk7r2t%|j!t"||||||cYd}~cdddStd|d |d}~wwxYw#1swYmxYw)zF to_datetime specalized to the case where a 'unit' is passed. T) extract_numpyNriuuint64rz cannot convert input with unit ''z datetime64[rFr)rcrdrfignore)invalid)rrrrrirfloat64)overrzM8[ns])rrrirunit_for_numericsrrr)$r:r|r3_hasna_mask_datarrrrwkindiinfoint64maxanyrrrrrrrisnanerrstaterminallrrrrarray_to_datetimer<rrr)rrrrrrirmaskmask_oobrrrr int_valuesi64in_int64_rangererrs rXrrs# 4 0C#|$JJsyyDii  ((*CCIjjo yy~~ 99* *RXXbhh/333H||~W$-:4&Bjj(# $CI-tS&(Ijj;tfA.Uj; | #'-H )#rxx#hZq8I/JQVW  CI 3 xx} [[ * .BHH-J . hhrxx CGG!44rzz#''?R9RS NcZ&78 9 > > @,!#F"%FLL Mjjj/ [[g &  /$? $hhx  jjej,00 "  Y3T *F fm ,    & 1 1)    sZ%N OQ O*rLt'||| ||}|j(stA|||j4}|S||||j4}|St|rA tCd|}t'||| ||}|j(stA|}|S||}|S|tIjJ|g|d }t |tLr%t |tHjNr tM|}|S#tD$r|dk(rd d l m } | gtF}YwxYw)aF; 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 : {'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`. 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 ``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. 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`. .. deprecated:: 3.1.0 Passing integer or float values together with ``format`` is deprecated; cast them to strings first. In a future version numeric values will be interpreted as epochs via ``unit`` instead, and ``format`` will only apply to string input. .. note:: If a :class:`DataFrame` is passed, then `format` has no effect. .. note:: When using ``format``, any datetime components not present in the format string default to ``1900-01-01 00:00:00``, consistent with Python's :meth:`datetime.datetime.strptime` behavior. For example, ``to_datetime(["1", "2"], format="%d")`` returns dates in January 1900. The ``origin`` parameter does not affect string parsing via ``format``; it only applies to numeric input interpreted through ``unit``. 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 numeric arg (Y, M, W, D, h, m, s, ms, us, ns, ps, fs, as). Specifies the unit of the input values when `arg` is numeric (int or float), interpreted relative to ``origin``. For example, with ``unit='ms'`` and ``origin='unix'``, the input values are treated as millisecond offsets from the Unix epoch (1970-01-01). This does not truncate or round datetime-like inputs to the given unit. To change the resolution of the result, use :meth:`Series.dt.as_unit`. To truncate datetime values, use :meth:`Series.dt.floor` or :meth:`Series.dt.normalize`. Only applicable to numeric input; has no effect on datetime-like input or when ``format`` is specified. 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.datetime64 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. .. note:: This parameter only affects numeric input used with ``unit``. It does not affect string parsing via ``format``. See the ``format`` parameter for how defaults are handled during string parsing. 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``, or when parsing datetimes with mixed time zones unless ``utc=True``. If parsing datetimes with mixed time zones, please specify ``utc=True``. 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[us] 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[us]', 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("invalid for Ymd", 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[us]', 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[us, 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 raise a ValueError unless ``utc=True``: >>> pd.to_datetime( ... ["2020-10-25 02:00 +0200", "2020-10-25 04:00 +0100"] ... ) # doctest: +SKIP ValueError: Mixed timezones detected. Pass utc=True in to_datetime or tz='UTC' in DatetimeIndex to convert to a common timezone. - To create a :class:`Series` with mixed offsets and ``object`` dtype, please use :meth:`Series.apply` and :func:`datetime.datetime.strptime`: >>> import datetime as dt >>> ser = pd.Series(["2020-10-25 02:00 +0200", "2020-10-25 04:00 +0100"]) >>> ser.apply(lambda x: dt.datetime.strptime(x, "%Y-%m-%d %H:%M %z")) 0 2020-10-25 02:00:00+02:00 1 2020-10-25 04:00:00+01:00 dtype: object - A mix of timezone-aware and timezone-naive inputs will also raise a ValueError unless ``utc=True``: >>> from datetime import datetime >>> pd.to_datetime( ... ["2020-01-01 01:00:00-01:00", datetime(2020, 1, 1, 3, 0)] ... ) # doctest: +SKIP ValueError: Mixed timezones detected. Pass utc=True in to_datetime or tz='UTC' in DatetimeIndex to convert to a common timezone. | 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[us, 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[us, 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[us, UTC]', freq=None) )rrz+errors must be one of 'raise', or 'coerce'.>rISO8601z8Cannot use 'exact' when 'format' is 'mixed' or 'ISO8601'Nrrrrrrr)rrr)rrrirrrz;list | tuple | ExtensionArray | np.ndarray | Series | Indexrr)(rr no_defaultrrzr|r1rrrrrDr,r<rrrrrremptyrrrwr _constructorrr0rMutableMapping_assemble_from_unit_mappingsr;rr rrrrboolbool_)rrrirrrrrrrarg_name arg_index is_seriesrDrrrvaluesargcs rXrrBs4B ((FGG CNN"v1E'ESTT {  3-!+C!;CII sI. VT&A X ooe,)cBBC $Sx88 #  #y! vv!.d Ma/` M_ C #"37GN   WW[)001B1BCFV MS&ckk6:F%%fCIICHH%MFP MO C,(:(:; <-c63?L MK C "37GN   +C388LFD MA&c6AF@ M? c  3 MsD'tVUF M&dF3F M""((C5/6:1= c4 Z%A&\F M+# 3  % 62K 3sK++#LLrNyearsrOmonthsrPdaysr\hr]r^mr_r`srarb millisecond millisecondsrc microsecondrd) microsecondsrd nanosecond nanosecondsc0|jj}|}t|jret j tj }|j|j|jd}||jtdz}t jt|tjt}||z}|jr4t j ||j#t$t||<|jrCt j ||j#dj#t$t||<|j'||j(|j*tS)aW Cast a numeric column to object-dtype strings so that to_datetime with a ``format`` doesn't have to infer how to interpret numeric input. GH#55663 Floats that can't be represented as int64 (e.g. +/-inf) get their plain ``str`` form, which fails to parse downstream: raise for errors="raise", NaT for errors="coerce". left) inclusiveF)rwna_valuerr)rrrw)notnato_numpyr)rwrrrbetweenrrr'rr}nanrrrrrnr$rr)r, notna_maskint_maskrin_rangeroob_masks rXstringify_numeric_columnrFs.((*JHfll#">>%))UYY&>I 1 1u 1 MM WWS["&& 7FXI%H||~::fX&6&=&=c&B&Qx||~:: 8  # #G , 3 3C 8 x   fllF  rWc 2ddlm}m}m2m}||}|j j s tdd}|jDcic] }||| }}|jD cic]\}} | | } }} gd} t| t| jz } t| r)djt| } td| dt| jttjz }t|r)djt|}td |d 2fd }t!j"t|t$ }gd }t!j&t j(}g}g}|D]o\}}| j+|}|>|j-t!j"t|t j. X|||}t!j0|}|dvrXt3|j4rMt|dk(xs<|j7|j6k\xr|j9|j8k}ngt;|j4rPt%|t!j<|k(||j6k\z||j8kzj?}nd}|r1|j-|jAt j.dnZ|j-tCd||f|j-t!j"t|t j. tE|j4rYdk(rtd|dd|dd|j-t!jFt||t j. Ct;|j4s2|j-|jAt j.dt!jH|}||t!j<|k7z}|jKrdk(rtd|d|dk\|dkz}|jKrdk(rtd|d||z|z}|jKrd||<t!jL|||}|j-|jAt j.r|jKr3tO|D]%\} \}!}t!jL|||| || <'|\}"}#}$}%}&}'tQ|"|#|$|%|&|'\}(})|)dk\rRdk(rM|"|)d|#|)dd|$|)d}*|%|)s |&|)s|'|)r|*d|%|)dd|&|)dd|'|)dz }*td|*d |jKr tR|(|<|(jUd!}+|r8tWjX|+t[d"d#$ },||,|j\d%}-n||+|j\d%}-|D]\}.} |-|||.&z }-gd)}0|0D]3}.| j+|.}1|1|1|vs |-||||1|.&z }-5|-Scc}wcc} }w#t^tf$r}/td'| |.d(|/|/d}/~/wwxYw#t^tf$r}/td'|1d(|/|/d}/~/wwxYw)*a assemble the unit specified fields from the arg (DataFrame) Return a Series for actual parsing Parameters ---------- arg : DataFrame errors : {'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` utc : bool Whether to convert/localize timestamps to UTC. Returns ------- Series r)rCrD to_numericr=z#cannot assemble with duplicate keysc|tvr t|S|jtvrt|jS|Sr) _unit_maplower)values rXrz'_assemble_from_unit_mappings..f]s; I U# # ;;=I %U[[]+ + rW)rNrOrP,zNto assemble mappings requires at least that [year, month, day] be specified: [z ] is missingz9extra keys have been passed to the datetime assemblage: [rc|}t|jr|jd}t|jr|jd}|S)Nr!rr)r)rwrr+)r,rrHs rXrz,_assemble_from_unit_mappings..coerce|sLF62 &,, ']]9-F FLL )]]7+F rWr))rNi)rOrj)rPrj)r1r)r2r)r3rN)r1r2r3FrrArz&cannot assemble the datetimes: column z has dtype boolTz contains fractional valuesllz contains out-of-bounds values-02d :z>cannot assemble the datetimes: invalid or out-of-bounds date ""zM8[us]rrcrrrzcannot assemble the datetimes [z]: )rbrcrd)0rrCrDrHr=columnsrrkeysitemsrr}joinsortedrJr,rzerosr'rint32getappendrrr+rwrrr)floorrrr r'rrrr  enumeraterrrr2rr/rr)3rrrrCrDr=rkrvunit_revrequiredreq _requiredexcess_excessrnan_mask field_speci32info field_arrstd_unitsfielddefaultcol_namevalsrr fits_structr fractional out_of_rangebadidxryear_arr month_arrday_arrhour_arr minute_arr second_arrusecs first_invalidbad_valrrr,urunitsrLrHs3 ` @rXr&r&<s* C.C ;; >??!XXZ (AqtG (D (!%.A1.H.(H h-#hmmo. .C 3xHHVC[)  11: < I   !C (8(8(:$; ;F 6{((6&>*GyPQ R   xxC-HJhhrxx GJ 8:H$=0w<<&     bhhs3xrxx@ A c(m$jj O # *!#h!mGGI,Igkk1I  *" -'++-/'++-/ce  $ !!#**RXXE*"BCmU!;T BC!!"((3s8288"DE   $   ?  f !56 >> ' 18 E-.  u x8    &G"38 E01 j </ 779 HSM((3-C#**RXX./{=0H||~!*:!6 K C!W hhx*S/JJsO KFPBHi(J / E=f/ &'q=)A#(F &s+ -  ] #-(-( H]+C0*]2KC1PJ}-c24 GLWIUV W  ||~h**X&K '' %dC 39959 3995A4  l4a? ?F 2E  Q  # ,vc%j'9&QQ  Mw ).T:& 1(1+c#G  z*  5eWCuE s< Z2 Z Z%?[%[4[  [[7 [22[7)rrr)F)ri bool | Nonereturn str | None)gffffff?NNN) rrGrfloatrz int | Nonerrrrrr'r) rrGrrrr'rr>rrrrD)FN)rr"rr'rHashable | Nonerr;)rrJrrDrrrr;)NFNrNNT)rrrrrr'rrrr#rirrrrr') rr'rrnrr'rrnrr;)rr'rrnrr;)r)rr#)rrrrFrr2) .........)rrIrr#rir'rr'rr'rrrr'rrrr'rr)rzSeries | DictConvertiblerr#rir'rr'rr'rrrr'rrrr'rrD)rz list | tuple | Index | ArrayLikerr#rir'rr'rr'rrrr'rrrr'rr<)rz2DatetimeScalarOrArrayConvertible | DictConvertiblerr#rir'rr'rr'rrrzbool | lib.NoDefaultrrrrnrr'rz1DatetimeIndex | Series | DatetimeScalar | NaTType)r,rDrrD)rr#rr'rrD) __future__r collectionsrdatetimer functoolsr itertoolsrtypingrr r r r r ronumpyr pandas._libsrrpandas._libs.tslibsrrrrrrrrrrrpandas._libs.tslibs.conversionrrpandas._libs.tslibs.dtypesrpandas._libs.tslibs.parsingrrpandas._libs.tslibs.strptimerr pandas._typingr!r"r#pandas.util._decoratorsr$pandas.util._exceptionsr%pandas.core.dtypes.commonr&r'r(r)r*r+r,r-pandas.core.dtypes.dtypesr.r/pandas.core.dtypes.genericr0r1 pandas.arraysr2r3r4pandas.core.algorithmsr5pandas.core.arrays.baser6pandas.core.arrays.datetimesr7r8r9pandas.core.constructionr:pandas.core.indexes.baser;pandas.core.indexes.datetimesr<pandas.core.tools.timedeltasr=collections.abcr>r?pandas._libs.tslibs.nattyper@pandas._libs.tslibs.timedeltasrArBrrCrDpandas.core.arraysrErFrrrGrUrrnrHrrIrJrKrMr[DictConvertibler~rurrrrrrrrrrr"rJrFr&__all__rVrWrXrs"   8 /4     *2 3*75 4:'#Ul\9)9CK "TMBMM9 9.>MMy 'u (+56 2" T TTT  T  T  Tx 2 2 2 2 2  2  2lEI<<"<2A< <@!C )CC C C@!#* !H9 H9 H9  H9  H9 ! H9H9H9 H9VD D D  D  D D8H  H  H HVQh> $'                      $'   !                    $'   )                   H$+"%..} ;} }} }  }  } } } } }7}}B  F  V  W  g    5    E   C  S  c s  c s  $ 4 D   $! "4# $ +  2>f%f,0f fR rW