a 鴫jY\ @sdZddlmZddlZddlZddlZddlmZmZm Z ddl Z ddl m Z m Z ddl mZddlmZddlmZdd lmZdd lmZdd lmZdd lmZdd lmZmZddlmZddl m!Z!ddl"m#Z#m$Z$m%Z%m&Z&m'Z'erddl(m)Z)m*Z*m+Z+m,Z,m-Z-dddddZ.d:ddddddddd Z/Gd!ddZ0Gd"d#d#e0Z1Gd$d%d%e0Z2eed&d'd;d*d+dd,d-dd.dd/d0 d1d2Z3eed&d'd(ddej4ej4ddfd3dd.dd4d5dd6d*d7 d8d9Z5dS)eZdZedddddZddddZd dd d d Zd S)rrNone)dfr!cCst|tstddS)Nz+to_parquet only supports IO with DataFrames)r:rr)rIr+r+r,validate_dataframes zBaseImpl.validate_dataframerJcKs t|dSNr )selfrIr1 compressionkwargsr+r+r,writeszBaseImpl.writeNr!cKs t|dSrLr )rMr1columnsrOr+r+r,readsz BaseImpl.read)N)r> __module__ __qualname__ staticmethodrKrPrSr+r+r+r,rsc @sZeZdZddddZdddd d d d dd ddZdddejddfddd ddddZdS)r&rHrQcCs&tdddddl}ddl}||_dS)Nr$z(pyarrow is required for parquet support.extrar)r Zpyarrow.parquetZ(pandas.core.arrays.arrow.extension_typesapi)rMr$pandasr+r+r,__init__s zPyArrowImpl.__init__snappyNrzFilePath | WriteBuffer[bytes] str | None bool | Noner/list[str] | None)rIr1rNindexr3partition_colsr!cKsN||d|ddi} |dur*|| d<|jjj|fi| } |jrtdt|ji} | jj } i| | } | | } t |||d|dud\}}}t |t jrt|drt |jttfrt |jtr|j}n|j}z`|dur|jjj| |f|||d|n|jjj| |f||d|W|durJ|n|durH|0dS) NschemaZpreserve_indexZ PANDAS_ATTRSwb)r3r4r5name)rNra filesystem)rNre)rKpoprYTableZ from_pandasattrsjsondumpsrbmetadataZreplace_schema_metadatarGr:ioBufferedWriterhasattrrdrbytesdecodeparquetZwrite_to_datasetZ write_tableclose)rMrIr1rNr`r3rarerOZfrom_pandas_kwargstable df_metadataZexisting_metadataZmerged_metadatarDrFr+r+r,rPsf           zPyArrowImpl.writeFr0DtypeBackend | lib.NoDefault)use_nullable_dtypes dtype_backendr3r!cKsd|d<i} tddd} | dkr(d| d<t|||dd\} } }z|jjj| f|||d |} t*td d tt| || d }Wdn1s0Y| dkr|j dd d}| j j rd| j j vr| j j d}t ||_|W| dur| Sn| dur | 0dS)NTZuse_pandas_metadatazmode.data_manager)ZsilentarrayZ split_blocksr.)r3r4)rRrefiltersr6zmake_block is deprecated)rwto_pandas_kwargsF)copys PANDAS_ATTRS)rrGrYrqZ read_tablerrDeprecationWarningrZ _as_managerrbrkriloadsrhrr)rMr1rRryrvrwr3rerOrzmanagerrDrFZpa_tableresultrtr+r+r,rSs\   $    zPyArrowImpl.read)r\NNNN)r>rTrUr[rPr no_defaultrSr+r+r+r,r&sEr&c@sBeZdZddddZdddd dd d d Zdd dd ddZdS)r'rHrQcCstddd}||_dS)Nr%z,fastparquet is required for parquet support.rW)r rY)rMr%r+r+r,r[+szFastParquetImpl.__init__r\Nrz*Literal['snappy', 'gzip', 'brotli'] | Noner/)rIrNr3r!c  s||d|vr"|dur"tdd|vr4|d}|durDd|d<|durTtdt|}t|rtdfdd|d <n rtd td d .|jj ||f|||d |Wdn1s0YdS)N partition_onzYCannot use both partition_on and partition_cols. Use partition_cols for partitioning dataZhiveZ file_scheme9filesystem is not implemented for the fastparquet engine.r8csj|dfipiS)Nrc)open)r1_r8r3r+r,Vsz'FastParquetImpl.write..Z open_withz?storage_options passed with file object or non-fsspec file pathT)record)rNZ write_indexr) rKr)rfr;rrr rrYrP) rMrIr1rNr`rar3rerOr+rr,rP3s@   zFastParquetImpl.write)r3r!c Ksi}|dd}|dtj} d|d<|r2td| tjurDtd|durTtdt|}d} t|rtd} | j|d fi|pij |d <n,t |t rt j |st|d d|d } | j}z>|jj|fi|} | jf||d |W| dur| Sn| dur| 0dS) NrvFrwZ pandas_nullszNThe 'use_nullable_dtypes' argument is not supported for the fastparquet enginezHThe 'dtype_backend' argument is not supported for the fastparquet enginerr8r.r2r9)rRry)rfr rr)r;rrr rr2r:rrAr1rBrrCrYZ ParquetFileZ to_pandasrr) rMr1rRryr3rerOZparquet_kwargsrvrwrFr8Z parquet_filer+r+r,rShsH     zFastParquetImpl.read)r\NNNN)NNNN)r>rTrUr[rPrSr+r+r+r,r'*s 8r'r3)r3r"r\rz$FilePath | WriteBuffer[bytes] | Noner]r^r_z bytes | None) rIr1r rNr`r3rarer!c Kstt|tr|g}t|} |dur(tn|} | j|| f|||||d||durlt| tjsdJ| SdSdS)a Write a DataFrame to the parquet format. Parameters ---------- df : DataFrame path : str, path object, file-like object, or None, default None String, path object (implementing ``os.PathLike[str]``), or file-like object implementing a binary ``write()`` function. If None, the result is returned as bytes. If a string, it will be used as Root Directory path when writing a partitioned dataset. The engine fastparquet does not accept file-like objects. engine : {{'auto', 'pyarrow', 'fastparquet'}}, default 'auto' Parquet library to use. If 'auto', then the option ``io.parquet.engine`` is used. The default ``io.parquet.engine`` behavior is to try 'pyarrow', falling back to 'fastparquet' if 'pyarrow' is unavailable. When using the ``'pyarrow'`` engine and no storage options are provided and a filesystem is implemented by both ``pyarrow.fs`` and ``fsspec`` (e.g. "s3://"), then the ``pyarrow.fs`` filesystem is attempted first. Use the filesystem keyword with an instantiated fsspec filesystem if you wish to use its implementation. compression : {{'snappy', 'gzip', 'brotli', 'lz4', 'zstd', None}}, default 'snappy'. Name of the compression to use. Use ``None`` for no compression. index : bool, default None If ``True``, include the dataframe's index(es) in the file output. If ``False``, they will not be written to the file. If ``None``, similar to ``True`` the dataframe's index(es) will be saved. However, instead of being saved as values, the RangeIndex will be stored as a range in the metadata so it doesn't require much space and is faster. Other indexes will be included as columns in the file output. partition_cols : str or list, optional, default None Column names by which to partition the dataset. Columns are partitioned in the order they are given. Must be None if path is not a string. {storage_options} filesystem : fsspec or pyarrow filesystem, default None Filesystem object to use when reading the parquet file. Only implemented for ``engine="pyarrow"``. .. versionadded:: 2.1.0 kwargs Additional keyword arguments passed to the engine Returns ------- bytes if no path argument is provided else None N)rNr`rar3re)r:rr-rlBytesIOrPgetvalue) rIr1r rNr`r3rarerOimplZ path_or_bufr+r+r, to_parquets(A  rzFilePath | ReadBuffer[bytes]zbool | lib.NoDefaultruz&list[tuple] | list[list[tuple]] | None) r1r rRr3rvrwreryr!c Ksft|} |tjur:d} |dur&| d7} tj| ttdnd}t|| j|f||||||d|S)a Load a parquet object from the file path, returning a DataFrame. Parameters ---------- path : str, path object or file-like object String, path object (implementing ``os.PathLike[str]``), or file-like object implementing a binary ``read()`` function. The string could be a URL. Valid URL schemes include http, ftp, s3, gs, and file. For file URLs, a host is expected. A local file could be: ``file://localhost/path/to/table.parquet``. A file URL can also be a path to a directory that contains multiple partitioned parquet files. Both pyarrow and fastparquet support paths to directories as well as file URLs. A directory path could be: ``file://localhost/path/to/tables`` or ``s3://bucket/partition_dir``. engine : {{'auto', 'pyarrow', 'fastparquet'}}, default 'auto' Parquet library to use. If 'auto', then the option ``io.parquet.engine`` is used. The default ``io.parquet.engine`` behavior is to try 'pyarrow', falling back to 'fastparquet' if 'pyarrow' is unavailable. When using the ``'pyarrow'`` engine and no storage options are provided and a filesystem is implemented by both ``pyarrow.fs`` and ``fsspec`` (e.g. "s3://"), then the ``pyarrow.fs`` filesystem is attempted first. Use the filesystem keyword with an instantiated fsspec filesystem if you wish to use its implementation. columns : list, default=None If not None, only these columns will be read from the file. {storage_options} .. versionadded:: 1.3.0 use_nullable_dtypes : bool, default False If True, use dtypes that use ``pd.NA`` as missing value indicator for the resulting DataFrame. (only applicable for the ``pyarrow`` engine) As new dtypes are added that support ``pd.NA`` in the future, the output with this option will change to use those dtypes. Note: this is an experimental option, and behaviour (e.g. additional support dtypes) may change without notice. .. deprecated:: 2.0 dtype_backend : {{'numpy_nullable', 'pyarrow'}}, default 'numpy_nullable' Back-end data type applied to the resultant :class:`DataFrame` (still experimental). Behaviour is as follows: * ``"numpy_nullable"``: returns nullable-dtype-backed :class:`DataFrame` (default). * ``"pyarrow"``: returns pyarrow-backed nullable :class:`ArrowDtype` DataFrame. .. versionadded:: 2.0 filesystem : fsspec or pyarrow filesystem, default None Filesystem object to use when reading the parquet file. Only implemented for ``engine="pyarrow"``. .. versionadded:: 2.1.0 filters : List[Tuple] or List[List[Tuple]], default None To filter out data. Filter syntax: [[(column, op, val), ...],...] where op is [==, =, >, >=, <, <=, !=, in, not in] The innermost tuples are transposed into a set of filters applied through an `AND` operation. The outer list combines these sets of filters through an `OR` operation. A single list of tuples can also be used, meaning that no `OR` operation between set of filters is to be conducted. Using this argument will NOT result in row-wise filtering of the final partitions unless ``engine="pyarrow"`` is also specified. For other engines, filtering is only performed at the partition level, that is, to prevent the loading of some row-groups and/or files. .. versionadded:: 2.1.0 **kwargs Any additional kwargs are passed to the engine. Returns ------- DataFrame See Also -------- DataFrame.to_parquet : Create a parquet object that serializes a DataFrame. Examples -------- >>> original_df = pd.DataFrame( ... {{"foo": range(5), "bar": range(5, 10)}} ... ) >>> original_df foo bar 0 0 5 1 1 6 2 2 7 3 3 8 4 4 9 >>> df_parquet_bytes = original_df.to_parquet() >>> from io import BytesIO >>> restored_df = pd.read_parquet(BytesIO(df_parquet_bytes)) >>> restored_df foo bar 0 0 5 1 1 6 2 2 7 3 3 8 4 4 9 >>> restored_df.equals(original_df) True >>> restored_bar = pd.read_parquet(BytesIO(df_parquet_bytes), columns=["bar"]) >>> restored_bar bar 0 5 1 6 2 7 3 8 4 9 >>> restored_bar.equals(original_df[['bar']]) True The function uses `kwargs` that are passed directly to the engine. In the following example, we use the `filters` argument of the pyarrow engine to filter the rows of the DataFrame. Since `pyarrow` is the default engine, we can omit the `engine` argument. Note that the `filters` argument is implemented by the `pyarrow` engine, which can benefit from multithreading and also potentially be more economical in terms of memory. >>> sel = [("foo", ">", 2)] >>> restored_part = pd.read_parquet(BytesIO(df_parquet_bytes), filters=sel) >>> restored_part foo bar 0 3 8 1 4 9 zYThe argument 'use_nullable_dtypes' is deprecated and will be removed in a future version.TzFUse dtype_backend='numpy_nullable' instead of use_nullable_dtype=True.) stacklevelF)rRryr3rvrwre) r-r rwarningswarn FutureWarningrrrS) r1r rRr3rvrwreryrOrmsgr+r+r, read_parquets0 r)Nr.F)Nr"r\NNNN)6__doc__ __future__rrlrirAtypingrrrrrrZpandas._config.configrZ pandas._libsr Zpandas.compat._optionalr Z pandas.errorsr Zpandas.util._decoratorsr Zpandas.util._exceptionsrZpandas.util._validatorsrrZrrZpandas.core.shared_docsrZpandas.io._utilrZpandas.io.commonrrrrrZpandas._typingrrrrrr-rGrr&r'rrrr+r+r+r,s^           %?  q "X