ɯeikddlZddlZddlZddlZddlmZmZmZmZm Z m Z ddl Z ddl mZmZddlmZddlmZmZmZmZmZmZmZmZGddeZGdd eZGd d eZGd d Zy)N)IODictList NamedTupleOptionalUnion)OperationalErrorProgrammingError)SnowparkClientExceptionMessages)get_local_file_pathis_in_stored_procedureis_single_quotednormalize_local_filenormalize_remote_file_or_dirresult_set_to_rows split_pathvalidate_stage_locationcbeZdZUdZeed<eed<eed<eed<eed<eed<eed<eed <y ) PutResultzERepresents the results of uploading a local file to a stage location.sourcetarget source_size target_sizesource_compressiontarget_compressionstatusmessageN)__name__ __module__ __qualname____doc__str__annotations__intc/var/www/html/glpi_dashboard/venv/lib/python3.12/site-packages/snowflake/snowpark/file_operation.pyrrs1O K K K Lr&rc:eZdZUdZeed<eed<eed<eed<y) GetResultz\Represents the results of downloading a file from a stage location to the local file system.filesizerrN)rrr r!r"r#r%r&r'r)r)'sf I I K Lr&r)cPeZdZUdZeed<eed<eeed<eeed<eed<y) ListResultz>Represents the results of listing files from a stage location.namer+md5sha1 last_modifiedN)rrr r!r"r#r$rr%r&r'r-r-0s9H I I      r&r-c$eZdZdZd)dZdeedeeefddfdZdd d d dd d edede de dede deeeefde e fdZ dddddedede deedeeeefde ef dZdd d d ddeedede de dede de fdZdd dddede de deeeefdeef dZddd ddd eed!fd"ed#ee edeed$e deeeefdee ee ffd%Zddd&dedeedeeeefde efd'Zddd&dedeedeeeefde efd(Zy)* FileOperationzwProvides methods for working on files in a stage. To access an object of this class, use :attr:`Session.file`. returnNc||_y)N)_session)selfsessions r'__init__zFileOperation.__init__Cs  r&patternoptionscZ|)t|s|jdd}d|d}||d<yy)z@Helper method to process and add pattern to options if provided.N'z\'r:)rreplace)r7r:r;pattern_escape_single_quotes r'_process_patternzFileOperation._process_patternFs@  #G,.5ooc5.I+9:!<!(GI  r&T AUTO_DETECTF)parallel auto_compressr overwritestatement_paramslocal_file_namestage_locationrCrDrrErFc ||||d}tr] |jjj} | j |||| j } | j } t| | } n|jjjj!dt#|t%||}t&j(j*j-|j|j/|} | Dcgc]}t1di|j3c}S#t$rC} tjd}tj| }|j|dd} ~ wwxYwcc}w)a:Uploads local files to the stage. References: `Snowflake PUT command `_. Example:: >>> # Create a temp stage. >>> _ = session.sql("create or replace temp stage mystage").collect() >>> # Upload a file to a stage. >>> put_result = session.file.put("tests/resources/t*.csv", "@mystage/prefix1") >>> put_result[0].status 'UPLOADED' Args: local_file_name: The path to the local files to upload. To match multiple files in the path, you can specify the wildcard characters ``*`` and ``?``. stage_location: The stage and prefix where you want to upload the files. parallel: Specifies the number of threads to use for uploading files. The upload process separates batches of data files by size: - Small files (< 64 MB compressed or uncompressed) are staged in parallel as individual files. - Larger files are automatically split into chunks, staged concurrently, and reassembled in the target stage. A single thread can upload multiple chunks. Increasing the number of threads can improve performance when uploading large files. Supported values: Any integer value from 1 (no parallelism) to 99 (use 99 threads for uploading files). auto_compress: Specifies whether Snowflake uses gzip to compress files during upload. source_compression: Specifies the method of compression used on already-compressed files that are being staged. Values can be 'AUTO_DETECT', 'GZIP', 'BZ2', 'BROTLI', 'ZSTD', 'DEFLATE', 'RAW_DEFLATE', 'NONE'. overwrite: Specifies whether Snowflake will overwrite an existing file with the same name during upload. statement_params: Dictionary of statement level parameters to be set while executing this action. Returns: A ``list`` of :class:`PutResult` instances, each of which represents the results of an uploaded file. rCrrDrENputrFr%)r r6_conn_cursor_upload descriptionfetchallrr sysexc_infor $SQL_EXCEPTION_FROM_PROGRAMMING_ERRORwith_traceback _analyzer plan_builderfile_operation_planrr snowflakesnowpark dataframe DataFrame_internal_collect_with_tagrasDict)r7rGrHrCrDrrErFr;cursor result_meta result_data put_resultpetbneplan file_results r'rLzFileOperation.putNsSZ!"4*"   " # 6,,44H$00 $oo/ / [I ==**77KK$_5,^< D #++55?? t((:J(K FPPk 1K..01PP!$ 6\\^A&4YY''+5  6 QsAD; E- E*'>E%%E* )rCr:rFtarget_directoryc Rd|i}|j|| tr] |jjj}|j ||||j }|j} t| |} n|jjj!dt#|t%||}t'j(t+|dt,j.j0j3|j|j5|} | Dcgc]}t7di|j9c}S#t$rC} tjd} tj| } | j| dd} ~ wwxYwcc}w#t:$rgcYSwxYw) aD Downloads the specified files from a path in a stage to a local directory. References: `Snowflake GET command `_. Examples: >>> # Create a temp stage. >>> _ = session.sql("create or replace temp stage mystage").collect() >>> # Upload a file to a stage. >>> _ = session.file.put("tests/resources/t*.csv", "@mystage/prefix1") >>> # Download one file from a stage. >>> get_result1 = session.file.get("@myStage/prefix1/test2CSV.csv", "tests/downloaded/target1") >>> assert len(get_result1) == 1 >>> # Download all the files from @myStage/prefix. >>> get_result2 = session.file.get("@myStage/prefix1", "tests/downloaded/target2") >>> assert len(get_result2) > 1 >>> # Download files with names that match a regular expression pattern. >>> get_result3 = session.file.get("@myStage/prefix1", "tests/downloaded/target3", pattern=".*test.*.csv.gz") >>> assert len(get_result3) > 1 Args: stage_location: A directory or filename on a stage, from which you want to download the files. target_directory: The path to the local directory where the files should be downloaded. If ``target_directory`` does not already exist, the method creates the directory. parallel: Specifies the number of threads to use for downloading the files. The granularity unit for downloading is one file. Increasing the number of threads might improve performance when downloading large files. Supported values: Any integer value from 1 (no parallelism) to 99 (use 99 threads for downloading files). pattern: Specifies a regular expression pattern for filtering files to download. The command lists all files in the specified path and applies the regular expression pattern on each of the files found. Default: ``None`` (all files in the specified stage are downloaded). statement_params: Dictionary of statement level parameters to be set while executing this action. Returns: A ``list`` of :class:`GetResult` instances, each of which represents the result of a downloaded file. rCrKNgetT)exist_okrMr%)r@r r6rNrO _downloadrQrRrr rSrTr rUrV _plan_builderrYrrosmakedirsr rZr[r\r]r^r)r_ IndexError)r7rHrjrCr:rFr;r`rarb get_resultrdrerfrgrhs r'rlzFileOperation.gets\x( gw/ %' :!]]0088F$$^5EwO"("4"4K"(//"3K!3K!MJ}}22FF()9:0@  /0@ADQ&//99CCMM4,,>N,OJTT+I5 2 2 45T T'(:*B8]]B++B/T9 :&U I sB FAE>B#F! FF F >F  FF F&%F&)rCrDrrE input_streamc Ht|}|jjj}t r, ||||d}|j ||||j } n?t|\} }|jjj|| |||||}|d} |j}t!| |d}t#di|j%S#t$rC} tjd} tj| } | j| dd} ~ wwxYw)a*Uploads local files to the stage via a file stream. Args: input_stream: The input stream from which the data will be uploaded. stage_location: The full stage path with prefix and file name where you want the file to be uploaded. parallel: Specifies the number of threads to use for uploading files. The upload process separates batches of data files by size: - Small files (< 64 MB compressed or uncompressed) are staged in parallel as individual files. - Larger files are automatically split into chunks, staged concurrently, and reassembled in the target stage. A single thread can upload multiple chunks. Increasing the number of threads can improve performance when uploading large files. Supported values: Any integer value from 1 (no parallelism) to 99 (use 99 threads for uploading files). Defaults to 4. auto_compress: Specifies whether Snowflake uses gzip to compress files during upload. Defaults to True. source_compression: Specifies the method of compression used on already-compressed files that are being staged. Values can be 'AUTO_DETECT', 'GZIP', 'BZ2', 'BROTLI', 'ZSTD', 'DEFLATE', 'RAW_DEFLATE', 'NONE'. Defaults to "AUTO_DETECT". overwrite: Specifies whether Snowflake will overwrite an existing file with the same name during upload. Defaults to False. Returns: An object of :class:`PutResult` which represents the results of an uploaded file. rJrKN)rtrH dest_filenamerC compress_datarrEdatarr%)rr6rNrOr _upload_streamrRr rSrTr rUrVr upload_streamrQrrr_)r7rtrHrCrDrrEr`r;rbrdrerfstage_with_prefixrvrcras r' put_streamzFileOperation.put_streams0>1@$$,, ! # 6 (*<%2!*  %%lNGL$oo/ 0:./I , },,::)0+!+#5#;J%V,K(( ' [A!D /:,,.//+$ 6\\^A&4YY''+5  6s*C D!>DD!)rC decompressrFr}ct|}tr1 |jjjj ||Sd|i}tj} t|d} tj j#| | } |jj$j'dt)| t+||} t,j.j0j3|j| j5||rt;j<| dSt=| dS#t $rC}tjd}tj|}|j|dd}~wwxYw#t6$rC} tjd}tj8| }|j|dd} ~ wwxYw) aDownloads the specified files from a path in a stage and expose it through a stream. Args: stage_location: The full stage path with prefix and file name, from which you want to download the file. parallel: Specifies the number of threads to use for downloading the files. The granularity unit for downloading is one file. Increasing the number of threads might improve performance when downloading large files. Supported values: Any integer value from 1 (no parallelism) to 99 (use 99 threads for downloading files). Defaults to 10. statement_params: Dictionary of statement level parameters to be set while executing this action. Defaults to None. decompress: Specifies whether to use gzip to decompress file after download. Defaults to False. Examples: >>> # Create a temp stage. >>> _ = session.sql("create or replace temp stage mystage").collect() >>> # Upload a file to a stage. >>> _ = session.file.put("tests/resources/testCSV.csv", "@mystage/prefix1") >>> # Download one file from a stage. >>> fd = session.file.get_stream("@myStage/prefix1/testCSV.csv.gz", decompress=True) >>> assert fd.read(5) == b"1,one" >>> fd.close() Returns: An ``BytesIO`` object which points to the downloaded file. rKNrCrl)r;rMrb)rr r6rNrO_download_streamr rSrTr rUrVtempfile gettempdirrrppathjoinrorYrrrZr[r\r]r^r $SQL_EXCEPTION_FROM_OPERATIONAL_ERRORgzipopen)r7rHrCr}rFrdrerfr;tmp_dir src_file_namerGrgoes r' get_streamzFileOperation.get_stream+sD1@ ! # 6}}**22CC"J"8,G))+G&~6q9M ggll7MBO==..BB$W-,^< CD 6"",,66MM4,,>N,O /40 /40 9$ 6\\^A&4YY''+5  6*$ 6\\^A&4YY''+5  6s0/D1 AF1 E=:>E88E= G  >GG )filesr:detailed_outputrFrz&snowflake.snowpark.dataframe.DataFrametarget_stage_locationrrcd|i}|||d<|j||t|tjjj r|| t dt|tr t|n4d|jjdjjd}|jjjj!d|t||}tjjj |j|j#|} |r| D cgc]} | d  c} S| d d Scc} w) u Copy files from a source location to an output stage. You can use either a stage location (``str``) or a DataFrame as the source: - DataFrame source: The DataFrame must have exactly one or two columns of string type. Column names are not significant; Snowflake interprets columns by position: - First column (required): The existing url of the source file location (scoped URL, stage name, or stage URL). - Second column (optional): Then new file name which is the relative output path from the ``target`` stage. The file is copied to ``@[.][/]``. If the second column is not provided, Snowflake uses the relative path of the first column's value. Invalid input (for example, missing the first column, non-string values, or extra columns) is rejected by Snowflake and results in a server-side error. - Stage location source: Provide a stage location string for ``source``. You can optionally use ``files`` or ``pattern`` to restrict which files are copied. References: `Snowflake COPY FILES command `_. Args: source: The source to copy from. Either a stage location string, or a DataFrame with 1–2 string columns where the first column is required (existing url) and the second column is optional (new file name). target: The target stage and path where files will be copied. files: Optional list of specific file names to copy; only applicable when ``source`` is a stage location string. pattern: Optional regular expression pattern for filtering files to copy; only applicable when ``source`` is a stage location string. detailed_output: If True, returns details for each file; if False, returns only the number of files copied. Defaults to True. statement_params: Dictionary of statement level parameters to be set while executing this action. Examples: >>> # Create a temp stage. >>> _ = session.sql("create or replace temp stage source_stage").collect() >>> _ = session.sql("create or replace temp stage target_stage").collect() >>> # Upload a file to a stage. >>> _ = session.file.put("tests/resources/testCSV.csv", "@source_stage", auto_compress=False) >>> # Copy files from source stage to target stage. >>> session.file.copy_files("@source_stage", "@target_stage") ['testCSV.csv'] >>> # Copy files from source stage to target stage using a DataFrame. >>> df = session.create_dataframe( ... [["@source_stage/testCSV.csv", "new_file_1"]], ... schema=["existing_url", "new_file_name"], ... ) >>> session.file.copy_files(df, "@target_stage", detailed_output=False) 1 Returns: If ``detailed_output`` is True, a ``list[str]`` of copied file paths. Otherwise, an ``int`` indicating the number of files copied. rrz>files and pattern are not supported when source is a dataframe() copy_filesrMr)r@ isinstancerZr[r\r] ValueErrorr"r_planqueriessqlstripr6rWrXrYr^) r7rrrr:rrFr;rg copy_resultrhs r'rzFileOperation.copy_filesusJ@%o6  $GG  gw/ fi00::DD E G$7 T &#& ) 0V\\))"-11779:!<  }}&&33GG   ()> ?     ((22<< MM4 $ $6F $ G  6AB{KNB Bq>!$ $Cs0 E)r:rFcXi}|j|||jjjj ddt ||}t jjj|j|j|}|Dcgc]}|d c}Scc}w)alRemoves files from a stage. References: `Snowflake REMOVE command `_. Example:: >>> # Create a temp stage and upload files. >>> _ = session.sql("create or replace temp stage mystage").collect() >>> _ = session.file.put("tests/resources/testCSV.csv", "@mystage/prefix1") >>> _ = session.file.put("tests/resources/testCSV.csv", "@mystage/prefix2") >>> # Remove all files from the stage. >>> session.file.remove("@mystage/prefix1") ['mystage/prefix1/testCSV.csv.gz'] >>> # Remove files matching a pattern. >>> session.file.remove("@mystage/prefix2", pattern=".*test.*") ['mystage/prefix2/testCSV.csv.gz'] Args: stage_location: The stage and path where you want to remove files. pattern: Specifies a regular expression pattern for filtering files to remove. The command lists all files in the specified path and applies the regular expression pattern on each of the files found. Default: ``None`` (all files in the specified stage path are removed). statement_params: Dictionary of statement level parameters to be set while executing this action. Returns: A ``list`` of removed file paths. removeNrMr) r@r6rWrXrYrrZr[r\r]r^)r7rHr:rFr;rg remove_resultrhs r'rzFileOperation.removesD gw/}}&&33GG   ( 8    "**44>> MM4 $ $6F $ G 3@@; A@@@s B'ci}|j|||jjjj ddt ||}t jjj|j|j|}g}|D]V}|j} | jdd| d<| jdd| d<|jtdi| X|S)azReturns a list of files from a stage. References: `Snowflake LIST command `_. Example:: >>> # Create a temp stage and upload files. >>> _ = session.sql("create or replace temp stage mystage").collect() >>> _ = session.file.put("tests/resources/t*.csv", "@mystage/prefix1") >>> # List all files in the stage. >>> list_result = session.file.list("@mystage/prefix1") >>> assert len(list_result) > 0 >>> # List files matching a pattern. >>> filtered_result = session.file.list("@mystage/prefix1", pattern=".*test.*") >>> assert len(filtered_result) > 0 Args: stage_location: The stage and path from which you want to list files. pattern: Specifies a regular expression pattern for filtering files from the output. The command lists all files in the specified path and applies the regular expression pattern on each of the files found. Default: ``None`` (all files in the specified stage path are listed). statement_params: Dictionary of statement level parameters to be set while executing this action. Returns: A ``list`` of :class:`ListResult` instances, each of which represents the metadata of a file in the stage. listNrMr/r0r%)r@r6rWrXrYrrZr[r\r]r^r_rlappendr-) r7rHr:rFr;rg list_resultresultsrhrxs r'rzFileOperation.listsB gw/}}&&33GG   ( 8     ((22<< MM4 $ $6F $ G & /K%%'D((tDK 88FD1DL NN:-- .  /r&)r8z"snowflake.snowpark.session.Sessionr4N)rrr r!r9rr"rr@r$boolrrrLr)rlrbytesr|rrrrr-rr%r&r'r3r3>s ) )S#X)SW)""/59IQIQIQ  IQ  IQ IQIQ#4S>2IQ iIQ`!%59NNN  N # N#4S>2N iNj""/@0i@0@0  @0  @0 @0@0 @0L 59 HH H  H #4S>2 H EH^&*!% $59`%cCCD`% #`% S " `% # `%`%#4S>2`% tCy#~ `%L"&59 /A/A# /A #4S>2 /A c /Aj"&59 66# 6 #4S>2 6 j  6r&r3)rrprSrtypingrrrrrrsnowflake.snowparkrZsnowflake.connectorr r *snowflake.snowpark._internal.error_messager "snowflake.snowpark._internal.utilsr r rrrrrrrr)r-r3r%r&r'rsa  >>BV        @@r&