ujDddlmZddlmZmZddlmZddlmZddlm Z m Z m Z m Z m Z mZmZmZddlZddlZddlmZddlmZdd lmZmZdd lmZdd lmZdd lm Z m!Z!m"Z"dd l#m$Z$ddl%m&Z&ddl'm(Z(ddl)m*Z*m+Z+m,Z,ddl-m.Z.m/Z/ddl0m1Z1m2Z2m3Z3m4Z4m5Z5m6Z6m7Z7m8Z8ddl9m:Z:ddl;mZ>m?Z?m@Z@mAZAmBZBddlCmDZDddlEmFZFmGZGmHZHddlImJZJe r0ddlKmLZLmMZMmNZNddlOmPZPddlQmRZRmSZSmTZTmUZUmVZVmWZWmXZXmYZYmZZZm[Z[m\Z\ddl]m^Z^ede dZ_dKd Z`e dL dMd"Zae dL dNd#Za dO dPd&ZaGd'd(eZbGd)d*ebZcGd+d,ebZdGd-d.edZe dQd/Zfed!d!d!d!d!d!d!d!d!d!d!d!d!d!d!d!d0 dRd1Zged!d!d!d!d!d!d!d!d!d!d!d!d!d!d!d2 dSd3Zged!d!d!d!d!d!d!d!d!d!d!d!d!d!d!d!d4 dTd5Zged!d!d!d!d!d!d!d!d!d!d!d!d!d!d!d!d!d6 dUd7Zge$d8dd9ddejejd$ddd:d$dd%ddejd;d6 dVd<Zge$d=Gd>d?eje2e5ze e_ZjGd@dAZkdWdBZldXdCZmd$dD dYdEZnGdFdGekZoGdHdIekZp dZdJZqy)[) annotations)ABCabstractmethod)abc)islice) TYPE_CHECKINGAnyGenericLiteralSelfTypeVarfinaloverloadN)option_context)lib) ujson_dumps ujson_loads)iNaT)import_optional_dependency)AbstractMethodErrorOutOfBoundsDatetimePandas4Warning) set_module)find_stack_level)check_dtype_backend) ensure_stris_string_dtype pandas_dtype) PeriodDtype SparseDtype) ArrowDtype DataFrameIndex MultiIndexSeriesisnanotna to_datetime)concat)arrow_table_to_pandas) IOHandles dedup_names get_handleis_potential_multi_indexstringify_path)convert_to_line_delimits)build_table_schemaparse_table_schemaset_default_names)validate_integer)CallableHashableMapping) TracebackType) CompressionOptionsDtypeArg DtypeBackendDtypeObjFilePath IndexLabel JSONEngineJSONSerializable ReadBufferStorageOptions WriteBuffer)NDFrameFrameSeriesStrT)frameseries)boundcD|jdvxrt|t S)al Whether this dtype takes the ``.dt.as_unit`` conversion below. SparseDtype reports the subtype's kind, so the kind check alone is not enough. This is not an exhaustive test for a usable ``.dt.as_unit`` -- it only rules out what is known to reach here. Datetime-likes it returns False for are scaled to date_unit by the C encoder instead. Mm)kind isinstancer dtypes _/var/www/html/python-recuperauto-other/env/lib/python3.12/site-packages/pandas/io/json/_json.py_has_dt_accessorrPjs" ::  Dj &D"DD.cyN path_or_bufobjorient date_formatdouble_precision force_ascii date_unitdefault_handlerlines compressionindexindentstorage_optionsmodes rOto_jsonrdws rQcyrSrTrUs rOrdrds rQFinferc `|dvr| dur td|dvr| dur td| d} |r|dk7r td| d vrd | d }t|| d k(r|r|dk7r d }t||dk(r0t|tr |j|jxsd}|dk(rE|dvrtd|dt|t rkd}t j|jjtd}t|rW|jd}d}|D]>}|j||jdd|fjj!|@t|j"j$rI|s|jd}d}t|j"jj!||_t|j&j$r|s|jd}d}t|j&jj!||_nt|trt|j$r-|jd}|jj!|}t|j"j$rE|jd}t|j"jj!||_|dk(rt|t rt(}n9t|trt*}n"t|t rt,}n t/d||||||||| |  j1}|r t3|}|4t5|| | | 5}|j6j1|dddy|S#1swYyxYw)N)recordsvaluesTzT'index=True' is only valid when 'orient' is 'split', 'table', 'index', or 'columns'.r`columnsFzV'index=False' is only valid when 'orient' is 'split', 'table', 'records', or 'values'.rhz3'lines' keyword only valid when 'orient' is records)awzmode=z@ is not a valid option.Only 'w' and 'a' are currently supported.rlzNmode='a' (append) is only supported when lines is True and orient is 'records'tableri)nameepochsmsusnszInvalid value 'z' for option 'date_unit'rdeepz''obj' should be a Series or a DataFrame)rXrYrZ ensure_asciir\r]r`ra)r_rb) ValueErrorrLr%to_frameror"npnonzerodtypesmaprPlencopyisetitemilocdtas_unitr`rNrkJSONTableWriter SeriesWriter FrameWriterNotImplementedErrorwriter0r-handle)rVrWrXrYrZr[r\r]r^r_r`rarbrcmsgcopiedcolscolwriterrrhandless rOrdrdsq &&5D= %   ' 'EUN &    9$NOO :D68 8 o s{EVy%8 4 o ZV4ll 4Hl5g 3 3yk9QRS S c9 %F::cjjnn-=>?BD4yhhEh*NCLLchhq#v&6&9&9&A&A)&LMN 0(((.C!F"399-0088C  1 12(((.C!F$S[[144<))F & 0(".   rQct|rSrrs rOrzWriter._format_axes1 !$''rQc *|jdk(} t|j|j|j|j |j ||j|jS#t$r}dt|vrtd|d}~wwxYw)Niso)rXrZrxr\ iso_datesr]razMaximum recursion level reachedzUnable to serialize object to JSON: encountered an unsupported object type; convert the column to a supported type (e.g. str) before calling to_json.) rYr obj_to_writerXrZrxr\r]ra OverflowErrorrry)rrerrs rOrz Writer.write4s$$-  !!{{!%!6!6!....# $ 4 4{{   1C@:   sAA** B3B  Bcy)zObject to write in JSON format.NrTrs rOrzWriter.obj_to_writeLsrQNr)rWrDrX str | NonerYrrZintrxboolr\rr`rr](Callable[[Any], JSONSerializable] | NonerarreturnNonerrrrrz"NDFrame | Mapping[IndexLabel, Any]) __name__ __module__ __qualname____annotations__rrrpropertyrrrTrQrOrrsEI      B 6(0..rQrc*eZdZdZeddZddZy)rr`c|js<|jdk(r-|jj|jjdS|jS)Nsplit)rodata)r`rXrWrorirs rOrzSeriesWriter.obj_to_writeUs8zzdkkW4 HHMM488??C C88OrQc|jjjs)|jdk(rt d|jdyy)Nr`z(Series index must be unique for orient='')rWr` is_uniquerXryrs rOrzSeriesWriter._format_axes\sAxx~~''DKK7,BG }TUVW W-C'rQNrrrrrrrrrrTrQrOrrRsO  XrQrc*eZdZdZeddZddZy)rrkc|js0|jdk(r!|jjd}|d=|S|j}|S)Nr)rXr`)r`rXrWto_dict)rrs rOrzFrameWriter.obj_to_writedsLzzdkkW488++7+;LW% 88LrQc"|jjjs'|jdvrt d|jd|jj js(|jdvrt d|jdyy)z: Try to format axes if they are datelike. rjz+DataFrame index must be unique for orient='z'.)r`rkrhz-DataFrame columns must be unique for orient='N)rWr`rrXryrkrs rOrzFrameWriter._format_axesmsxx~~''DKK;O,O=dkk]"M xx))dkk> / ? }BO  / )rQNrrrrTrQrOrrasO rQrc^eZdZdZ d dfd ZeddZxZS)rrhc $t ||||||||||  |dk7rd|d} t| t||j|_|jr t |}|jdk(r%t|jtr td|jdk(r+|jt|jjvs8t|jj!|jjr d } t| |j#d g j} d } t| r*|j%}d } || j'd|| <|js|j)d |_nnt|jj,t.r3| s|j%d }|jj1|_|j)d |_d|_d|_||_y)z Adds a `schema` attribute with the Table Schema, resets the index (can't do in caller, because the schema inference needs to know what the index is, forces orient to records, and forces date_format to 'iso'. )r]rarz8Trying to write with `orient='table'` and `date_format='zH'`. Table Schema requires dates to be formatted with `date_format='iso'`)r`z6orient='table' is not supported for MultiIndex columnsz/Overlapping names between the index and columns timedelta)includeFTc"|jSrS) isoformat)xs rOz*JSONTableWriter.__init__..s AKKMrQ)droprvrhN)superrryr1r`schemar3ndimrLrkr$rrosetnamesr intersection select_dtypesrr~ reset_indexrWrNr to_timestamprYrX)rrWrXrYrZrxr\r`r]rar timedeltasr __class__s rOrzJSONTableWriter.__init__s$        +   % !!, .;;  S/ !(DJJ? ::#C(C 88q=Z Z@%H  XX]S-A!As KK $ $SYY__ 5H DCS/ !&& }&=EE  z?((*CF!*o112IJC OzzD1DH#))//;7(((.CII224 E2DH   rQc4|j|jdS)N)rr)rrWrs rOrzJSONTableWriter.obj_to_writes++txx88rQr)rXrrYrrZrrxrr\rr`rr]rrarrrr)rrrrrrr __classcell__)rs@rOrrsOEIJJ J  J  JJJBJJ JX99rQrc dd} |dk7r| d|| d|dur|tjur| d|dur|tjur| d|d ur| d || d | | d | d k7r| d||jdvr| d| |dk7r| dt|trC|j D]/\} } tt | tr td| d| y| | dyy)a= Reject ``read_json`` arguments the ``"pyarrow"`` engine cannot honor. The pyarrow engine hands the input straight to ``pyarrow.json.read_json``, so any argument that pandas would otherwise apply itself is silently ignored, producing a wrong result rather than an error. Raise instead. Called from ``read_json`` before ``convert_axes`` and ``dtype`` are resolved from ``None`` to ``True`` (and ``convert_dates`` / ``keep_default_dates`` from ``lib.no_default``), so that an explicitly-passed value is distinguishable from the default. c td|d)NzThe z2 option is not supported with the 'pyarrow' engine)ry)argnames rOraise_unsupportedz;_validate_pyarrow_engine_options..raise_unsupporteds7+O P  rQrFtypN convert_axesT convert_dateskeep_default_datesF precise_floatr\rbrfr_)zutf-8utf8encodingstrictencoding_errorszQThe 'pyarrow' engine only supports ArrowDtype values in the 'dtype' mapping, got z for column rN)rrrr) r no_defaultlowerrLdictitemsrr!ry)rrNrrrrr\rrr_rbrfield field_dtypes rO _validate_pyarrow_engine_optionsrs?6  g~% .)D ]#..%H/*%* [index], columns -> [columns], data -> [values]}`` - ``'records'`` : list like ``[{column -> value}, ... , {column -> value}]`` - ``'index'`` : dict like ``{index -> {column -> value}}`` - ``'columns'`` : dict like ``{column -> {index -> value}}`` - ``'values'`` : just the values array - ``'table'`` : dict like ``{'schema': {schema}, 'data': {data}}`` When ``typ == 'series'``, the shapes differ, since a Series has no columns: - ``'split'`` : dict like ``{name -> name, index -> [index], data -> [values]}`` - ``'records'`` : list like ``[value, ... , value]`` - ``'index'`` : dict like ``{index -> value}`` The allowed and default values depend on the value of the `typ` parameter. * when ``typ == 'series'``, - allowed orients are ``{'split','records','index'}`` - default is ``'index'`` - The Series index must be unique for orient ``'index'``. * when ``typ == 'frame'``, - allowed orients are ``{'split','records','index', 'columns','values', 'table'}`` - default is ``'columns'`` - The DataFrame index must be unique for orients ``'index'`` and ``'columns'``. - The DataFrame columns must be unique for orients ``'index'``, ``'columns'``, and ``'records'``. typ : {'frame', 'series'}, default 'frame' The type of object to recover. dtype : bool or dict, default None If True, infer dtypes; if a dict of column to dtype, then use those; if False, then don't infer dtypes at all, applies only to the data. For all ``orient`` values except ``'table'``, default is True. convert_axes : bool, default None Try to convert the axes to the proper dtypes. For all ``orient`` values except ``'table'``, default is True. convert_dates : bool or list of str, default True If True then default datelike columns may be converted (depending on keep_default_dates). If False, no dates will be converted. If a list of column names, then those columns will be converted and default datelike columns may also be converted (depending on keep_default_dates). .. deprecated:: 3.1.0 Pass ``dtype=False`` to disable type conversion, or parse date columns with :func:`~pandas.to_datetime` after reading. keep_default_dates : bool, default True If parsing dates (convert_dates is not False), then try to parse the default datelike columns. A column label is datelike if * it ends with ``'_at'``, * it ends with ``'_time'``, * it begins with ``'timestamp'``, * it is ``'modified'``, or * it is ``'date'``. .. deprecated:: 3.1.0 Pass ``dtype=False`` to disable type conversion, or parse date columns with :func:`~pandas.to_datetime` after reading. precise_float : bool, default False Set to enable usage of higher precision (strtod) function when decoding string to double values. Default (False) is to use fast but less precise builtin functionality. date_unit : str, default None The timestamp unit to detect if converting dates. The default behaviour is to try and detect the correct precision, but if this is not desired then pass one of 's', 'ms', 'us' or 'ns' to force parsing only seconds, milliseconds, microseconds or nanoseconds respectively. encoding : str, default is 'utf-8' The encoding to use to decode py3 bytes. encoding_errors : str, optional, default "strict" How encoding errors are treated. `List of possible values `_ . lines : bool, default False Read the file as a json object per line. chunksize : int, optional Return JsonReader object for iteration. See the `line-delimited json docs `_ for more information on ``chunksize``. This can only be passed if `lines=True`. If this is None, the file will be read into memory all at once. compression : str or dict, default 'infer' For on-the-fly decompression of on-disk data. If 'infer' and 'path_or_buf' is path-like, then detect compression from the following extensions: '.gz', '.bz2', '.zip', '.xz', '.zst', '.tar', '.tar.gz', '.tar.xz' or '.tar.bz2' (otherwise no compression). If using 'zip' or 'tar', the ZIP file must contain only one data file to be read in. Set to ``None`` for no decompression. Can also be a dict with key ``'method'`` set to one of {``'zip'``, ``'gzip'``, ``'bz2'``, ``'zstd'``, ``'xz'``, ``'tar'``} and other key-value pairs are forwarded to ``zipfile.ZipFile``, ``gzip.GzipFile``, ``bz2.BZ2File``, ``zstandard.ZstdDecompressor``, ``lzma.LZMAFile`` or ``tarfile.TarFile``, respectively. As an example, the following could be passed for Zstandard decompression using a custom compression dictionary: ``compression={'method': 'zstd', 'dict_data': my_compression_dict}``. nrows : int, optional The number of lines from the line-delimited jsonfile that has to be read. This can only be passed if `lines=True`. If this is None, all the rows will be returned. storage_options : dict, optional Extra options that make sense for a particular storage connection, e.g. host, port, username, password, etc. For HTTP(S) URLs the key-value pairs are forwarded to ``urllib.request.Request`` as header options. For other URLs (e.g. starting with "s3://", and "gcs://") the key-value pairs are forwarded to ``fsspec.open``. Please see ``fsspec`` and ``urllib`` for more details, and for more examples on storage options refer `here `_. dtype_backend : {'numpy_nullable', 'pyarrow'} Back-end data type applied to the resultant :class:`DataFrame` (still experimental). If not specified, the default behavior is to not use nullable data types. If specified, the behavior is as follows: * ``"numpy_nullable"``: returns nullable-dtype-backed :class:`DataFrame` * ``"pyarrow"``: returns pyarrow-backed nullable :class:`ArrowDtype` :class:`DataFrame` .. versionadded:: 2.0 engine : {"ujson", "pyarrow"}, default "ujson" Parser engine to use. The ``"pyarrow"`` engine is only available when ``lines=True``, and only supports ``typ="frame"`` with default parsing options; passing an option it cannot apply (for example ``convert_dates``, ``date_unit``, ``precise_float``, ``encoding``, or a non-``ArrowDtype`` ``dtype``) raises ``ValueError``. .. versionadded:: 2.0 Returns ------- Series, DataFrame, or pandas.api.typing.JsonReader A JsonReader is returned when ``chunksize`` is not ``0`` or ``None``. Otherwise, the type returned depends on the value of ``typ``. See Also -------- DataFrame.to_json : Convert a DataFrame to a JSON string. Series.to_json : Convert a Series to a JSON string. json_normalize : Normalize semi-structured JSON data into a flat table. Notes ----- Specific to ``orient='table'``, if a :class:`DataFrame` with a literal :class:`Index` name of `index` gets written with :func:`to_json`, the subsequent read operation will incorrectly set the :class:`Index` name to ``None``. This is because `index` is also used by :func:`DataFrame.to_json` to denote a missing :class:`Index` name, and the subsequent :func:`read_json` operation cannot distinguish between the two. The same limitation is encountered with a :class:`MultiIndex` and any names beginning with ``'level_'``. Examples -------- >>> from io import StringIO >>> df = pd.DataFrame( ... [["a", "b"], ["c", "d"]], ... index=["row 1", "row 2"], ... columns=["col 1", "col 2"], ... ) Encoding/decoding a Dataframe using ``'split'`` formatted JSON: >>> df.to_json(orient="split") '{"columns":["col 1","col 2"],"index":["row 1","row 2"],"data":[["a","b"],["c","d"]]}' >>> pd.read_json(StringIO(_), orient="split") # noqa: F821 col 1 col 2 row 1 a b row 2 c d Encoding/decoding a Dataframe using ``'index'`` formatted JSON: >>> df.to_json(orient="index") '{"row 1":{"col 1":"a","col 2":"b"},"row 2":{"col 1":"c","col 2":"d"}}' >>> pd.read_json(StringIO(_), orient="index") # noqa: F821 col 1 col 2 row 1 a b row 2 c d Encoding/decoding a Dataframe using ``'records'`` formatted JSON. Note that index labels are not preserved with this encoding. >>> df.to_json(orient="records") '[{"col 1":"a","col 2":"b"},{"col 1":"c","col 2":"d"}]' >>> pd.read_json(StringIO(_), orient="records") # noqa: F821 col 1 col 2 0 a b 1 c d Encoding with Table Schema >>> df.to_json(orient="table") '{"schema":{"fields":[{"name":"index","type":"string","extDtype":"str"},{"name":"col 1","type":"string","extDtype":"str"},{"name":"col 2","type":"string","extDtype":"str"}],"primaryKey":["index"],"pandas_version":"1.4.0"},"data":[{"index":"row 1","col 1":"a","col 2":"b"},{"index":"row 2","col 1":"c","col 2":"d"}]}' The following example uses ``dtype_backend="numpy_nullable"`` >>> data = '''{"index": {"0": 0, "1": 1}, ... "a": {"0": 1, "1": null}, ... "b": {"0": 2.5, "1": 4.5}, ... "c": {"0": true, "1": false}, ... "d": {"0": "a", "1": "b"}, ... "e": {"0": 1577.2, "1": 1577.1}}''' >>> pd.read_json(StringIO(data), dtype_backend="numpy_nullable") index a b c d e 0 0 1 2.5 True a 1577.2 1 1 4.5 False b 1577.1 rnz)cannot pass both dtype and orient='table'z0cannot pass both convert_axes and orient='table'pyarrow) rrNrrrrr\rrr_rbzThe 'convert_dates' keyword in read_json is deprecated and will be removed in a future version. Pass dtype=False to disable type conversion, or parse date columns with pd.to_datetime after reading. stacklevelTzThe 'keep_default_dates' keyword in read_json is deprecated and will be removed in a future version. Pass dtype=False to disable type conversion, or parse date columns with pd.to_datetime after reading.rXrrNrrrrr\rr^rr_rrbrrr) ryrrrrwarningswarnrr JsonReaderread)rVrXrrNrrrrr\rrr^rr_rrbrr json_readers rOrr{sZ UDEE \KLL &  )%'1'+#+ CNN*  S ')   /  S ')  " }7* ' 1    "  $ .$ ( (!"$#$%K*!!rQzpandas.api.typingcBeZdZdZddej df ddZdZddZe ddZ e dd Z e dd Z dd Z dd Z dd Z ddZ ddZd dZe ddZe ddZe ddZddZd dZ d!dZy)"ra) JsonReader provides an interface for reading in a JSON file. If initialized with ``lines=True`` and ``chunksize``, can be iterated over ``chunksize`` lines at a time. Otherwise, calling ``read`` reads in the whole document. A ``JsonReader`` is returned by :func:`~pandas.read_json` when ``chunksize`` is passed; it is not usually instantiated directly. Parameters ---------- filepath_or_buffer : a str path, path object or file-like object Any valid string path is acceptable. The string could be a URL. Valid URL schemes include http, ftp, s3, and file. pandas accepts any ``os.PathLike``, or file-like object with a ``read()`` method, such as a file handle or ``StringIO``. orient : str Indication of expected JSON string format. Compatible JSON strings can be produced by ``to_json()`` with a corresponding orient value. See :func:`~pandas.read_json` for the set of possible orients. typ : {"frame", "series"} The type of object to recover. dtype : bool or dict If True, infer dtypes; if a dict of column to dtype, then use those; if False, then don't infer dtypes at all, applies only to the data. convert_axes : bool or None Try to convert the axes to the proper dtypes. convert_dates : bool or list of str If True then default datelike columns may be converted (depending on ``keep_default_dates``). If False, no dates will be converted. If a list of column names, then those columns will be converted and default datelike columns may also be converted (depending on ``keep_default_dates``). keep_default_dates : bool If parsing dates (``convert_dates`` is not False), then try to parse the default datelike columns. See :func:`~pandas.read_json` for the criteria used to determine whether a column label is datelike. precise_float : bool Set to enable usage of higher precision (strtod) function when decoding string to double values. date_unit : str or None The timestamp unit to detect if converting dates. The default behaviour is to try and detect the correct precision, but if this is not desired then pass one of 's', 'ms', 'us' or 'ns' to force parsing only seconds, milliseconds, microseconds or nanoseconds respectively. encoding : str or None The encoding to use to decode py3 bytes. lines : bool Read the file as a json object per line. chunksize : int or None Return a ``JsonReader`` for iteration, yielding ``chunksize`` lines at a time. Can only be passed if ``lines=True``. If this is None, the file will be read into memory all at once. compression : str or dict For on-the-fly decompression of on-disk data, see :func:`~pandas.read_json` for the accepted values. nrows : int or None The number of lines from the line-delimited json file that has to be read. Can only be passed if ``lines=True``. If this is None, all the rows will be returned. storage_options : dict, optional Extra options that make sense for a particular storage connection, e.g. host, port, username, password, etc. See :func:`~pandas.read_json` for more details. encoding_errors : str, optional, default "strict" How encoding errors are treated. `List of possible values `_ . dtype_backend : {"numpy_nullable", "pyarrow"} Back-end data type applied to the resultant :class:`DataFrame` (still experimental). See :func:`~pandas.read_json` for more details. engine : {"ujson", "pyarrow"}, default "ujson" Parser engine to use. See :func:`~pandas.read_json` for the restrictions on the ``"pyarrow"`` engine. See Also -------- read_json : Convert a JSON string to pandas object. Examples -------- >>> from io import StringIO >>> df = pd.DataFrame({"a": [1, 2], "b": [3, 4]}) >>> reader = pd.read_json( ... StringIO(df.to_json(orient="records", lines=True)), ... lines=True, ... chunksize=1, ... ) >>> for chunk in reader: ... print(chunk) a b 0 1 3 a b 1 2 4 Nrrc||_||_||_||_||_||_||_| |_| |_||_ | |_ ||_ | |_ | |_ d|_||_||_d|_||_|jdvrt'd|jd|jMt)d|jd|_ |js t'd|jdk(r t'd |jMt)d |jd|_|js t'd |jdk(r t+d |jdk(r|js t'd ||_y|jdk(rR|j/|}|j-|j!|5|j1|_dddy||_yy#1swYyxYw)Nr>rrzThe engine type z is currently not supported.rrz*chunksize can only be passed if lines=Truerz> %-k4>>1MDN:: !MNN{{i' R :: !)'4::qADJ:: !IJJ{{i')N ;;) #:: 5+DI [[G #//0BCD~~%$***<, $ DI,,! $ ,,s G//G8ct|}t|d|j|j|j|j |_|j j}|S)z The function read_json accepts three input types: 1. filepath (string-like) 2. file-like object (e.g. open file object, StringIO) r)rr_rberrors)r/r-rr_rbrrr)rrs rOrz"JsonReader._get_data_from_filepaths\ ,,>?!  ]](( 00''   "\\00!!rQcfddjd|DDcgc]}|s| c}dScc}w)zG Combines a list of JSON objects into one JSON object. [,c3<K|]}|jywrS)strip).0lines rO z,JsonReader._combine_lines..s+KTDJJL+Ks])join)rr^rs rO_combine_lineszJsonReader._combine_liness6 +KU+KT4t$TUVVW X Ts. . cyrSrTrs rOrzJsonReader.reads?BrQcyrSrTrs rOrzJsonReader.reads=@rQcyrSrTrs rOrzJsonReader.readsRUrQc|5|jdk(r|j}n|jdk(r|j}dddS#1swYSxYw)a Read the whole JSON input into a pandas object. Unlike iterating over the reader, this reads the entire underlying JSON input in a single call, regardless of whether ``chunksize`` was specified when this reader was created. Returns ------- DataFrame or Series The parsed pandas object, depending on the ``typ`` passed when this reader was created. See Also -------- read_json : Convert a JSON string to pandas object. Examples -------- >>> from io import StringIO >>> df = pd.DataFrame({"a": [1, 2], "b": [3, 4]}) >>> reader = pd.read_json( ... StringIO(df.to_json(orient="records", lines=True)), ... lines=True, ... chunksize=2, ... ) >>> reader.read() a b 0 1 3 1 2 4 rrN)r _read_pyarrow _read_ujsonrrWs rOrzJsonReader.readsZB ){{i'((*'&&(  )   )  s AA  Actd}d}t|jtrtd}g}|jj D]>\}}t |}t|t s"|j||jf@|j|}|j|d}|j|j|} t| |j} | S)z5 Read JSON using the pyarrow engine. z pyarrow.jsonNrrf)explicit_schemaunexpected_field_behavior) parse_optionsr)rrLrNrrrr!append pyarrow_dtyper ParseOptionsrrr*r) r pyarrow_jsonoptionspafieldsrrNpd_dtyperpa_tabledfs rOrzJsonReader._read_pyarrows2.A  djj$ '+I6BF $ 0 0 2 C u'.h 3MM5(*@*@"AB C YYv&F"// &'0G ))$))7)K "84;M;M N rQc|jr|jr:t|}|r t|}n|j |j g}n|j Ltt|j|j }|j |}|j |}nbt|j}|jd}|j |j |}n|j |j}|jtjur2tdd5|j|jcdddS|S#1swYyxYw)z3 Read JSON using the ujson engine. N future.distinguish_nan_and_naFr)r^rlistr)_get_object_parserrrrrrrrrrrconvert_dtypes)rchunksrWr^ lines_jsonr data_liness rOrzJsonReader._read_ujsons* ::~~d .C11$2E2Eb2IJC'VDIItzz:;!007 --j9!$)),!ZZ- --d.A.A*.MN))$))4C   S^^ 3 ?G L))8J8J)K L LJ L Ls 5EE&c |j}|j}|j|j|j|j|j |j |j|jd}|dk(rt|fi|jS|dk(r/t|ts||d<t|fi|jStd|d)z> Parses a json document into a pandas object. )rXrNrrrrr\rrFrGrNztyp=z must be 'frame' or 'series'.)rrNrXrrrrr\r FrameParserparserLr SeriesParserry)rjsonrrNkwargss rOr-zJsonReader._get_object_parser/shh kkZZ --!//"&"9"9!//!//   '>t.v.446 6 H_eT*"'w//557 7v%BCD DrQcR|j|jjyy)a Close the underlying file handle, if one was opened by the reader. If an open stream or file-like object was passed to the reader rather than a path, it is left open and this method does not close it. See Also -------- read_json : Convert a JSON string to pandas object. Examples -------- >>> from io import StringIO >>> df = pd.DataFrame({"a": [1, 2], "b": [3, 4]}) >>> reader = pd.read_json( ... StringIO(df.to_json(orient="records", lines=True)), ... lines=True, ... chunksize=1, ... ) >>> reader.close() N)rclosers rOr9zJsonReader.closeHs#. << # LL    $rQc|SrSrTrs rO__iter__zJsonReader.__iter__b rQcyrSrTrs rO__next__zJsonReader.__next__esCFrQcyrSrTrs rOr>zJsonReader.__next__hsADrQcyrSrTrs rOr>zJsonReader.__next__ks!rQc6|jZ|j|jz }|dkr|jt|j|}n#t |j|}n |j}t t|j|}|s|jt |j|}|j|}t|j|jt|z|_ |xjt|z c_|jt j"ur2t%dd5|j'|jcdddS|S#t$r}|j|d}~wwxYw#1swYyxYw)Nrr+Fr)rrr9 StopIterationrminr,rrrr-rangerr` Exceptionrrrrr.)r remaining chunk_sizer^r0rWexs rOr>zJsonReader.__next__psW :: ! T__4IA~ ##~~%&  ; JVDIIz23 JJL  ,,U3J))*5CdootS/IJCI OOs3x 'O   S^^ 3 ?G L))8J8J)K L LJ  JJLH   L Ls%+A1E,F, F 5FF Fc|SrSrTrs rO __enter__zJsonReader.__enter__r<rQc$|jyrS)r9)rexc_type exc_value tracebacks rO__exit__zJsonReader.__exit__s rQ)rrEr bool | Nonerrrrr^rr int | Noner_r9rrQrbStorageOptions | NonerrrDtypeBackend | lib.NoDefaultrr?rrr)rJsonReader[Literal['frame']]rr")rJsonReader[Literal['series']]rr%)rz&JsonReader[Literal['frame', 'series']]rDataFrame | SeriesrrVrr")r6rrrVr)rr )rLztype[BaseException] | NonerMzBaseException | NonerNzTracebackType | Nonerr)rrr__doc__rrrrrrrrrr-r9r;r>rJrOrTrQrOrrs}`d26&.69nn$'L! L! " L!!L!L!L!L!(L!L! /!L!"$#L!$4%L!&'L!( )L!\"$ BB @@ UU'R28E2!4FF DD !4! !!"H,((   rQrceZdZUded<ded<dZdddd dZded <d d d d d d ejf ddZe ddZ e ddZ ddZ e ddZ dZe d ddZe ddZy )Parserztuple[str, ...] _split_keysrrrqi3l,b/l`'rlF[L'r6NTFc `||_| |j}||_||_|K|j }||j vrt d|j |j||_n|jd|_||_ ||_ ||_ ||_ ||_ | |_y)Nzdate_unit must be one of rr)r6rrXrNr _STAMP_UNITSry _MIN_STAMPS min_stamprrrr\rr) rr6rXrNrrrrr\rs rOrzParser.__init__s >))F   !)I 1 11 #>X %8)C ;;w/ hnn))299 5X%%&dnn,.##t+-  <<> >>X %4 ! ,,D9V))(3$/QW$X  $Y&+=i+H&vDI  ! !p K/3nn$..*$BSBSJI L'! % ,,D9V))(3 %0$W9% &LL006'+ &(\*62$D E! %2(*95-h7 +62$D Q!  z*  (% D,"%!   skH%H8<H(>I$+I H%H%$H%( H51H84H55H88I I!I$ I!!I$$I- )r6rrNDtypeArg | Nonerrrbool | list[str]rrrrrrSrr)rdzdict[str, Any]rrrW)rWrVrrV)TTF) ror6rr%rnrrrrorrztuple[Series, bool])rr%rr%)rrrrr^r_rrrrrgr4rirjrkrrrrTrQrOr[r[s\  *L  K I "&!*.#(#69nn"+"+ "+  "+ ( "+!"+"+4"+ "+H T T  (  &(  *. YYY Y ( Y  Y Y Yv X XrQr[c|jjdk7ryt|jjdk(j S)a Whether a speculative string date parse only succeeded by filling in defaults. GH#63473: ``to_datetime`` falls back to ``dateutil`` for strings it cannot match against a format, and ``dateutil`` takes the year absent from the string from ``datetime(1, 1, 1)``. Strings like ``"Jan"`` or ``"1st"`` parse that way, so accepting the result would silently turn ordinary labels into year 1 timestamps. Strings carrying only a time of day are filled from *today* instead and so are not caught here. A year-1 result is genuine when the strings parse under a strict ISO8601 format, which rejects ``"Jan"`` outright; callers check that separately, either by having attempted ``format="ISO8601"`` themselves or via ``_parses_strict_iso8601``. MFr)rNrKrryearany)rs rOrrs< s" ""a',,. //rQctj5tjd t|dd dddy#t$r YdddywxYw#1swYyxYw)a$ Whether every entry of ``data`` parses under a strict ISO8601 format. Used to tell a genuine out-of-nanosecond-bounds date apart from a default-filled parse on the object-dtype path, which -- unlike the string-dtype path -- does not attempt ``format="ISO8601"`` itself. ignorerrrNFT)rrrr(rE)rs rOrrsi  " h'  WY ?       s(AA A AAAA$rc|D]S}|rt|jtr tj|j |jt Uy)a Re-emit the warnings captured from a date parse ``_try_convert_to_date`` may discard. GH#50907: it parses the same values several ways and keeps at most one result. The quarterly-string deprecation asks the user to change a call, so it may only be emitted for the parse whose result they actually receive. Unrelated warnings keep the visibility they had before. rN)rcategory UserWarningrrmessager)rrwarnings rOrrsJ  Jw/?/?$M  OO   ')  rQc$eZdZdZdZddZddZy)r5r`)ror`rct|j|j}|jdk(rH|j Dcic]\}}t ||}}}|j |tdi|St|Scc}}w)NrrrT)rr6rrXrrrgr%)rrkvrds rOrizSeriesParser._parsest499D4F4FG ;;' !-1ZZ\:TQs1vqy:G:  ! !' *$G$ $$<  ;sBcH|jd||j\}}|S)Nrr)rrr)rrWrs rOrkzSeriesParser._try_convert_typess(''4CUCU'VQ rQN)rr%)rWr%rr%rrrrr\rirkrTrQrOr5r5sO+K rQr5c$eZdZdZdZddZddZy)r3rk)rkr`rc||j}|j}|dk(rt||jj Dcic]\}}t ||}}}|j ||dDcgc]}t|tr t|n|!}}t|t|d|d<td ddi|S|dk(r-tjt||jddS|dk(rt||jStt||jdScc}}wcc}w) NrrrkrNr`)rNrXrnrMrT)r6rXrrrrrgrLr,tupler,r.r" from_dictr2)rr6rXrrrdr orig_namess rOrizFrameParser._parsesOyy W (D'>!/IFA MM&,, ' (%% CKKU  rQNrX)rWr"rr"rrTrQrOr3r3 sO.KB rQr3c|duryt|ts|t|vry|syt|tsy|j }|j ds|dvs|j dryy)zL Return bool whether a DataFrame column should be cast to datetime. FT)_at_time>datedatetimemodified timestamp)rLrrrrendswith startswith)rrr col_lowers rOrrBsr  t ,M8J1J  S ! I+, 8 8    , rQ)rNr<rr) ............)rVz0FilePath | WriteBuffer[str] | WriteBuffer[bytes]rWrDrXrrYrrZrr[rr\rr]rr^rr_r9r`rPrarrbrBrcLiteral['a', 'w']rr)rVrrWrDrXrrYrrZrr[rr\rr]rr^rr_r9r`rPrarrbrBrcrrr) Nrp TrsNFrfNrNrm)rVz7FilePath | WriteBuffer[str] | WriteBuffer[bytes] | NonerWrDrXrrYrrZrr[rr\rr]rr^rr_r9r`rPrarrbrRrcrrrr)&rV.FilePath | ReadBuffer[str] | ReadBuffer[bytes]rXrrLiteral['frame']rNrrrPr bool | list[str] | lib.NoDefaultrbool | lib.NoDefaultrrr\rrrrrr^rrrr_r9rrQrbrBrrSrr?rrT)&rVrrXrrLiteral['series']rNrrrPrrrrrrr\rrrrrr^rrrr_r9rrQrbrBrrSrr?rrU)&rVrrXrrrrNrrrPrrrrrrr\rrrrrr^rrrr_r9rrQrbrBrrSrr?rr%)&rVrrXrrrrNrrrPrrrrrrr\rrrrrr^rrrr_r9rrQrbrBrrSrr?rr")&rVrrXrrzLiteral['frame', 'series']rNrrrPrrrrrrr\rrrrrr^rrrQr_r9rrQrbrRrrSrr?rz$DataFrame | Series | JsonReader[Any])rr%rr)rr%rr)rzlist[warnings.WarningMessage]rrrr)rrrrrr6rr)r __future__rrrr collections itertoolsrtypingrr r r r r rrrnumpyr{pandas._configr pandas._libsrpandas._libs._ujsonrrpandas._libs.tslibsrpandas.compat._optionalr pandas.errorsrrrpandas.util._decoratorsrpandas.util._exceptionsrpandas.util._validatorsrpandas.core.dtypes.commonrrrpandas.core.dtypes.dtypesrr rr!r"r#r$r%r&r'r(pandas.core.reshape.concatr)pandas.io._utilr*pandas.io.commonr+r,r-r.r/pandas.io.json._normalizer0pandas.io.json._table_schemar1r2r3pandas.io.parsers.readersr4collections.abcr5r6r7typesr8pandas._typingr9r:r;r<r=r>r?r@rArBrCpandas.core.genericrDrErPrdrrrrrrrIteratorrr[rrrr5r3rrTrQrOrsw "   )%> /47    .1? 7 $    ,+7;L3MN E @C&)&)!A       > $  $   $ @C&)&)!       > $  $   *@D&--1!sHs s s s  s  ss>s s$s s s+s ssl<.S<.~ X6 X&