ɯei8qUddlZddlZddlZddlZddlZddlZddlZddlZddlZddl Z ddl m Z ddl m Z ddl mZddlmZddlmZddlmZddlmZmZmZmZmZmZmZmZmZmZm Z m!Z!ddl"Z"ddl#Z$dd l%m&Z&dd l'm(Z)ddl*m+cm,cm-cm.cm/Z-ddl0m+cm1Z1dd l2m3Z3m4Z4dd l5m6Z6m7Z7m8Z8dd l9m:Z:ddl;mZ>ddl?m@Z@ddlAmBZBmCZCddlDmEZEddlFmGZGddlHmIZImJZJmKZKddlLmMZMddlNmOZOmPZPddlQmRZRmSZSmTZTddlUmVZVddlWmXZXddlYmZZZm[Z[m\Z\m]Z]m^Z^m_Z_ddl`maZaddlbmcZcddldmeZemfZfmgZgmhZhmiZimjZjmkZkmlZlmmZmmnZnmoZompZpddlqmrZrddlsmtZtdd lumvZvdd!lwmxZxmyZymzZzm{Z{m|Z|m}Z}dd"l~mZdd#lmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZdd$lmZmZdd%lmZdd&l0mZmZdd'lmZdd(lmZdd)lmZmZdd*lmZdd+lmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZdd,lmZdd-lmZdd.lmZdd/lmZdd0lmZdd1lmZmZdd2lmZdd3lmZdd4lmZdd5lmZdd6lmZdd7lmZmZdd8lmZdd9lmZdd:lmZdd;lmZddlmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZdd?l m Z dd@l m Z ddAl mZerddlZddBl mZej$dCkr ddDlmZn ddDlmZeeZeZeZedEedF<dGZdHZdIZdJZdKZdLZ dMZ!dNZ"dOZ#dPZ$dQZ%dRZ&dSZ'dTZ(dUZ)dVZ*dWZ+dXZ,dYZ-dZZ.d[Z/d\Z0d]Z1d^Z2d_Z3erd`ndZ4e5eda<erd`ndZ6e5edb<djddZ7dcedEfdeZ8dkdfZ9dldgZ:dkdhZ;GdidEZPYTHON_SNOWPARK_USE_LARGE_QUERY_BREAKDOWN_OPTIMIZATION_VERSIONct5ttdk\rtcdddStj#1swYyxYwr)rrrr5rrrr_get_active_sessionsrOsH !N  A %$ NN 2KKM M NNs ==Acdt5tj|dddy#1swYyxYwN)rraddsessions r _add_sessionrYs( !&W%&&&s&/c6trd}|S|xs t}|Sr)rzrrs r'_get_sandbox_conditional_active_sessionr^s&5 N202 Nrct5 tj|dddy#t$rYwxYw#1swYyxYwr)rrremoveKeyErrorrs r_remove_sessionrgsF !   # #G ,   s6' 3636?c&ZeZdZUdZGddZGddZeZeed< ddee e e fd e e eefd dfd Zdd Zd ZdZdZdZdZded efdZd efdZed efdZed e dfdZeZ ee!ddZ"ddZ#ed efdZ$ed efdZ%ed efdZ&e&jNe(dded dfd Z&ed efd!Z)ed efd"Z*ed efd#Z+ed efd$Z,ed e-eeffd%Z.ed efd&Z/ed efd'Z0ed efd(Z1ed e fd)Z2e%jNded dfd*Z%e)jNded dfd+Z)e*jNe(d,ded dfd-Z*e+jNe(d.ded dfd/Z+e,jNe(d0ded dfd1Z,e.jNde-eefd dfd2Z.e/jNe(d3ded dfd4Z/e0jNded dfd5Z0e1jNded dfd6Z1e2jNe(d7d8e d dfd9Z2dd:Z3d e4efd;Z5 dd=ed>e ed?ed@ed df dAZ6d=ed dfdBZ7ddCZ8e9 dd=ed>e ed?ed@ed e-ee ee eff dDZ: dddEdFedGedHe e ee-e ee effdIe e eefd e4ef dJZ; dddEdKe edIe e eefd eddOdPeee?e@eee?ffdMe ed dfdQZA ddRedMe ed dfdSZB ddMe ed dfdTZC ddUedMe ed dfdVZDe!dW ddXe`_ to connect to Snowflake. Refer to `Connecting to Snowflake using the Python Connector `_ for the details of `Connection Parameters `_. To create a :class:`Session` object from a ``dict`` of connection parameters:: >>> connection_parameters = { ... "user": "", ... "password": "", ... "account": "", ... "role": "", ... "warehouse": "", ... "database": "", ... "schema": "", ... } >>> session = Session.builder.configs(connection_parameters).create() # doctest: +SKIP To create a :class:`Session` object from an existing Python Connector connection:: >>> session = Session.builder.configs({"connection": }).create() # doctest: +SKIP :class:`Session` contains functions to construct a :class:`DataFrame` like :meth:`table`, :meth:`sql` and :attr:`read`, etc. c`eZdZdddeeefddfdZd dedefdZdedefd Z ded eddfd Z y) Session.RuntimeConfigrrconfrNc||_ddddd|_|jj|_|jD])\}}|j |s|j ||+y)NTF)use_constant_subquery_alias'flatten_select_after_filter_and_orderbycollect_stacktrace_in_query_taguse_simplified_query_generation)_session_conf_lockitems is_mutableset)selfrrkeyvals r__init__zSession.RuntimeConfig.__init__sd#DM/3;?3838 DJ ,,DJ JJL 'S??3'HHS#& 'rr c|j5tt|rt|j|cdddSt|jj j |r3t|jj j |cdddS|j j||cdddS#1swYyxYwr)rhasattrrgetattrr_connrget)r r defaults rrzSession.RuntimeConfig.gets 47C("4==#6 4 44==..44c:"4==#6#6#<#|jj|d|S)zOnly used in test.N)r&poprs r_remove_configz%Session.SessionBuilder._remove_configs MM  c4 (Krapp_name format_jsonc"||_||_|S)a Adds the app name to the :class:`SessionBuilder` to set in the query_tag after session creation Args: app_name: The name of the application. format_json: If set to `True`, it will add the app name to the session query tag in JSON format, otherwise, it will add it using a key=value format. Returns: A :class:`SessionBuilder` instance. Example:: >>> session = Session.builder.app_name("my_app").configs(db_parameters).create() # doctest: +SKIP >>> print(session.query_tag) # doctest: +SKIP APPNAME=my_app >>> session = Session.builder.app_name("my_app", format_json=True).configs(db_parameters).create() # doctest: +SKIP >>> print(session.query_tag) # doctest: +SKIP {"APPNAME": "my_app"} )r'r()r r-r.s rr-zSession.SessionBuilder.app_names,&DN +D Krrc$||j|<|S)zo Adds the specified connection parameter to the :class:`SessionBuilder` configuration. r&rs rconfigzSession.SessionBuilder.configs"'DMM# Kroptionsc0i|j||_|S)a3 Adds the specified :class:`dict` of connection parameters to the :class:`SessionBuilder` configuration. Note: Calling this method overwrites any existing connection parameters that you have already set in the SessionBuilder. r1)r r3s rconfigszSession.SessionBuilder.configss9t}}88DMKrrc|jjddrRtt|j|j}d|jvrd|jd<t |n|jjddrRtt |j|j}d|jvrd|jd<t |n*|j |jjd}|jrM|jr!d|ji}|j||Sd|j}|j||S) zCreates a new Session. local_testingFpasswordN nop_testing connectionAPPNAMEzAPPNAME=) r&rrrrr_create_internalr'r(update_query_tagappend_query_tag)r r app_name_tags rcreatezSession.SessionBuilder.creates}}  %8!"6t}}"Et}}U.04DMM*-W%""=%8!- "> N.04DMM*-W%// 0A0A,0OP~~$$$-t~~#>L,,\: N&.dnn-=#>L,,\:Nrc t}|jjjrt||j S|S#t $r*}|j dk(r|j cYd}~Sd}~wwxYw)z=Gets the last created session or creates a new one if needed.1403N)rrexpiredrr@r error_code)r rexs r getOrCreatez"Session.SessionBuilder.getOrCreatesf -/==&&..#G,;;=(* ==F*;;=( s*AA A A<A70A<6A77A<conncRts |s|jsddlm}||_d|jvrd|jd<t |r t i|nt |j|j}d|jvrd|jd<t ||S)Nr)_get_default_connection_params paramstyleqmarkr8)rcr&"snowflake.connector.config_managerrIrrCr)r rGrI new_sessions rr<z'Session.SessionBuilder._create_internal%s *+D!? @ 4==0.5 l+!.2 T*8H8W K T]]*,0 j)  % rc*tjSr)rSessionBuilder)r objobjtypes r__get__zSession.SessionBuilder.__get__As))+ +rrNFrrr)rrr__doc__r r r,r!r-rintr2r r5r@rFrrr<appNamerRrrrrOr$s  %  c .F  6;  .2  % 4 c %S/ >V  U38_ 45  %  2 37 ./  4 ,rrObuilderNrGr3rc ttdk\r0tr&|jddst j ||_d|_i|_i|_ tt|_ |j j|_dtdt!dt#d|jdt%d |_t|_d|_t-|t.rAt1||_t5||_t9||_t=||_n@tA||_tC||_tE||_tG||_t-|j tHr tK|n tM||_'d |_(d |_)tTxr |j jtVd |_*|j jtXd|_-t]||_/ta||_1|j jtdd |_3|jitj|_6|j jtnd |_8|j jtrd|_:|jitv|_<|j jtzd|_>|j jt~d|_@|j jtd|_B|jr|jn|j|j jtd|_F|jit|_H|j jtd}|!t-|trt||_Lnd|_L|jL|j jtt}|rtjntj|_Lnd|jtjk(r*tjd tj|_L|jtjk(}|jtjk7rd|j jtd C|jit}|s,tjd tj|_Ld}ttj||j jtt|j jttf|_\|jit|_^|j jtd|_`dtjvr: d dlcmd}|j jtd}||j|t|j j|_jt|j j|_lt|j j|_mt|j j|_nt|j j|_oi|_pi|_q|jit|_s|j||xsi|_ud|_vt||_xt||_zt||_|t||_~d|_t||_t||_tj d|j&t j |jy#t$rYwxYw)Nr%ENABLE_CREATE_SESSION_IN_STORED_PROCSFz "version" : z, "python.version" : z, "python.connector.version" : z", "python.connector.session.id" : z, "os.name" :  rTzWSnowpark python client does not support dataframe requests, downgrading to SQL_AND_AST.zNServer side dataframe support requires minimum snowpark-python client version.modinAutoSwitchBackendrz Snowpark Session information: %s)rrrc"_get_client_side_session_parameterr5DONT_CREATE_SESSION_IN_SPr _query_tag _import_paths _packagesrdict_artifact_repository_packagesget_session_id _session_idrar^r\r] _session_infoversion_session_stagerrr_udf_registrationr_udtf_registrationr_udaf_registrationr_sp_registrationrrrrrCr'r _plan_builder_last_action_id_last_canceled_idr{/_PYTHON_SNOWPARK_USE_SCOPED_TEMP_OBJECTS_STRING3_PYTHON_SNOWPARK_ENABLE_SCOPED_TEMP_READ_ONLY_TABLE _use_scoped_temp_read_only_tabler_filer_lineage*_PYTHON_SNOWPARK_USE_SQL_SIMPLIFIER_STRING_sql_simplifier_enabledis_feature_enabled_for_version-_PYTHON_SNOWPARK_USE_CTE_OPTIMIZATION_VERSION_cte_optimization_enabled=_PYTHON_SNOWPARK_USE_LOGICAL_TYPE_FOR_CREATE_DATAFRAME_STRING_use_logical_type_for_create_df9_PYTHON_SNOWPARK_ELIMINATE_NUMERIC_SQL_VALUE_CAST_ENABLED)_eliminate_numeric_sql_value_cast_enabled9_PYTHON_SNOWPARK_AUTO_CLEAN_UP_TEMP_TABLE_ENABLED_VERSION!_auto_clean_up_temp_table_enabled._PYTHON_SNOWPARK_REDUCE_DESCRIBE_QUERY_ENABLED_reduce_describe_query_enabled/_PYTHON_SNOWPARK_ENABLE_QUERY_COMPILATION_STAGE _query_compilation_stage_enabled+_PYTHON_SNOWPARK_GENERATE_MULTILINE_QUERIES_generate_multiline_queries_enable_multiline_queries_disable_multiline_queries+_PYTHON_SNOWPARK_INTERNAL_TELEMETRY_ENABLED_internal_telemetry_enabled?_PYTHON_SNOWPARK_USE_LARGE_QUERY_BREAKDOWN_OPTIMIZATION_VERSION_large_query_breakdown_enabled _PYTHON_SNOWPARK_CLIENT_AST_MODErWru _ast_mode_PYTHON_SNOWPARK_USE_AST&_PYTHON_SNOWPARK_USE_AST_DEFAULT_VALUE SQL_AND_ASTSQL_ONLYAST_ONLY_loggerrp+_PYTHON_SNOWPARK_CLIENT_MIN_VERSION_FOR_ASTrrrtSERVER=_PYTHON_SNOWPARK_LARGE_QUERY_BREAKDOWN_COMPLEXITY_LOWER_BOUND$DEFAULT_COMPLEXITY_SCORE_LOWER_BOUND=_PYTHON_SNOWPARK_LARGE_QUERY_BREAKDOWN_COMPLEXITY_UPPER_BOUND$DEFAULT_COMPLEXITY_SCORE_UPPER_BOUND(_large_query_breakdown_complexity_bounds1_PYTHON_SNOWPARK_DATAFRAME_JOIN_ALIAS_FIX_VERSION_join_alias_fix3_SNOWPARK_PANDAS_DUMMY_ROW_POS_OPTIMIZATION_ENABLED#_dummy_row_pos_optimization_enabledsysmodules modin.configr_)_SNOWPARK_PANDAS_HYBRID_EXECUTION_ENABLEDput ExceptionrW_thread_safe_session_enabled _thread_storerVr _package_lock _plan_lock_xpath_udf_cache_lock_custom_package_usage_config_xpath_udf_cache;_PYTHON_SNOWPARK_COLLECT_TELEMETRY_AT_CRITICAL_PATH_VERSION2_collect_snowflake_plan_telemetry_at_critical_pathr"r!_runtime_version_from_requirementrE_temp_table_auto_cleanerr _sp_profilerr _udf_profilerr_dataframe_profiler_catalogr6_client_telemetryr. _ast_batchinfoatexitregister_close_at_exit)r rGr3ast_mode_value ast_enabledast_supported_versionr_pandas_hybrid_execution_enableds rr zSession.__init__Hs  !Q &&(;;72KKM M MO)+   * ::446" ]O&()*3567!!%!1!1 23 ]O #} " d0 1%8%>D "&:4&@D #&:4&@D #$CD$ID !%4T%:D "$?$ED !&6t&  + JJ 9 9?  - JJ 9 9;U  (  + +  * * ,  + + - JJ 9 9;U  ( 594W4W K5 +#jjKK ,d   %*^S*I$^4DN!DN >> ! $ M M(*P!K5@W00WEUEUDN~~!1!11m")!4!4..G,?,??K >>W-- - ==? /3.Q.Q?/%-OOh&-%5%5DN"'Km**K8 JJ 9 9M4  JJ 9 9M4  J 5&*%H%H =&  JJ 9 9CU  0 ckk ! :JJAA=t03>%))*IJ 1 JJ 3 3 "$**"I"IJ *$***Q*QR'tzz'N'NO&2 JJ 3 3& "35)13  / /K  ? ''gm< 6:.>RSW>X%3DA(6#4T#B  !4T!B"4. 79K9KL ++,a  s-9_ _"!_"ct5 |jj|jdddy#t$rYwxYw#1swYyxYw)a This is the helper function to close the current session at interpreter shutdown. For example, when a jupyter notebook is shutting down, this will also close the current session and make sure send all telemetry to the server. N)rr_opentelemetry_shutdowncloserr)s rrzSession._close_at_exit:sU &  &&>>@        s&A *< AA AA  Ac|Srrr)s r __enter__zSession.__enter__Gs rc:ts|jyyr)rcr)r exc_typeexc_valexc_tbs r__exit__zSession.__exit__Js%' JJL(rcd|jjd|jjd|jd|j d|j d|j d|jdS) N<.z : account=z, role=z , database=z , schema=z , warehouse=>) __class__rrget_current_accountget_current_roleget_current_databaseget_current_schemaget_current_warehouser)s r__str__zSession.__str__Ns))*!DNN,C,C+DJtOgOgOiNjk))+,K8Q8Q8S7TU--/0 T=W=W=Y*2D   '!!***rcf tS#t$r}|jdk(rYd}~y|d}~wwxYw)zRGets the active session if one is created. If no session is created, returns None.rBN)rrrD)clsrEs rget_active_sessionzSession.get_active_sessions4 &( (& }}&H  s 0++0z1.27.0)rjcddlm}|jHt|jt r!|jj dt|||_|jS)z`_ to get the schema from the Snowflake server. This optimization improves the performance of your workloads by reducing the number of describe queries issued to the server. The default value is ``False``. )rr)s rreduce_describe_query_enabledz%Session.reduce_describe_query_enabled s222rc|jS)zSet to ``True`` to enable the dummy row position optimization (defaults to ``True``). The generated SQLs from pandas transformations would potentially have fewer expensive window functions to compute the row position column. )rr)s r"dummy_row_pos_optimization_enabledz*Session.dummy_row_pos_optimization_enableds 777rctjjds tdddlm}|j S)aLSet to ``True`` to enable hybrid execution mode (has the same default as AutoSwitchBackend). When enabled, certain operations on smaller data will automatically execute in native pandas in-memory. This can significantly improve performance for operations that are more efficient in pandas than in Snowflake. r]PThe 'modin' package is required to enable this feature. Please install it first.rr^) importlibutil find_spec ImportErrorrr_r)r r_s rrz'Session.pandas_hybrid_execution_enableds= ~~''0b  3 "&&((rc|jS)a Get or set configuration parameters related to usage of custom Python packages in Snowflake. If enabled, pure Python packages that are not available in Snowflake will be installed locally via pip and made available as an import (see :func:`add_import` for more information on imports). You can speed up this process by mentioning a remote stage path as ``cache_path`` where unsupported pure Python packages will be persisted. To use a specific version of pip, you can set the environment variable ``PIP_PATH`` to point to your pip executable. To use custom Python packages which are not purely Python, specify the ``force_push`` configuration parameter (*note that using non-pure Python packages is not recommended!*). This feature is **experimental**, please do not use it in production! Configurations: - **enabled** (*bool*): Turn on usage of custom pure Python packages. - **force_push** (*bool*): Use Python packages regardless of whether the packages are pure Python or not. - **cache_path** (*str*): Cache custom Python packages on a stage directory. This parameter greatly reduces latency of custom package import. - **force_cache** (*bool*): Use this parameter if you specified a ``cache_path`` but wish to create a fresh cache of your environment. Args: config (dict): Dictionary containing configuration parameters mentioned above (defaults to empty dictionary). Example:: >>> from snowflake.snowpark.functions import udf >>> session.custom_package_usage_config = {"enabled": True, "cache_path": "@my_permanent_stage/folder"} # doctest: +SKIP >>> session.add_packages("package_unavailable_in_snowflake") # doctest: +SKIP >>> @udf ... def use_my_custom_package() -> str: ... import package_unavailable_in_snowflake ... return "works" >>> session.clear_packages() >>> session.clear_imports() Note: - These configurations allow custom package addition via :func:`Session.add_requirements` and :func:`Session.add_packages`. - These configurations also allow custom package addition for all UDFs or stored procedures created later in the current session. If you only want to add custom packages for a specific UDF, you can use ``packages`` argument in :func:`functions.udf` or :meth:`session.udf.register() `. )rr)s rcustom_package_usage_configz#Session.custom_package_usage_config-sL000rcHtd|j5|jjj |j | |jj jdtd|||_ dddy#t$rYwxYw#1swYyxYw)Nrzalter session set z = ) rorr_telemetry_clientsend_sql_simplifier_telemetryrh_cursorexecuterxrryrs rrzSession.sql_simplifier_enabledUs89QR ZZ 1 JJ ( ( F F  %   ""**()S(TTWX]W^_ ,1D ( 1 1   1 1s/1B /B 9B BBBBB!ctd|j5|r/|jjj |j ||_dddy#1swYyxYw)Nr)rorrrsend_cte_optimization_telemetryrhr|rs rrz Session.cte_optimization_enabledesU89ST ZZ 3 ,,LL$$.3D *  3 3 3s 9AA#z1.20.0ctd|dvrM|j5|jjj |j |||_dddytd#1swYyxYw)z:Set the value for eliminate_numeric_sql_value_cast_enabledrTFNzIvalue for eliminate_numeric_sql_value_cast_enabled must be True or False!)rorrr/send_eliminate_numeric_sql_value_cast_telemetryrhr ValueErrorrs rrz0Session.eliminate_numeric_sql_value_cast_enabledps 9 6  M ! G ,,\\$$eBG>  G G [   G G 8A((A1z1.21.0ctd|dvrM|j5|jjj |j |||_dddytd#1swYyxYw)z2Set the value for auto_clean_up_temp_table_enabledrr NzAvalue for auto_clean_up_temp_table_enabled must be True or False!)rorrr'send_auto_clean_up_temp_table_telemetryrhrr"rs rrz(Session.auto_clean_up_temp_table_enabledsy 9 .  M ! ? ,,TT$$e:?6  ? ? S   ? ?r#z1.22.0ctd|dvrM|j5|jjj |j |||_dddytd#1swYyxYw)a*Set the value for large_query_breakdown_enabled. When enabled, the client will automatically detect large query plans and break them down into smaller partitions, materialize the partitions, and then combine them to execute the query to improve overall performance. r r Nz>value for large_query_breakdown_enabled must be True or False!)rorrr$send_large_query_breakdown_telemetryrhrr"rs rr z%Session.large_query_breakdown_enabledsy 9 +  M ! < ,,QQ$$e7<3  < < P   < value for reduce_describe_query_enabled must be True or False!N)rr$send_reduce_describe_query_telemetryrhrr"rs rr z%Session.reduce_describe_query_enabledsI M ! JJ ( ( M M  % 38D /P rc0|dvr||_ytd)z4Set the value for dummy_row_pos_optimization_enabledr zCvalue for dummy_row_pos_optimization_enabled must be True or False!N)rr"rs rrz*Session.dummy_row_pos_optimization_enableds$ M !7>> from snowflake.snowpark.types import IntegerType >>> from resources.test_udf_dir.test_udf_file import mod5 >>> session.add_import("tests/resources/test_udf_dir/test_udf_file.py", import_path="resources.test_udf_dir.test_udf_file") >>> mod5_and_plus1_udf = session.udf.register( ... lambda x: mod5(x) + 1, ... return_type=IntegerType(), ... input_types=[IntegerType()] ... ) >>> session.range(1, 8, 2).select(mod5_and_plus1_udf("id")).to_df("col1").collect() [Row(COL1=2), Row(COL1=4), Row(COL1=1), Row(COL1=3)] >>> session.clear_imports() Note: 1. In favor of the lazy execution, the file will not be uploaded to the stage immediately, and it will be uploaded when a UDF is created. 2. The Snowpark library calculates a sha256 checksum for every file/directory. Each file is uploaded to a subdirectory named after the checksum for the file in the stage. If there is an existing file or directory, the Snowpark library will compare their checksums to determine whether it should be re-uploaded. Therefore, after uploading a local file to the stage, if the user makes some changes to this file and intends to upload it again, just call this function with the file path again, the existing file in the stage will be overwritten by the re-uploaded file. 3. Adding two files with the same file name is not allowed, because UDFs can't be created with two imports with the same name. 4. This method will register the file for all UDFs created later in the current session. If you only want to import a file for a specific UDF, you can use ``imports`` argument in :func:`functions.udf` or :meth:`session.udf.register() `. )r;N) rrrudf _import_filesproc_resolve_import_pathrrc)r r:r;r<r=checksum leading_paths r add_importzSession.add_import sP djj"6 7 HH ! !$K ! @ JJ # #Dk # B'+'@'@ +z?( $h ZZ @(0,'?D  t $ @ @ @s 9BBcB|j}|jtstjj |n|}|j 5||jvrt|d|jj| dddy#1swYyxYw)a\ Removes a file in stage or local file from the imports of a user-defined function (UDF). Args: path: a path pointing to a local file or a remote file in the stage Examples:: >>> session.clear_imports() >>> len(session.get_imports()) 0 >>> session.add_import("tests/resources/test_udf_dir/test_udf_file.py") >>> len(session.get_imports()) 1 >>> session.remove_import("tests/resources/test_udf_dir/test_udf_file.py") >>> len(session.get_imports()) 0 z% is not found in the existing importsN) strip startswithrNosr:abspathrrcrr+)r r: trimmed_pathabs_paths r remove_importzSession.remove_import[s&zz|  **<8 GGOOL )  ZZ 1t111(+PQRR""&&x0  1 1 1s 8BBct|jtr4|jj |j j |j 5|jjdddy#1swYyxYw)zo Clears all files in a stage or local files from the imports of a user-defined function (UDF). N) rrrr?_clear_session_importsrArrcrr)s r clear_importszSession.clear_importszsa djj"6 7 HH + + - JJ - - / ZZ '    $ $ & ' ' 's A??Bc|j}|r|jnd}|jtstjj |st |dtjj|s-tjj|std|tjj|}|tjj|r+|jdtjj}n`tjj|r?|jdr.|jdtjjd}nd}|r2|j|r|dt| }ntd|d|d}nd}|t|||||fS|ddfS)Nz is not foundzSadd_import() only accepts a local file or directory, or a file in a stage, but got r.pyz import_path z, is invalid because it's not a part of path )additional_infor<r=)rGrHrNrIr:existsFileNotFoundErrorisfileisdirr"rJreplacesependswithrrT) r:r;r<r=rKtrimmed_import_pathrLimport_file_pathrDs rrBzSession._resolve_import_pathszz| 5@k//1d&&|477>>,/'<. (FGG77>>,/ 9 !55ANDww|4H #.77==*':'B'B3 'T$WW^^H-(2C2CE2J.66sBGGKKHIM%(,$#(()9:'/0H37G3H2H'I (*+>*?@??GjJ $(L# "$0)$3     t+ +rstatement_paramsimport_only_stageupload_and_import_stageudf_level_import_pathsr^c@g}|j||}t|}t|}|j5|xs|jj } ddd j D]\} \} } | j tr|j| 1tjj| s| jdr"tjj| dntjj| } | d| }||vr;tj| d|d|jt!|d|tjj| s| jdr;t#| | 5}|j$j'||| | dd d d d | dddn!|j$j)| || d d d |jt!|d||S#1swYxYw#1swY:xYw) zAResolve the imports and upload local files (if any) to the stage.r]NrR.zip/z exists on z , skippedDEFLATEFT) input_streamstage_location dest_filename dest_prefixsource_compression compress_data overwrite is_in_udfskip_upload_on_content_matchr^)r:rgrirkrlrn)_list_files_in_stagermrrccopyrrHrNappendrIr:rWrZbasenamerrrerqr upload_stream upload_file)r r_r`rar^resolved_stage_filesstage_file_listnormalized_import_only_location%normalized_upload_and_import_location import_pathsr:prefixrDfilenamefilename_with_prefixrfs r_resolve_importszSession._resolve_importssL "33 0@4 +M + '1S #1 -ZZ O1NT5G5G5L5L5NL O,8,>,>,@4  (D(6<|,$++D1ww}}T*dmmE.Bww''-.d3))$/ +18*'=$'?:MM#*K0O/PPYZ)//4>?qAU@VWww}}T*dmmE.B< ,) JJ44-9/T.6,23<.3*.*.=A1A5 " ..!%+P(.*/&*9= /)//4DEQG[F\]a4 l$#q O O2sH&HHH rgct|r t|n |j}|jd|dj ddj |}t |}|Dchc]}t|d|dc}Scc}w)Nzls F _emit_astz"name"r]r)rerlrksqlselect_internal_collect_with_tagr_r )r rgr^ normalized file_list prefix_lengthrows rrozSession._list_files_in_stages 2  /$$ HHs:,'5H 9 VHV . ' '9I ' J  5^D 7@ACF MN+AAAs)Bartifact_repositoryc|j5|r&|j|jcdddS|jjcdddS#1swYyxYw)aj Returns a ``dict`` of packages added for user-defined functions (UDFs). The key of this ``dict`` is the package name and the value of this ``dict`` is the corresponding requirement specifier. Args: artifact_repository: When set this will function will return the packages for a specific artifact repository. N)rrfrprdr rs r get_packageszSession.get_packages*sY   )"99:MNSSU ) )>>&&( ) ) )sAAA"rpackagescL|jt||j|y)a Adds third-party packages as dependencies of a user-defined function (UDF). Use this method to add packages for UDFs as installing packages using `conda `_. You can also find examples in :class:`~snowflake.snowpark.udf.UDFRegistration`. See details of `third-party Python packages in Snowflake `_. To use Python packages that are not available in Snowflake, refer to :meth:`~snowflake.snowpark.Session.custom_package_usage_config`. Args: packages: A `requirement specifier `_, a ``module`` object or a list of them for installing the packages. An exception will be raised if two conflicting requirement specifiers are provided. The syntax of a requirement specifier is defined in full in `PEP 508 `_, but currently only the `version matching clause `_ (``==``) is supported as a `version specifier `_ for this argument. If a ``module`` object is provided, the package will be installed with the version in the local environment. artifact_repository: When set this parameter specifies the artifact repository that packages will be added from. Only functions using that repository will use the packages. (Default None) Example:: >>> import numpy as np >>> from snowflake.snowpark.functions import udf >>> import numpy >>> import pandas >>> import dateutil >>> # add numpy with the latest version on Snowflake Anaconda >>> # and pandas with the version "2.1.*" >>> # and dateutil with the local version in your environment >>> session.custom_package_usage_config = {"enabled": True} # This is added because latest dateutil is not in snowflake yet >>> session.add_packages("numpy", "pandas==2.2.*", dateutil) >>> @udf ... def get_package_name_udf() -> list: ... return [numpy.__name__, pandas.__name__, dateutil.__name__] >>> session.sql(f"select {get_package_name_udf.name}()").to_df("col1").show() ---------------- |"COL1" | ---------------- |[ | | "numpy", | | "pandas", | | "dateutil" | |] | ---------------- >>> session.clear_packages() Note: 1. This method will add packages for all UDFs created later in the current session. If you only want to add packages for a specific UDF, you can use ``packages`` argument in :func:`functions.udf` or :meth:`session.udf.register() `. 2. We recommend you to `setup the local environment with Anaconda `_, to ensure the consistent experience of a UDF between your local environment and the Snowflake server. rN)_resolve_packagesrfrd)r rrs r add_packageszSession.add_packages8s*B  )8 4 NN 3  rpackagec^t|j}|j5|=||jj |ivr|j|j |n8||j vr|j j |nt|ddddy#1swYyxYw)a Removes a third-party package from the dependency list of a user-defined function (UDF). Args: package: The package name. artifact_repository: When set this parameter specifies that the package should be removed from the default packages for a specific artifact repository. Examples:: >>> session.clear_packages() >>> len(session.get_packages()) 0 >>> session.add_packages("numpy", "pandas==2.2.*") >>> len(session.get_packages()) 2 >>> session.remove_package("numpy") >>> len(session.get_packages()) 1 >>> session.remove_package("pandas") >>> len(session.get_packages()) 0 Nz is not in the package list)rnamerrfrr+rdr")r rr package_names rremove_packagezSession.remove_packages8#7+00    O#/ 5599:MrRS223FGKK /""<0 L>1L!MNN O O Os A8B##B,c|j5|+|jj|ijn|jjdddy#1swYyxYw)z Clears all third-party packages of a user-defined function (UDF). When artifact_repository is set packages are only clear from the specified repository. N)rrfrrrdrs rclear_packageszSession.clear_packagessX   '".22667JBOUUW$$&  ' ' 's AAA' file_pathc|jds|jdrt|\}}||_n&t|\}}|D]}|j ||j ||y)az Adds a `requirement file `_ that contains a list of packages as dependencies of a user-defined function (UDF). This function also supports addition of requirements via a `conda environment file `_. To use Python packages that are not available in Snowflake, refer to :meth:`~snowflake.snowpark.Session.custom_package_usage_config`. Args: file_path: The path of a local requirement file. artifact_repository: When set this parameter specifies the artifact repository that packages will be added from. Only functions using that repository will use the packages. (Default None) Example:: >>> from snowflake.snowpark.functions import udf >>> import numpy >>> import pandas >>> import sys >>> # test_requirements.txt contains "numpy" and "pandas" >>> file = "test_requirements.txt" if sys.version_info < (3, 13) else "test_requirements_py313.txt" >>> session.add_requirements(f"tests/resources/{file}") >>> @udf ... def get_package_name_udf() -> list: ... return [numpy.__name__, pandas.__name__] >>> session.sql(f"select {get_package_name_udf.name}()").to_df("col1").show() -------------- |"COL1" | -------------- |[ | | "numpy", | | "pandas" | |] | -------------- >>> session.clear_packages() Note: 1. This method will add packages for all UDFs created later in the current session. If you only want to add packages for a specific UDF, you can use ``packages`` argument in :func:`functions.udf` or :meth:`session.udf.register() `. 2. We recommend you to `setup the local environment with Anaconda `_, to ensure the consistent experience of a UDF between your local environment and the Snowflake server. z.ymlz.yamlrN)rZr?rr@rEr)r rrrruntime_version new_importsr;s radd_requirementszSession.add_requirementssuf   f %););G)D(I)(T %Ho5DD 2$@$K !Hk* -  , - (8KLrz1.7.0ignore_packagesrelaxcn|in|}g}tjjD]}|jdj|vr4tj |jdjdV|jdjt vr4tj |jdjd|jr|sd|jznd}|j|jdj||j|y)au Adds all third-party packages in your local environment as dependencies of a user-defined function (UDF). Use this method to add packages for UDFs as installing packages using `conda `_. You can also find examples in :class:`~snowflake.snowpark.udf.UDFRegistration`. See details of `third-party Python packages in Snowflake `_. If you find that certain packages are causing failures related to duplicate dependencies, try adding duplicate dependencies to the ``ignore_packages`` parameter. If your local environment contains Python packages that are not available in Snowflake, refer to :meth:`~snowflake.snowpark.Session.custom_package_usage_config`. This function is **experimental**, please do not use it in production! Example:: >>> import sys >>> from snowflake.snowpark.functions import udf >>> import numpy >>> import pandas >>> # test_requirements.txt contains "numpy" and "pandas" >>> session.custom_package_usage_config = {"enabled": True, "force_push": True} # Recommended configuration >>> session.replicate_local_environment(ignore_packages={"snowflake-snowpark-python", "snowflake-connector-python", "urllib3", "tzdata", "numpy"}, relax=True) # doctest: +SKIP >>> @udf ... def get_package_name_udf() -> list: ... return [numpy.__name__, pandas.__name__] >>> if sys.version_info <= (3, 11): ... session.sql(f"select {get_package_name_udf.name}()").to_df("col1").show() # doctest: +SKIP -------------- |"COL1" | -------------- |[ | | "numpy", | | "pandas" | |] | -------------- >>> session.clear_packages() # doctest: +SKIP >>> session.clear_imports() # doctest: +SKIP Args: ignore_packages: Set of package names that will be ignored. relax: If set to True, package versions will not be considered. Note: 1. This method will add packages for all UDFs created later in the current session. If you only want to add packages for a specific UDF, you can use ``packages`` argument in :func:`functions.udf` or :meth:`session.udf.register() `. 2. We recommend you to `setup the local environment with Anaconda `_, to ensure the consistent experience of a UDF between your local environment and the Snowflake server. NNamez" found in environment, ignoring...z% is available by default, ignoring...==r) rmetadata distributionsr1rrr7rjrqr)r rrrr version_texts rreplicate_local_environmentz#Session.replicate_local_environments(n!0 7"_ ))779 QG'--/?B ''/55788Z['--/3CC ''/55788]^*1//%w&R  OOw//7==?@O P Q (#rct}|D]}t|trQtj|j |j }|dt jj|}d}n2|jj}|jdrd}t|}|jj}|s1d|vr-tjd|}|r|d|j!n|}|||f||<|S)NrT#F_z[^0-9a-zA-Z\-_.])rerrrMrrrrrjrGr1rHrrresearchstart)r package_dictrruse_local_version package_req reg_matchs r_parse_packageszSession._parse_packages@sv  SG':.>BB$$g&6&6  *N"Y-?-?-G-G -U,VW$(!!--///1%%c*$)!%g.K'++113L$II&97C ?Hw':):;g %13Dk$RL !9 S:rrvalidate_package package_tablecurrent_packagessuppress_local_package_warningsc  g}|j|jDcgc]}|d c}|||} |j5|jj } dddg} |j D]|\} } | \}}}|j r |j nd|r|| vsrtfd| |Dsddnd}tr!|jtd||d||| vr1|js!|jtd||d  jd d s|jtd|d | j| |sN tjj|}d }|||| s!|st j#d|d|d| d||vr0||| k7sR|jt)d| d||dx| ||<t+|dk(r|dt+|dkDr t|g}t+| dk7rt j#d| d jdd rS| jdd sA| d} t-| }|j/|| d}|t j#d|d|s|j3| ||| }|Scc}w#1swYsxYw#tjj$$r|st j#d|dY[t&$r$}|st j#d||Yd}~d}~wwxYw#t&$r3}t j#d|d|j1Yd}~d}~wwxYw) Nr) package_namespackage_table_namerr^c3@K|]}j|ywr)contains).0r3package_specifiers r z3Session._get_dependency_packages..s$ *2215 sz (version r*rzCannot add package ai because it is not available in Snowflake and it cannot be installed via pip as you are executing this code inside a stored procedure. You can find the directory of these packages and add it via Session.add_import. See details at https://docs.snowflake.com/en/developer-guide/snowpark/python/creating-udfs.html#using-third-party-packages-from-anaconda-in-a-udf.z because Anaconda terms must be accepted by ORGADMIN to use Anaconda 3rd party packages. Please follow the instructions at https://docs.snowflake.com/en/developer-guide/udf/python/udf-python-packages.html#using-third-party-packages-from-anaconda.enabledFa because it is not available in Snowflake and Session.custom_package_usage_config['enabled'] is not set to True. To upload these packages, you can set it to True or find the directory of these packages and add it via Session.add_import. See details at https://docs.snowflake.com/en/developer-guide/snowpark/python/creating-udfs.html#using-third-party-packages-from-anaconda-in-a-udf.c  |dk(rqtt|jd\}}}|j|gDchc]-}t tt|jddd/}}||f|vS||j|gvScc}w)Nsnowflake-snowpark-pythonrr))maprWsplitrtuple)rpackage_client_versionvalid_packages client_major client_minorrr3valid_versionss ris_valid_versionz:Session._get_dependency_packages..is_valid_versions ,/JJ@C$')?)E)Ec)JA" = lA .<-?-? b-Q2"()%*#c1773<3C*D$E2"2")5l'C~'U U#9^=O=O ,b>$ 2"s2B zThe version of package 'z' in the local environment is z7, which does not fit the criteria for the requirement 'zo'. Your UDF might not work when the package version is different between the server and your local environment.z Package 'z' is not installed in the local environment. Your UDF might not work when the package is installed on the server but not on your local environment.z6Failed to get the local distribution of package %s: %sCannot add package ' ' because  is already added.rz7The following packages are not available in Snowflake: r cache_path force_cachez-Unable to load environments from remote path z', creating a fresh environment instead.z/, creating a fresh environment instead. Error: )$_get_available_versions_for_packagesvaluesrrrpr specifieranyrcrq RuntimeError_is_anaconda_terms_acknowledgedrrrrjrrpPackageNotFoundErrorrr"rr<%_load_unsupported_packages_from_stage__repr___upload_unsupported_packages)r rrrrr^rerrorsr3rrunsupported_packagesr package_inforrrrrrrEdependency_packagesrenvironment_signatureers @r_get_dependency_packagesz Session._get_dependency_packagesds]BB)5)<)<)>?A1Q4?,-- C ZZ S*.*K*K*P*P*R ' S+-%1%7%7%9o 9 !G\;G 8L+[:E9N9N 5 5TX ~5% !/ != -8$$5#6a8! ./ ("5l^L>Rf!g!$N: $ D D F ("5l^L>R^!^!6::9eL ("5k]Cf!g!(//8*-1:1C1C1K1K(2." 0(*@. $C '&>|nLj'=&>?44;9=b%c!"*//#L1W<MM"27):FVWcFdEef0029 ._o 9d v;! )O [1_v& &13 # $ ) OOIJ^I__`a +..e155mUK8F ,9:N,O)*.*T*T-/J#OO"+L>:E!F %>#OO X , "X!OOG |T778zz|nFsH K K0A K8;MK8MM L??M N)M>>Nr result_dictcg}|D]r}t|tr||vr|j|)t|ts:|j|vsI|j|jd|j t|S)Nr)rr rqrr __version__)rrresms r_get_req_identifiers_listz!Session._get_req_identifiers_listso =A!S!a{&: 1 Az*qzz/L ajj\AMM?;<  =  rTexisting_packages_dictinclude_pandasc tg}|r|jd|j|} t|jt s|g} |j 5| |j} n|j|} | jD]W\} } }| | vr?t|| | k7r.| jtdt|d| | dJt|| | <Yt| dk(r| dt| dkDr t|  dddt j|j|| zSd}|j!sd |}|j 5||ni} |j#| ||| ||j%d d  }|D]}|j&}|j(Dcgc]}|j*|j,f}}|r|ddnd}|| vrD|Qd | |v}|r)| |t|k7rtd|d |d| |dt|| |<t|| |<t| j|j|| zcdddS#1swY`xYwcc}w#1swYyxYw)a Given a list of packages to add, this method will 1. Check if the packages are supported by Snowflake 2. Check if the package version if provided is supported by Snowflake 3. Check if the package is already added 4. Update existing packages dictionary with the new packages (*this is required for python sp to work*) When auto package upload is enabled, this method will also try to upload the packages unavailable in Snowflake to the stage. This function will raise error if any of the above conditions are not met. Returns: List[str]: List of package specifiers rNrrrrrzinformation_schema.packagesz snowflake. _suppress_local_package_warningsF)r^rrzCannot add dependency package ') cloudpicklerqrrrrrrdrfrr r"rrr7rrrrrroperatorrj)r rrrrr^rkwargs extra_modulesrrrpkg_namerpkg_reqrrrrspec package_specsrjadded_package_has_versions rrzSession._resolve_packages"s4%    *++H5 tzz#7 8".F## /&."&..K"&"D"D+#K-9,?,?,A =(Ha K/LK,AA &"6s7|nJ{[cOdNef4!414G H- =v;!# )O[1_&v..%/ /4 **,-0N0N{1 6 ((*(8M  ) *@*L&RT  #'"?"? !106 61 #@ # / 5||>E>O>O!6:T]]DLL1! !2?-*1-D;&*48K package spec of packages that have been added explicitly so far using add_packages() or other such methods. Returns: List[packaging.requirements.Requirement]: List of package dependencies (present in Snowflake) that would need to be added to the package dictionary. Raises: RuntimeError: If any failure occurs in the workflow. rFzIf you are adding package(s) unavailable in Snowflake, it is highly recommended that you include the 'cache_path' configuration parameter in order to reduce latency.r)rrr force_pushzYour code depends on packages that contain native code, it may not work on Snowflake! Set Session.custom_package_usage_config['force_push'] to True if you wish to proceed with using them anyway.rrc.txtrd0SELECT t.$1 as signature, t.$2 as packages from  trrz METADATA: |w,r\NT)r:rgrkrlz Unable to auto-upload packages: z , Error: z | NOTE: Alternatively, you can find the directory of these packages and add it via Session.add_import. See details at https://docs.snowflake.com/en/developer-guide/snowpark/python/creating-udfs.html#using-third-party-packages-from-anaconda-in-a-udf.)+rrrptempfileTemporaryDirectoryrrIr:joinrTmakedirsrAr>rr8r;r=r7rr"r:r<r9rBget_session_stager8rerrrr openrwriterrtrdrErHrNrrcleanup)r rrrrtmpdir_handlertmpdirtargetdownloaded_packages_dictrvalid_downloaded_packagesnative_packagessupported_dependenciesdropped_dependenciesnew_dependenciesrzip_filezip_path stage_name metadata_filenormalized_metadata_pathrr requirementmetadata_local_pathfiler rstage_zip_pathrs rrz$Session._upload_unsupported_packagess/0+..|UC OO_  ~ )%88:N#((FWW\\&*@AF77>>&) F# 1(F C(PPV'W $)-(Q(Q0H0M0M0O%,GLL$1 )R) %90O,-2245)   &$ ?#a'0K0O0Oe1!E /&)==( *7x)@ !013H2INHww||FH5H "68 4//1J*..|UC8F $B"B$ G +G!l!M?3,( NOgNhhjk&+!546 Fc!fCF"4 z(4536((,BDT+T'K(3./ ')ggll>3F3F &V#-s37t&.nn&67 U cU!E7"#5677  &&-.AB#? #K"'" ' JJ " ")(3;JG" # !+|1XJ7N OO!,,\:$~n%56 &&(%(888cp 776 28*IaSI@A  &&(siB(N"N$D$N"N ,N" NAN"0NB!N"N"NN"" O+N==OOOc0|jdddS)Nz/select system$are_anaconda_terms_acknowledged()r) _run_queryr)s rrz'Session._is_anaconda_terms_acknowledged= sPQRSTUVWWrrrctd}|j|}||vrtjd|d|dytd|d}||vrtjd|dy|d |}|j d t |d d jtd|k(d jDcic]!}|d|dr|djdng#}}||D cgc] } t| } } tjd||d|d td|d} |j| jtr| | St| | Scc}wcc} w)a Uses specified stage path to auto-import a group of unsupported packages, along with its dependencies. This saves time spent on pip install, native package detection and zip upload to stage. A cached environment on a stage consists of two files: 1. A metadata dictionary, pickled using cloudpickle, which maps environment signatures to a list of Anaconda-supported dependency packages required for that environment. 2. Zip files named '{PACKAGES_ZIP_NAME}_.zip.gz which contain the unsupported packages. Note that a cached environment is only useful if you wish to use packages unsupported in Snowflake! Supported packages will not be cached (and need not be cached). Also note that any changes to your package list, which does not involve changing the versions or names of unsupported packages, will not necessarily affect your environment signature. Your environment signature corresponds only to packages currently not supported in the Anaconda channel. Args: environment_signature (str): Unique hash signature for a set of unsupported packages, computed by hashing a sorted tuple of unsupported package requirements (package versioning included). Returns: Optional[List[packaging.requirements.Requirement]]: A list of package dependencies for the set of unsupported packages requested. rzMetadata file named z not found at stage path rNrz.zip.gzz2Matching environment file not found at stage path rdrrFr signaturerrrz#Loading dependency packages list - )r8rorrr9rrefilterrrrrrErHrN) r rrrfiles required_filemetadata_file_pathrrrrr;s rrz-Session._load_unsupported_packages_from_stage@ s4::$? 33J?  % LL&}o5NzlZ[\ 22!4I3J'R  % LLDZLPQR !+|1]O<FGcdvGwFxxz{#K(,AAUS++-   FQCFLL%R 7    199N0O %,K     1(;P2Q1RRS T l!2315J4K7 S  %%l3  #"!>+/ #"7   s :&E )E%rrc|rt|dkDr|j|djtdddk(tddj |dzdj ddj tdddj|Dcic]}|dtj|d  c}}|Sd}|Scc}w) NrFrlanguagepythonrrjr]r) rtablerrin_group_byaggrrjsonloads)r rrrr^ppackage_to_version_mappings rrz,Session._get_available_versions_for_packages s0 C $6$:$6%Hu5ANe<@@)UA $.E:YyE:eL++=M+N !djj1&&  #(*)% #(*)' s!#C c|jS)a The query tag for this session. :getter: Returns the query tag. You can use the query tag to find all queries run for this session in the History page of the Snowflake web interface. :setter: Sets the query tag. If the input is ``None`` or an empty :class:`str`, the session's query_tag will be unset. If the query tag is not set, the default will be the call stack when a :class:`DataFrame` method that pushes down the SQL query to the Snowflake Database is called. For example, :meth:`DataFrame.collect`, :meth:`DataFrame.show`, :meth:`DataFrame.create_or_replace_view` and :meth:`DataFrame.create_or_replace_temp_view` will push down the SQL query. Note: The setter calls ``ALTER SESSION SET QUERY_TAG = `` which may be restricted in some environments such as Owner's rights stored procedures. Refer to `Owner's rights stored procedures `_. for more details. )rbr)s r query_tagzSession.query_tag s,rtagc|j5|r(|jjdt|n|jjd||_dddy#1swYyxYw)Nzalter session set query_tag = zalter session unset query_tag)rrr5r"rb)r r)s rr(zSession.query_tag s[ ZZ " $$'EjQToEV%WX $$%DE!DO  " " "s A A##A,c|jddj}t|dk7st|dds t d|dj S)z9 Fetches the current sessions query tag. z SHOW PARAMETERS LIKE 'QUERY_TAG'Frrrrz@Snowflake server side query tag parameter has unexpected schema.)r'_internal_collect_with_tag_no_telemetryrrr"r)r remote_tag_rowss r_get_remote_query_tagzSession._get_remote_query_tag sh(( .%# 1 1 3   1 $GOA4F,PR q!'''r separatorcl|r2|j}|jd||fD}||_yy)a Appends a tag to the current query tag. The input tag is appended to the current sessions query tag with the given separator. Args: tag: The tag to append to the current query tag. separator: The string used to separate values in the query tag. Note: Assigning a value via session.query_tag will remove any appended query tags. Example:: >>> session.query_tag = "tag1" >>> session.append_query_tag("tag2") >>> print(session.query_tag) tag1,tag2 >>> session.query_tag = "new_tag" >>> print(session.query_tag) new_tag Example:: >>> session.query_tag = "" >>> session.append_query_tag("tag1") >>> print(session.query_tag) tag1 Example:: >>> session.query_tag = "tag1" >>> session.append_query_tag("tag2", separator="|") >>> print(session.query_tag) tag1|tag2 Example:: >>> session.sql("ALTER SESSION SET QUERY_TAG = 'tag1'").collect() [Row(status='Statement executed successfully.')] >>> session.append_query_tag("tag2") >>> print(session.query_tag) tag1,tag2 c3&K|] }|s| ywrr)rts rrz+Session.append_query_tag.. s$G1QQ$GsN)r.rr()r r)r/ remote_tagnew_tags rr>zSession.append_query_tag s;L 335Jnn$GS0A$GGG$DN rc|rV|jxsd} tj|}|j|tj||_yy#tj $rtd|wxYw)aI Updates a query tag that is a json encoded string. Throws an exception if the sessions current query tag is not a valid json string. Args: tag: The dict that provides updates to the current query tag dict. Note: Assigning a value via session.query_tag will remove any current query tag state. Example:: >>> session.query_tag = '{"key1": "value1"}' >>> session.update_query_tag({"key2": "value2"}) >>> print(session.query_tag) {"key1": "value1", "key2": "value2"} Example:: >>> session.sql("ALTER SESSION SET QUERY_TAG = '{\"key1\": \"value1\"}'").collect() [Row(status='Statement executed successfully.')] >>> session.update_query_tag({"key2": "value2"}) >>> print(session.query_tag) {"key1": "value1", "key2": "value2"} Example:: >>> session.query_tag = "" >>> session.update_query_tag({"key1": "value1"}) >>> print(session.query_tag) {"key1": "value1"} z{}z8Expected query tag to be valid json. Current query tag: N)r.r#r$updatedumpsr(JSONDecodeErrorr")r r)tag_strtag_dicts rr=zSession.update_query_tag s|: 002:dG ::g.$!%H!5  ''  NwiX s AA"A<)time_travel_mode statementoffset timestamptimestamp_typestreamris_temp_table_for_cleanuprr;)atbeforer<r=r>r?r@c |r|jj} t| jj| } t | j |d| j_|| _ ||| j_ ||| j_ ||| j_ |t| j||t!|| j"_ | | | j$_ nd} t'|t s!t'|t(rdj+|}t-|t/|||| |||||||  } t1| d| S)aL Returns a Table that points the specified table. Args: name: A string or list of strings that specify the table name or fully-qualified object identifier (database name, schema name, and table name). _emit_ast: Whether to emit AST statements. time_travel_mode: Time travel mode, either 'at' or 'before'. Exactly one of statement, offset, timestamp, or stream must be provided when time_travel_mode is set. statement: Query ID for time travel. offset: Negative integer representing seconds in the past for time travel. timestamp: Timestamp string or datetime object. timestamp_type: Type of timestamp interpretation ('NTZ', 'LTZ', or 'TZ'). stream: Stream name for time travel. Note: If your table name contains special characters, use double quotes to mark it like this, ``session.table('"my table"')``. For fully qualified names, you need to use double quotes separately like this, ``session.table('"my db"."my schema"."my.table"')``. Refer to `Identifier Requirements `_. Examples:: >>> df1 = session.create_dataframe([[1, 2], [3, 4]], schema=["a", "b"]) >>> df1.write.save_as_table("my_table", mode="overwrite", table_type="temporary") >>> session.table("my_table").collect() [Row(A=1, B=2), Row(A=3, B=4)] >>> current_db = session.get_current_database() >>> current_schema = session.get_current_schema() >>> session.table([current_db, current_schema, "my_table"]).collect() [Row(A=1, B=2), Row(A=3, B=4)] >>> df_at_time = session.table("my_table", time_travel_mode="at", timestamp="2023-01-01 12:00:00", timestamp_type="LTZ") # doctest: +SKIP >>> df_before = session.table("my_table", time_travel_mode="before", statement="01234567-abcd-1234-5678-123456789012") # doctest: +SKIP >>> df_offset = session.table("my_table", time_travel_mode="at", offset=-3600) # doctest: +SKIP >>> df_stream = session.table("my_table", time_travel_mode="at", stream="my_stream") # doctest: +SKIP # timestamp_type automatically set to "TZ" due to timezone info >>> import datetime, pytz # doctest: +SKIP >>> tz_aware = datetime.datetime(2023, 1, 1, 12, 0, 0, tzinfo=pytz.UTC) # doctest: +SKIP >>> table1 = session.read.table("my_table", time_travel_mode="at", timestamp=tz_aware) # doctest: +SKIP # timestamp_type remains "NTZ" (user's explicit choice respected) >>> table2 = session.read.table("my_table", time_travel_mode="at", timestamp=tz_aware, timestamp_type="NTZ") # doctest: +SKIP TNr) rrA _ast_stmtrr;r<r=r>r?r@z Session.table)rbindr4exprrr3rvariant session_tablerAr;rr<r=r0r>r r?r@rrrrnrrD) r rrArr;r<r=r>r?r@stmtastr2s rrz Session.table* s0x ??'')D#DIIOOT:C SXXt ,(,CKK %,EC )+-=$$*$&/ #!#)  $*3==)D)+.~+>""(!#)  D$$D()C88D>DT"  &?-)  A/rr func_name.func_argumentsfunc_named_argumentsc d}|rjt|j||jj}t|jj |}t |j|g|i|t|jtrvt|jts\|jjrE|jgttdt!gd}|r|j"|_|S t'|g|i|}|j(rJt+||j,j/t1||j,|j,||} nt+|t3|||} t5| d| S) a$ Creates a new DataFrame from the given snowflake SQL table function. References: `Snowflake SQL functions `_. Example 1 Query a table function by function name: >>> import sys, pytest; _ = (sys.version_info[:2] != (3, 9)) or pytest.skip() >>> from snowflake.snowpark.functions import lit >>> session.table_function("split_to_table", lit("split words to table"), lit(" ")).collect() [Row(SEQ=1, INDEX=1, VALUE='split'), Row(SEQ=1, INDEX=2, VALUE='words'), Row(SEQ=1, INDEX=3, VALUE='to'), Row(SEQ=1, INDEX=4, VALUE='table')] Example 2 Define a table function variable and query it: >>> from snowflake.snowpark.functions import table_function, lit >>> split_to_table = table_function("split_to_table") >>> session.table_function(split_to_table(lit("split words to table"), lit(" "))).collect() [Row(SEQ=1, INDEX=1, VALUE='split'), Row(SEQ=1, INDEX=2, VALUE='words'), Row(SEQ=1, INDEX=3, VALUE='to'), Row(SEQ=1, INDEX=4, VALUE='table')] Example 3 If you want to call a UDTF right after it's registered, the returned ``UserDefinedTableFunction`` is callable: >>> from snowflake.snowpark.types import IntegerType, StructField, StructType >>> from snowflake.snowpark.functions import udtf, lit >>> class GeneratorUDTF: ... def process(self, n): ... for i in range(n): ... yield (i, ) >>> generator_udtf = udtf(GeneratorUDTF, output_schema=StructType([StructField("number", IntegerType())]), input_types=[IntegerType()]) >>> session.table_function(generator_udtf(lit(3))).collect() [Row(NUMBER=0), Row(NUMBER=1), Row(NUMBER=2)] Args: func_name: The SQL function name. func_arguments: The positional arguments for the SQL function. func_named_arguments: The named arguments for the SQL function, if it accepts named arguments. Returns: A new :class:`DataFrame` with data from calling the table function. See Also: - :meth:`DataFrame.join_table_function`, which lateral joins an existing :class:`DataFrame` and a SQL function. - :meth:`Session.generator`, which is used to instantiate a :class:`DataFrame` using Generator table function. Generator functions are not supported with :meth:`Session.table_function`. NrFschemarrfrom_rrErzSession.table_function)r/rrFr4rGsession_table_functionr1fnrrrr_suppress_not_implemented_errorcreateDataFramerrruid_ast_idrrr|rcreate_select_statementr&r,rD) r rLrrMrNrJrKans func_exprds rtable_functionzSession.table_function s}n  !$//9 =??'')D#DII$D$DdKC )   '   djj"6 7 JJ A zz99**%{5+-'H&IJ#+ "&((CK 5  & *>   & &66-i$..Q!^^7#A%i0# A A78rr)rowcount timelimitrcolumnsrarbc d}|r|jj}t|jj|}t |\}|j _|D]1}|j jj|j3||_ ||_ ddl m} t|j | r[|j j"rE|j%gt't)dt+gd} |r|j,| _| St|j | r!|j j1dt2|s t5d i} |dk7rt7|j8| d <|dk7rt7|j8| d <|D cgc](} |j:j=| j8i*} } t?| | }|j@r:tC|tEtG||j: |j:||}ntC|tI|||}tK|d|Scc} w)aCreates a new DataFrame using the Generator table function. References: `Snowflake Generator function `_. Args: columns: List of data generation function that work in tandem with generator table function. rowcount: Resulting table with contain ``rowcount`` rows if only this argument is specified. Defaults to 0. timelimit: The query runs for ``timelimit`` seconds, generating as many rows as possible within the time frame. The exact row count depends on the system speed. Defaults to 0. Usage Notes: - When both ``rowcount`` and ``timelimit`` are specified, then: + if the ``rowcount`` is reached before the ``timelimit``, the resulting table with contain ``rowcount`` rows. + if the ``timelimit`` is reached before the ``rowcount``, the table will contain as many rows generated within this time. - If both ``rowcount`` and ``timelimit`` are not specified, 0 rows will be generated. Example 1 >>> from snowflake.snowpark.functions import seq1, seq8, uniform >>> df = session.generator(seq1(1).as_("sequence one"), uniform(1, 10, 2).as_("uniform"), rowcount=3) >>> df.show() ------------------------------ |"sequence one" |"UNIFORM" | ------------------------------ |0 |3 | |1 |3 | |2 |3 | ------------------------------ Example 2 >>> df = session.generator(seq8(0), uniform(1, 10, 2), timelimit=1).order_by(seq8(0)).limit(3) >>> df.show() ----------------------------------- |"SEQ8(0)" |"UNIFORM(1, 10, 2)" | ----------------------------------- |0 |3 | |1 |3 | |2 |3 | ----------------------------------- Returns: A new :class:`DataFrame` with data from calling the generator table function. NrrrFrPzDataFrame.generatorrz4Columns cannot be empty for generator table functionrarb)args operators)r^rrSrUzSession.generator)&rrFr4rG generatorrgrcvariadicrerq_ast row_counttime_limit_seconds#snowflake.snowpark.mock._connectionrrrrXrYrrrrZr[rrr"r _expressionranalyzer+rr|r%r&r,rD)r rarbrrcrJrK col_namescol_namerr] named_argsrrfr^r_s rrgzSession.generator sl ??'')D#DII$7$7>C.T/ +Is{{+& 7   '' 6 7$CM%.C " M tzz#7 8 ::&&!;ukm#D"EF'C "hh J djj"6 7 JJ . .&;/ / ST T q=%(]%>%>Jz " >&))n&@&@J{ #LSTST^^++COOR@T T* iP  & &-"+dnn"^^  # A%i0# A A23/Us-IqueryparamsrEc d}|rs|o|jj}t|jj|}||_|.|D]&}t |jj|(n|}t|jtr^|jjsH|jjr tdd|jjdt |j"rKt%||j&j)t+||j&||j&|| }n5t%||j&j,j |d| || }t/|d|S) a Returns a new DataFrame representing the results of a SQL query. Note: You can use this method to execute a SQL query lazily, which means the SQL is not executed until methods like :func:`DataFrame.collect` or :func:`DataFrame.to_pandas` evaluate the DataFrame. For **immediate execution**, chain the call with the collect method: `session.sql(query).collect()`. Args: query: The SQL statement to execute. params: binding parameters. We only support qmark bind variables. For more information, check https://docs.snowflake.com/en/developer-guide/python-connector/python-connector-example#qmark-or-numeric-binding _ast_stmt: when invoked internally, supplies the AST to use for the resulting dataframe. Example:: >>> # create a dataframe from a SQL query >>> df = session.sql("select 1/2") >>> # execute the query >>> df.collect() [Row(1/2=Decimal('0.500000'))] >>> # Use params to bind variables >>> session.sql("select * from values (?, ?), (?, ?)", params=[1, "a", 2, "b"]).sort("column1").collect() [Row(COLUMN1=1, COLUMN2='a'), Row(COLUMN1=2, COLUMN2='b')] NzBCannot perform this operation because the session has been closed.1404)rDz Session.sqlr)rrsrSrU) source_planrs)rrFr4rGrrrr0rsrrrrrXrrrrrr|rr\r$ plan_builderrD) r rrrsrErrJrGr%r_s rrz Session.sqlz smH  ++-(=" %#I24;;??3DaHI! tzz#7 8JJ>>zz##%.X% JJ . .&3/ /   & &66#EDNN6R!^^7#A++11tF2# A A}-rct|S)zReturns a :class:`DataFrameReader` that you can use to read data from various supported sources (e.g. a file in a stage) as a DataFrame.r}r)s rreadz Session.read st$$rc|jS)zBReturns an integer that represents the session ID of this session.)rhr)s r session_idzSession.session_id src.|jjS)zReturns a :class:`SnowflakeConnection` object that allows you to access the connection between the current session and Snowflake server.)rr)s rr:zSession.connection szzris_ddl_on_temp_objectlog_on_exceptioncF|jj||||dS)N)r}r~_statement_paramsdata)rr5)r rrr}r~r^s rrzSession._run_query s6zz## "7-. $   r query_paramsc:|jj||Sr)rget_result_attributes)r rrrs r_get_result_attributeszSession._get_result_attributes szz//|DDrc>|j5|js]|jttj }|j dt|jdd|d|||_dddt|jS#1swYxYw)at Returns the name of the temporary stage created by the Snowpark library for uploading and storing temporary artifacts for this session. These artifacts include libraries and packages for UDFs that you define in this session via :func:`add_import`. Note: This temporary stage is created once under the current database and schema of a Snowpark session. Therefore, if you switch database or schema during the session, the stage will not be re-created in the new database or schema, and still references the stage in the old database or schema. zcreate Tz) stage if not exists )r}r^N) rrk$get_fully_qualified_name_if_possiblerjrSSTAGErr`r{rN)r r^full_qualified_stage_names rrzSession.get_session_stage sZZ @&&,0,U,U/0D0DE-)6t7T7TVZ[\]))B(CE*.%5  '@# @ 3 3455 @ @s A*BBz1.28.0gzipabort_statementr) databaserQr< compressionon_erroruse_vectorized_scannerparallelquote_identifiersauto_create_tablerl table_typeuse_logical_typerrz pyarrow.Table table_namerrQrrrrrrrlr)rtemp temporary transientrrc  |jjj}| r#|rd|zdznd|rd|zdzndzd|zdzz}n|r|dznd|r|dzndz|z}tdid|d|d|d|d |d |d |d |d |d| d| d| d| d| d|d|jxr t \}}}}|r!|j |d}t |d|Std|)aG Writes a pyarrow.Table to a Snowflake table. The pyarrow Table is written out to temporary files, uploaded to a temporary stage, and then copied into the final location. This function requires the optional dependenct snowflake-snowpark-python[pandas] be installed. Returns a Snowpark Table that references the table referenced by table_name. Args: table: The pyarrow Table that is written. table_name: Table name where we want to insert into. database: Database schema and table is in, if not provided the default one will be used (Default value = None). schema: Schema table is in, if not provided the default one will be used (Default value = None). chunk_size: Number of rows to be inserted once. If not provided, all rows will be dumped once. Default to None normally, 100,000 if inside a stored procedure. Note: If auto_create_table or overwrite is set to True, the chunk size may affect schema inference because different chunks might contain varying data types, especially when None values are present. This can lead to inconsistencies in inferred types. compression: The compression used on the Parquet files, can only be gzip, or snappy. Gzip gives a better compression, while snappy is faster. Use whichever is more appropriate (Default value = 'gzip'). on_error: Action to take when COPY INTO statements fail, default follows documentation at: https://docs.snowflake.com/en/sql-reference/sql/copy-into-table.html#copy-options-copyoptions (Default value = 'abort_statement'). use_vectorized_scanner: Boolean that specifies whether to use a vectorized scanner for loading Parquet files. See details at `copy options `_. parallel: Number of threads to be used when uploading chunks, default follows documentation at: https://docs.snowflake.com/en/sql-reference/sql/put.html#optional-parameters (Default value = 4). quote_identifiers: By default, identifiers, specifically database, schema, table and column names (from df.columns) will be quoted. If set to False, identifiers are passed on to Snowflake without quoting. I.e. identifiers will be coerced to uppercase by Snowflake. (Default value = True) auto_create_table: When true, will automatically create a table with corresponding columns for each column in the passed in DataFrame. The table will not be created if it already exists table_type: The table type of to-be-created table. The supported table types include ``temp``/``temporary`` and ``transient``. Empty means permanent table as per SQL convention. use_logical_type: Boolean that specifies whether to use Parquet logical types. With this file format option, Snowflake can interpret Parquet logical types during data loading. To enable Parquet logical types, set use_logical_type as True. Set to None to use Snowflakes default. For more information, see: https://docs.snowflake.com/en/sql-reference/sql/create-file-format "".rrcursorrrrrQr<rrrrrrrlrruse_scoped_temp_objectFrzSession.write_arrowz;Failed to write arrow table to Snowflake. COPY INTO output r)rrr!r{rcrrDr)r rrrrQr<rrrrrrrlrrrrrlocationsuccessr ci_outputs rr!zSession.write_arrow sz!!((* ,4#.4'",2C&L4'<#c)+ $,C#)6C` or :func:`modin.pandas.Series.to_snowflake ` internally Args: df: The Snowpark pandas DataFrame or Series we'd like to write back. table_name: Name of the table we want to insert into. location: the location of the table in string. database: Database that the table is in. If not provided, the default one will be used. schema: Schema that the table is in. If not provided, the default one will be used. quote_identifiers: By default, identifiers, specifically database, schema, table and column names (from :attr:`DataFrame.columns`) will be quoted. `to_snowflake` always quote column names so quote_identifiers = False is not supported here. auto_create_table: When true, automatically creates a table to store the passed in pandas DataFrame using the passed in ``database``, ``schema``, and ``table_name``. Note: there are usually multiple table configurations that would allow you to upload a particular pandas DataFrame successfully. If you don't like the auto created table, you can always create your own table before calling this function. For example, auto-created tables will store :class:`list`, :class:`tuple` and :class:`dict` as strings in a VARCHAR column. overwrite: Default value is ``False`` and the pandas DataFrame data is appended to the existing table. If set to ``True`` and if auto_create_table is also set to ``True``, then it drops the table. If set to ``True`` and if auto_create_table is set to ``False``, then it truncates the table. Note that in both cases (when overwrite is set to ``True``) it will replace the existing contents of the table with that of the passed in pandas DataFrame. index: default True If true, save DataFrame index columns as table columns. index_label: Column label for index column(s). If None is given (default) and index is True, then the index names are used. A sequence should be given if the DataFrame uses MultiIndex. table_type: The table type of table to be created. The supported values are: ``temp``, ``temporary``, and ``transient``. An empty string means to create a permanent table. Learn more about table types `here `_. z=quote_identifiers = False is not supported by `to_snowflake`.idrcd|zdzS)Nrr)rs rquote_idz4Session._write_modin_pandas_helper..quote_id s8c> !rz:Cannot write Snowpark pandas DataFrame or Series to table z} because it does not exist. Use auto_create_table = True to create table before writing a Snowpark pandas DataFrame or SeriesrXrq)r if_existsrrrN)rr  _table_existsr to_snowflake)r rrrrrQrrrlrrrrrrs r_write_modin_pandas_helperz"Session._write_modin_pandas_helpery s`!%O  " " "| V$%,D X&'$.D ););D)A)LXJWpq "+I  #!  r)rrQr<rrrrrcreate_temp_tablerlrrrr)pandas.DataFramerrrc t|jtr!|jjdt| rt ddd} | r(| j tvrtdtt|dr#t|jdk(r td d } | r#|rd |zd znd |rd |zd znd zd |zd zz}n|r|dznd |r|dznd z|z}|Ftjt}d|j v}|r||d<nt#j$ddt'\}}|rVt||j(|j*fr4|j-dd |j.|||f||| | | | d|d\}}nRt|jtrdg}}n3t|jj||f||||||| | | | |d |\}}}}|r|j9|d}t;|d|r|j<j?}tA|jBj|}| |_"||tFk7r||jH_%||_&| |_'t|tPj(r?tS|jTjVjXjZ|j\nt dt_||rO|jaD]<\}}|jbje} || _3ti| jj|>||_6| |_7||_8| |_9|}!|||!g}!|| td|g|!z}!tS|j\|!| |_:|jv|_<|St5jzt}|#t$r8}|j0j3drt5j6||d }~wwxYw)aWrites a pandas DataFrame to a table in Snowflake and returns a Snowpark :class:`DataFrame` object referring to the table where the pandas DataFrame was written to. Args: df: The pandas DataFrame or Snowpark pandas DataFrame or Series we'd like to write back. table_name: Name of the table we want to insert into. database: Database that the table is in. If not provided, the default one will be used. schema: Schema that the table is in. If not provided, the default one will be used. chunk_size: Number of rows to be inserted once. If not provided, all rows will be dumped once. Default to None normally, 100,000 if inside a stored procedure. Note: If auto_create_table or overwrite is set to True, the chunk size may affect schema inference because different chunks might contain varying data types, especially when None values are present. This can lead to inconsistencies in inferred types. compression: The compression used on the Parquet files: gzip or snappy. Gzip gives supposedly a better compression, while snappy is faster. Use whichever is more appropriate. on_error: Action to take when COPY INTO statements fail. See details at `copy options `_. parallel: Number of threads to be used when uploading chunks. See details at `parallel parameter `_. quote_identifiers: By default, identifiers, specifically database, schema, table and column names (from :attr:`DataFrame.columns`) will be quoted. If set to ``False``, identifiers are passed on to Snowflake without quoting, i.e. identifiers will be coerced to uppercase by Snowflake. auto_create_table: When true, automatically creates a table to store the passed in pandas DataFrame using the passed in ``database``, ``schema``, and ``table_name``. Note: there are usually multiple table configurations that would allow you to upload a particular pandas DataFrame successfully. If you don't like the auto created table, you can always create your own table before calling this function. For example, auto-created tables will store :class:`list`, :class:`tuple` and :class:`dict` as strings in a VARCHAR column. create_temp_table: (Deprecated) The to-be-created table will be temporary if this is set to ``True``. Note that to avoid breaking changes, currently when this is set to True, it overrides ``table_type``. overwrite: Default value is ``False`` and the pandas DataFrame data is appended to the existing table. If set to ``True`` and if auto_create_table is also set to ``True``, then it drops the table. If set to ``True`` and if auto_create_table is set to ``False``, then it truncates the table. Note that in both cases (when overwrite is set to ``True``) it will replace the existing contents of the table with that of the passed in pandas DataFrame. table_type: The table type of table to be created. The supported values are: ``temp``, ``temporary``, and ``transient``. An empty string means to create a permanent table. Learn more about table types `here `_. use_logical_type: Boolean that specifies whether to use Parquet logical types when reading the parquet files for the uploaded pandas dataframe. With this file format option, Snowflake can interpret Parquet logical types during data loading. To enable Parquet logical types, set use_logical_type as True. Set to None to use Snowflakes default. For more information, see: `file format options: `_. use_vectorized_scanner: Boolean that specifies whether to use a vectorized scanner for loading Parquet files. See details at `copy options `_. Example:: >>> import pandas as pd >>> pandas_df = pd.DataFrame([(1, "Steve"), (2, "Bob")], columns=["id", "name"]) >>> snowpark_df = session.write_pandas(pandas_df, "write_pandas_table", auto_create_table=True, table_type="temp") >>> snowpark_df.sort('"id"').to_pandas() id name 0 1 Steve 1 2 Bob >>> pandas_df2 = pd.DataFrame([(3, "John")], columns=["id", "name"]) >>> snowpark_df2 = session.write_pandas(pandas_df2, "write_pandas_table", auto_create_table=False) >>> snowpark_df2.sort('"id"').to_pandas() id name 0 1 Steve 1 2 Bob 2 3 John >>> pandas_df3 = pd.DataFrame([(1, "Jane")], columns=["id", "name"]) >>> snowpark_df3 = session.write_pandas(pandas_df3, "write_pandas_table", auto_create_table=False, overwrite=True) >>> snowpark_df3.to_pandas() id name 0 1 Jane >>> pandas_df4 = pd.DataFrame([(1, "Jane")], columns=["id", "name"]) >>> snowpark_df4 = session.write_pandas(pandas_df4, "write_pandas_transient_table", auto_create_table=True, table_type="transient") >>> snowpark_df4.to_pandas() id name 0 1 Jane Note: 1. Unless ``auto_create_table`` is ``True``, you must first create a table in Snowflake that the passed in pandas DataFrame can be written to. If your pandas DataFrame cannot be written to the specified table, an exception will be raised. 2. If the dataframe is Snowpark pandas :class:`~modin.pandas.DataFrame` or :class:`~modin.pandas.Series`, it will call :func:`modin.pandas.DataFrame.to_snowflake ` or :func:`modin.pandas.Series.to_snowflake ` internally to write a Snowpark pandas DataFrame into a Snowflake table. 3. If the input pandas DataFrame has `datetime64[ns, tz]` columns and `auto_create_table` is set to `True`, they will be converted to `TIMESTAMP_LTZ` in the output Snowflake table by default. If `TIMESTAMP_TZ` is needed for those columns instead, please manually create the table before loading data. zSession.write_pandasrzwrite_pandas.create_temp_tablezcreate_temp_table is deprecated. We still respect this parameter when it is True but please consider using `table_type="temporary"` instead.rz.Unsupported table type. Expected table types: rcr>The provided schema or inferred schema cannot be None or emptyNrrrrrzuse_logical_type will be ignored because current python connector version does not support it. Please upgrade snowflake-connector-python to 3.4.0 or above.r stacklevel)rrQrrrlr)TrT) rrQr<rrrrrrlrrzdoes not existFrz)Only pandas DataFrame supported, but not z'Need to set schema when using database.)?rrrrrrpr1rOr"rrrcrinspectrr parameterswarningswarnrbr|Seriesr+rmsgrZr5(DF_PANDAS_TABLE_DOES_NOT_EXIST_EXCEPTIONrrDrrFr4rGrrr<rrrrr3rdataframe_data__pandasr3 temp_tablertyperrr_1r0_2rrlrrrrZr[DF_PANDAS_GENERAL_EXCEPTIONr )"r rrrrQr<rrrrrrrlrrrrrrrruse_logical_type_supported modin_pandasmodin_is_importedrrperrJrKr2r3r2table_locations" rrzSession.write_pandas s\l djj"6 7 JJ . .&</ /   0J  %J ***,4II@AV@WX  2y !c"**o&:"P K  08cHnt+b06f t+B@Z'#-/(0X^R'-v|27!#  +#--l; -?9CWCW-W*-1AF-.MMH$% /M.N +L+ Z\++\-@-@A& -t4/// &!&7&7')  &."djj*>?)-rYG/; (("0"*%#-$/!)!)*;*;"+#-/E0!0,GQ92 JJx5J9E '= >++-' (>(>E(9%)j"``) or an *implicit* struct (e.g. ``"a: int, b: string"``). Internally, the string is parsed and converted into a :class:`StructType` using Snowpark's type parsing. - When ``schema`` is a list of column names or ``None``, the schema of the DataFrame will be inferred from the data across all rows. To improve performance, provide a schema. This avoids the need to infer data types with large data sets. **kwargs: Additional keyword arguments passed to :meth:`write_pandas` or :meth:`write_arrow` when ``data`` is a pandas DataFrame or pyarrow Table, respectively. These can include options such as chunk_size or compression. Examples:: >>> # create a dataframe with a schema >>> from snowflake.snowpark.types import IntegerType, StringType, StructField >>> schema = StructType([StructField("a", IntegerType()), StructField("b", StringType())]) >>> session.create_dataframe([[1, "snow"], [3, "flake"]], schema).collect() [Row(A=1, B='snow'), Row(A=3, B='flake')] >>> # create a dataframe by inferring a schema from the data >>> from snowflake.snowpark import Row >>> # infer schema >>> session.create_dataframe([1, 2, 3, 4], schema=["a"]).collect() [Row(A=1), Row(A=2), Row(A=3), Row(A=4)] >>> session.create_dataframe([[1, 2, 3, 4]], schema=["a", "b", "c", "d"]).collect() [Row(A=1, B=2, C=3, D=4)] >>> session.create_dataframe([[1, 2], [3, 4]], schema=["a", "b"]).collect() [Row(A=1, B=2), Row(A=3, B=4)] >>> session.create_dataframe([Row(a=1, b=2, c=3, d=4)]).collect() [Row(A=1, B=2, C=3, D=4)] >>> session.create_dataframe([{"a": 1}, {"b": 2}]).collect() [Row(A=1, B=None), Row(A=None, B=2)] >>> # create a dataframe from a pandas Dataframe >>> import pandas as pd >>> session.create_dataframe(pd.DataFrame([(1, 2, 3, 4)], columns=["a", "b", "c", "d"])).collect() [Row(a=1, b=2, c=3, d=4)] >>> # create a dataframe using an implicit struct schema string >>> session.create_dataframe([[10, 20], [30, 40]], schema="x: int, y: int").collect() [Row(X=10, Y=20), Row(X=30, Y=40)] Note: When `data` is a pandas DataFrame, `snowflake.connector.pandas_tools.write_pandas` is called, which requires permission to (1) CREATE STAGE (2) CREATE TABLE and (3) CREATE FILE FORMAT under the current database and schema. Nzdata cannot be None.z9create_dataframe() function does not accept a Row object.zUcreate_dataframe() function only accepts data as a list, tuple or a pandas DataFrame.zbdata is a pandas DataFrame, parameter schema is ignored. To silence this warning pass schema=None.r)rrF)quotedrQTr)rrQrrrrrzSession.create_dataframe[arrow]z Session.create_dataframe[pandas]zInvalid schema string: zF. You should provide a valid schema string representing a struct type.z#Cannot infer schema from empty datac36K|]}t|ywr)rH)rrnamess rrz+Session.create_dataframe..s:cc5):srrrrrcHd}|dg}n~t|ttfrD|sdg}nbt|ddrUt|tr|j n|j }n$t|tr|j}n|g}|rK|jDcic]\}}t||}}}|Dcgc]}|j|c}St|t|k7r#tt|dt|dt|Scc}}wcc}w)N_fieldsz# fields are required by schema but z values are provided. This might be because data consists of rows with different lengths, or mixed rows with column names or without column names)rrr7rras_dict_asdictrerprrirrr")rrrow_dictr2r3rs rconvert_row_to_listz5Session.create_dataframe..convert_row_to_lists H{fC%/&CS)T20:30Ds{{}#++-HC&88:e9A9IJAJqM1,JJ7<=t T*==s8s5z)$u:,'"3xj)DE Cy K=s D9DzCREATE SCOPED TEMP TABLE z (r*zSELECT * FROM z{Cannot create temp table for specified non-nullable schema, fall back to using schema string from select query. Exception: )rz Cannot cast (z) to r) schema_queryrRrSrz Session.create_dataframe[values]zUnsupported type z in create_dataframe.)r"rr TypeErrorr7rrrr|rrrr UserWarningrYrjrSTABLErrr_get_current_parameterr!r~rDrrrFr4rGcreate_dataframer3rrr3rr2rQdataframe_schema__structrZr[r rKrrrrJrfieldsrr rrrizipdatatyperrrrrrrrrrrrrrqr#nullablerall is_primitiverattribute_to_schema_stringrrrrrdecimalDecimalrdatetimetimedaterrr#r7rRrecontext%_should_use_structured_type_semanticsrrrr precisionscaleas_tzrNTZrLTZrTZrrrrrrrrcastrrrr\create_select_snowflake_planr)rrr0dataframe_data__tuplevsrdataframe_data__listdataframe_schema__list)%r rrQrr origin_datatemp_table_name sf_database sf_schemarrJrKrr new_schemarfr quoted_namesrrowsattrs data_typesfield quoted_namesf_type schema_stringr converted converted_rowr data_typeproject_columnsrto_timestamp_funcrrs% @rrzSession.create_dataframe s5V <34 4 dC WX X$u .  "4&*:*:GMM)JKg  4&"2"2GMM!BC" MMt   4&2B2BGMM1R S++N,@,@AO$**&:;FtL #jj??u@ !JJ==hu=U dGMM2,D,,' "-(*.*.#.)-)M)M"' ! E(/PQ-D--' "-(*.*.#.)-)M)M"' ! E(/QR??//1D+DII,F,FMC$7799DDo1 cjj&I&I&K&K%)HHEM  fc "/7Ffj1 -fX6[\" fj )J $  !FGG&(+V :T:J z  !Q &P  !x}c)* !379 !  !@%/%6%67QVV7E5:;T 4(; ;BFG3#C6GGz"%j&7&7"F . E;NN! +%$" %#"-  &^^) , LL;H I   enn -1 .4  tzz+?@fmmLU50LMFMMR5446RS"=n>R>R"S . I I% P  OO3O3DB}oUVW&4D4]4]^m4n3o#pL 9 2CM$'Z$86  y=!((.w7J{="((/x'8'89j}?"((U4x}}5*x;"((U4x}}5*x;"((U4 +@A!((/ +>?!((/ ;7!((/eU';<yB"((E?S)TUt,42"((E?S)TUuc*"9j9EEG!(( 5==?8LM ;7!((E?S)TU =9!((/ <8!((/ 84!((/ :6!((E?S)TU#&tE{m1UG5Y@PPQRi6 n   S-0 1s9 2xz00%8- 5KE4%..+6&&t 00,,c$i ENNM:^^&&*...(8%,000(8%,///(7%(4%&&'8'F'J'J4'PQENNH5&&wvd|'<'@'@'FGENNH5&&wvd|'<'@'@'FGENNK8&&z*VD\2J'K'O'OPT'UVENNM:&&|F4L'A'E'Ed'KLENNL9&&{6$<'@'D'DT'JKENNY,LM&&vd|,11%..AEEdKENNJ7&&vd|,11%..AEEdKENNH5&&wvd|'<'@'@'FGENN,AB&&vd|'8'8'H'L'LT'RSENN,?@&&vd|'8'8'H'L'LT'RS&&vd|4[- 5`*3t##%** 66..EE'y|T!%F"^^ 7  f_f6y|Lf_f6# & B BC BJ ;(8(894::';<0OTJE' (B(BDI!HH3355@@/-LL#**"E"E"G"G!% L #DII$>$>EC+u-&C.6699==?K.&C.5588<<>  '[(9'::OP!fd+ &J 99<<CCDIJ 30 C C E EBJ m8;GHMR(MM@@CAxIsB9AF.AF3+AF8<AF=+!AG,AGG AG<G!AG7G7AG<rendstepc | td||n t|||}d}|re|jj}t|jj |}||_|r||j_||j_|jrZt||jj|jj||j|j||}nt||||}t|d|S)a Creates a new DataFrame from a range of numbers. The resulting DataFrame has single column named ``ID``, containing elements in a range from ``start`` to ``end`` (exclusive) with the step value ``step``. Args: start: The start of the range. If ``end`` is not specified, ``start`` will be used as the value of ``end``. end: The end of the range. step: The step of the range. Examples:: >>> session.range(10).collect() [Row(ID=0), Row(ID=1), Row(ID=2), Row(ID=3), Row(ID=4), Row(ID=5), Row(ID=6), Row(ID=7), Row(ID=8), Row(ID=9)] >>> session.range(1, 10).collect() [Row(ID=1), Row(ID=2), Row(ID=3), Row(ID=4), Row(ID=5), Row(ID=6), Row(ID=7), Row(ID=8), Row(ID=9)] >>> session.range(1, 10, 2).collect() [Row(ID=1), Row(ID=3), Row(ID=5), Row(ID=7), Row(ID=9)] NrrRrSrUz Session.range)r(rrFr4rGrangerrrr rr|rr\rrD) r rrr r range_planrJrKrs rr z Session.ranges8/2kU1eT*uUCQU?V  ??'')D#DIIOOT:CCI # !CHHN  & &66..EE"T^^F"^^ 7 # B4tyQBB0 rquery_idctr'|jjdds tdt |jt r!|jj dtt|d|S)zp Creates an :class:`AsyncJob` from a query ID. See also: :class:`AsyncJob` )ENABLE_ASYNC_QUERY_IN_PYTHON_STORED_PROCSFz4Async query is not supported in stored procedure yetzSession.create_async_jobrN)rcrr`rrrrrw)r r s rcreate_async_jobzSession.create_async_jobsr # $JJAA;U&F  djj"6 7 JJ . .&@/ / $--rc8|jjdS)z| Returns the name of the current account for the Python connector session attached to this session. accountrrr)s rrzSession.get_current_accounts zz00;;rc8|jjdS)zo Returns the name of the user in the connection to Snowflake attached to this session. userrr)s rget_current_userzSession.get_current_users zz0088rc8|jjdS)z Returns the name of the current database for the Python connector session attached to this session. See the example in :meth:`table`. rrr)s rrzSession.get_current_databases zz00<`_. zuse secondary roles Nr0)rr1)r r/s ruse_secondary_roleszSession.use_secondary_rolesbs' "U]6 "N O r object_name object_typec|rt|d|d|}t|jtrd}t j ||x}rb|j d}|j d}|jj}|5t|jd||dddy|j|y|j|ytd|d#1swYyxYw) Nzuse  z5^\s*use\s+(warehouse|database|schema|role)\s+(.+)\s*$rr)_active_'z' must not be empty or None.) rnrrrrmatchgroupget_lockrrr")r r3r4rruse_ddl_patternr9mock_conn_locks rr'zSession._use_objectqs   -;-q 6E$**&:;L HH_e<<5<#(++a.K"'++a.K%)ZZ%8%8%:N'S h{m,DkRSSOOE*&q -IJK KSSs CC(cB|jjjS)asControls whether or not the Snowpark client sends usage telemetry to Snowflake. This typically includes information like the API calls invoked, libraries used in conjunction with Snowpark, and information that will let us better diagnose and fix client side errors. The default value is ``True``. Example:: >>> session.telemetry_enabled True >>> session.telemetry_enabled = False >>> session.telemetry_enabled False >>> session.telemetry_enabled = True >>> session.telemetry_enabled True )rr_enabledr)s rtelemetry_enabledzSession.telemetry_enableds&zz++444rc|rdd|jj_tr>|js1t j dd|jj_yyyd|jj_y)NTzkClient side parameter ENABLE_SNOWPARK_FIRST_PARTY_TELEMETRY is set to False, telemetry could not be enabledF)rrr?rcrrrrs rr@zSession.telemetry_enabledsj 48DJJ ( ( 1%'0P0P B9> ,,5 1Q'5:DJJ ( ( 1rc|jS)z Returns a :class:`FileOperation` object that you can use to perform file operations on stages. See details of how to use this object in :class:`FileOperation`. )rvr)s rrz Session.files zzrc|jS)z Returns a :class:`Lineage` object that you can use to explore lineage of snowflake entities. See details of how to use this object in :class:`Lineage`. )rwr)s rlineagezSession.lineages }}rc|jS)z Returns a :class:`udf.UDFRegistration` object that you can use to register UDFs. See details of how to use this object in :class:`udf.UDFRegistration`. )rlr)s rr?z Session.udfs %%%rc|jS)z Returns a :class:`udtf.UDTFRegistration` object that you can use to register UDTFs. See details of how to use this object in :class:`udtf.UDTFRegistration`. )rmr)s rudtfz Session.udtfs&&&rc|jS)z Returns a :class:`udaf.UDAFRegistration` object that you can use to register UDAFs. See details of how to use this object in :class:`udaf.UDAFRegistration`. )rnr)s rudafz Session.udafs &&&rc|jS)z Returns a :class:`stored_procedure.StoredProcedureRegistration` object that you can use to register stored procedures. See details of how to use this object in :class:`stored_procedure.StoredProcedureRegistration`. )ror)s rrAz Session.sprocs $$$rc|jS)z Returns a :class:`stored_procedure_profiler.StoredProcedureProfiler` object that you can use to profile stored procedures. See details of how to use this object in :class:`stored_procedure_profiler.StoredProcedureProfiler`. )rr)s rstored_procedure_profilerz!Session.stored_procedure_profilers    rz1.43.0c|jS)a Returns a :class:`event_table_telemetry.EventTableTelemetry` object that you can use to send telemetry to snowflake event table. See details of how to use this object in :class:`event_table_telemetry.EventTableTelemetry`. `Session.client_telemetry` object enable user to send telemetry to designated event table when necessary dependencies are installed. Only traces and logs between `client_telemetry.enable_event_table_telemetry_collection` and `client_telemetry.disable_event_table_telemetry_collection` will be sent to event table. You can call `client_telemetry.enable_event_table_telemetry_collection` again to re-enable external telemetry after it is turned off. Note: This function requires the `opentelemetry` extra from Snowpark. Install it via pip: .. code-block:: bash pip install "snowflake-snowpark-python[opentelemetry]" Examples 1 .. code-block:: python ext = session.client_telemetry ext.enable_event_table_telemetry_collection("snowflake.telemetry.events", logging.INFO, True) tracer = trace.get_tracer("my_tracer") with tracer.start_as_current_span("code_store") as span: span.set_attribute("code.lineno", "21") span.set_attribute("code.content", "session.sql(...)") logging.info("Trace being sent to event table") ext.disable_event_table_telemetry_collection() Examples 2 .. code-block:: python ext = session.client_telemetry logging.info("log before enable external telemetry") # this log is not sent to event table ext.enable_event_table_telemetry_collection("snowflake.telemetry.events", logging.INFO, True) tracer = trace.get_tracer("my_tracer") with tracer.start_as_current_span("code_store") as span: span.set_attribute("code.lineno", "21") span.set_attribute("code.content", "session.sql(...)") logging.info("Trace being sent to event table") ext.disable_event_table_telemetry_collection() logging.info("out of scope log") # this log is not sent to event table ext.enable_event_table_telemetry_collection("snowflake.telemetry.events", logging.DEBUG, True) logging.debug("debug log") # this log is sent to event table because external telemetry is re-enabled ext.disable_event_table_telemetry_collection() )rr)s rclient_telemetryzSession.client_telemetrysd%%%rc|jS)z Returns a :class:`udf_profiler.UDFProfiler` object that you can use to profile UDFs. See details of how to use this object in :class:`udf_profiler.UDFProfiler`. )rr)s r udf_profilerzSession.udf_profilers !!!rc|jS)z Returns a :class:`dataframe_profiler.DataframeProfiler` object that you can use to profile dataframe operations. See details of how to use this object in :class:`dataframe_profiler.DataframeProfiler`. )rr)s rdataframe_profilerzSession.dataframe_profiler!s '''rr~ sproc_namerec|jjjdryd} g}|D]}t|trf|j }t|t r%|jt|jT|jt|jy|jtt||jddj|d}|jd||}|d d } | jjd S#t$r%} tj!d |d | Yd} ~ yd} ~ wwxYw) NzSYSTEM$Frrz, r*zdescribe procedure rSrrzCould not describe procedure z due to exception )rGupperrHrryrmr-rqrGtorrIrrrrr) r rTr~refunc_signature arg_typesargrG sproc_desc return_typeexcs r_infer_is_return_tablezSession._infer_is_return_table)s]     # # % 0 0 ; I Mc6*??D!$-!(()>tww)GH!(()>t}})MN$$%::c?%KL M!+ 0 0 231TYYy5I4J!LN %n%56!1)J%Q-*K$$&11': :  LL//??QRUQVW    sDD66 E$?EE$r^blockr~return_dataframerr`rac 6|j|g||||||dS)a Calls a stored procedure by name. Args: sproc_name: The name of stored procedure in Snowflake. args: Arguments should be basic Python types. statement_params: Dictionary of statement level parameters to be set while executing this action. block: Whether to block until the result is available. When it is ``False``, this function executes the stored procedure asynchronously and returns an :class:`AsyncJob`. log_on_exception: Log warnings if they arise when trying to determine if the stored procedure as a table return type. return_dataframe: When set to True, the return value of this function is a DataFrame object. This is useful when the given stored procedure's return type is a table. Returns: When block=True: The stored procedure result (scalar value or DataFrame) When block=False: An AsyncJob object for retrieving results later Example:: >>> import snowflake.snowpark >>> from snowflake.snowpark.functions import sproc >>> >>> session.add_packages('snowflake-snowpark-python') >>> >>> @sproc(name="my_copy_sp", replace=True) ... def my_copy(session: snowflake.snowpark.Session, from_table: str, to_table: str, count: int) -> str: ... session.table(from_table).limit(count).write.save_as_table(to_table) ... return "SUCCESS" >>> _ = session.sql("create or replace table test_from(test_str varchar) as select randstr(20, random()) from table(generator(rowCount => 100))").collect() >>> _ = session.sql("drop table if exists test_to").collect() >>> session.call("my_copy_sp", "test_from", "test_to", 10) 'SUCCESS' >>> session.table("test_to").count() 10 Example:: >>> from snowflake.snowpark.dataframe import DataFrame >>> >>> @sproc(name="my_table_sp", replace=True) ... def my_table(session: snowflake.snowpark.Session, x: int, y: int, col1: str, col2: str) -> DataFrame: ... return session.sql(f"select {x} as {col1}, {y} as {col2}") >>> session.call("my_table_sp", 1, 2, "a", "b").show() ------------- |"A" |"B" | ------------- |1 |2 | ------------- )r^r`r~is_return_tabler)_call)r rTr^r`r~rarres rcallz Session.callMs9ztzz   .-,  r)r^r~rarc 6|j|g||d|||dS)aCalls a stored procedure by name asynchronously and returns an AsyncJob. It is equivalent to ``call(block=False)``. Args: sproc_name: The name of stored procedure in Snowflake. args: Arguments should be basic Python types. statement_params: Dictionary of statement level parameters to be set while executing this action. log_on_exception: Log warnings if they arise when trying to determine if the stored procedure as a table return type. return_dataframe: When set to True, the return value of this function is a DataFrame object. This is useful when the given stored procedure's return type is a table. Returns: An AsyncJob object that can be used to retrieve results or check status. Example:: >>> import snowflake.snowpark >>> from snowflake.snowpark.functions import sproc >>> import time >>> >>> session.add_packages('snowflake-snowpark-python') >>> >>> @sproc(name="simple_add_sp", replace=True) ... def simple_add(session: snowflake.snowpark.Session, a: int, b: int) -> int: ... return a + b >>> async_job = session.call_nowait("simple_add_sp", 1, 2) >>> while not async_job.is_done(): ... time.sleep(1.0) >>> async_job.is_done() True >>> async_job.is_failed() False >>> async_job.status() 'SUCCESS' >>> result = async_job.result() >>> print(result) 3 Fr_)re)r rTr^r~rarres r call_nowaitzSession.call_nowaits9btyy   .--  r)r^rcr~rr`rccTd}|r!|jj}t|jj|} || j j jjj_|D]&} t| jj| (|A|D]<} | jj} | | _ t| j|| >|| j j j_|jj#|t%|j&t(r"|j&j*|g|||ddSt-|t/||g|} ||j0|g|d|i}|j3| |||||S)a Private implementation of session.call Args: sproc_name: The name of stored procedure in Snowflake. args: Arguments should be basic Python types. statement_params: Dictionary of statement level parameters to be set while executing this action. is_return_table: When set to a non-null value, it signifies whether the return type of sproc_name is a table return type. This skips infer check and returns a dataframe with appropriate sql call. NF)rr^rr~)rrrcr`r^ast_stmtr~)rrFr4rG apply_exprrWstored_procedurer name_flatr0pos_argsrrqrrr~revalrrorrernrLr^_execute_sproc_internal)r rTr^rcr~rr`rerJrGrZr2entryrrs rrdz Session._calls* ??'')D$TYY%9%94@D@JDGG $ $ ) ) . . 8 8 = E*4==+<+<+>D E+)NA OO//1E EH.uxx9I!9LMN?ODGG $ $ 5 5 ; OO  & d++-L M-4((--!1   Z(+D*DtD  "9d99!4DO+++-- ,  rz0.7.0z'Use `Session.table_function()` instead.z#Use :meth:`table_function` instead.)rjextra_warning_textextra_doc_stringinputouter recursivemodec  t|d}|r|jj}t|jj |}t |j||||j_ ||_ ||_ |jdk(rd|j_n6|jdk(rd|j_nd|j_t#|j$t&r8|j$j(ry|j$j+dt,t#|t.r t1|}t3|t5t7|j8||||||} t;| d| S)a Creates a new :class:`DataFrame` by flattening compound values into multiple rows. The new :class:`DataFrame` will consist of the following columns: - SEQ - KEY - PATH - INDEX - VALUE - THIS References: `Snowflake SQL function FLATTEN `_. Example:: df = session.flatten(parse_json(lit('{"a":[1,2]}')), "a", False, False, "BOTH") Args: input: The name of a column or a :class:`Column` instance that will be unseated into rows. The column data must be of Snowflake data type VARIANT, OBJECT, or ARRAY. path: The path to the element within a VARIANT data structure which needs to be flattened. The outermost element is to be flattened if path is empty or ``None``. outer: If ``False``, any input rows that cannot be expanded, either because they cannot be accessed in the ``path`` or because they have zero fields or entries, are completely omitted from the output. Otherwise, exactly one row is generated for zero-row expansions (with NULL in the KEY, INDEX, and VALUE columns). recursive: If ``False``, only the element referenced by ``path`` is expanded. Otherwise, the expansion is performed for all sub-elements recursively. mode: Specifies which types should be flattened "OBJECT", "ARRAY", or "BOTH". Returns: A new :class:`DataFrame` that has the flattened new columns and new rows from the compound data. Example:: >>> from snowflake.snowpark.functions import lit, parse_json >>> session.flatten(parse_json(lit('{"a":[1,2]}')), path="a", outer=False, recursive=False, mode="BOTH").show() ------------------------------------------------------- |"SEQ" |"KEY" |"PATH" |"INDEX" |"VALUE" |"THIS" | ------------------------------------------------------- |1 |NULL |a[0] |0 |1 |[ | | | | | | | 1, | | | | | | | 2 | | | | | | |] | |1 |NULL |a[1] |1 |2 |[ | | | | | | | 1, | | | | | | | 2 | | | | | | |] | ------------------------------------------------------- See Also: - :meth:`DataFrame.flatten`, which creates a new :class:`DataFrame` by exploding a VARIANT column of an existing :class:`DataFrame`. - :meth:`Session.table_function`, which can be used for any Snowflake table functions, including ``flatten``. NOBJECTTARRAYzSession.flattenrrU)rUrrFr4rGflattenr0rsr:rrtrurVrvflatten_mode_objectflatten_mode_arrayflatten_mode_bothrrrrXrrr rr|r,r*rmrD) r rsr:rtrurvrrJrGrs rrzzSession.flatten sBN 4  ??'')D$TYY%6%6=D &tzz5 9"& DJ&DNzz|x'04 -(/3 ,.2 + djj"6 7zz99 22*; 33 eS !JE   ! 1 14 4P    B 12 rinclude_describeinclude_thread_id include_errorinclude_dataframe_profilingcZt|||||}|jj||S)aCreate an instance of :class:`QueryHistory` as a context manager to record queries that are pushed down to the Snowflake database. Args: include_describe: Include query notifications for describe queries include_thread_id: Include thread id where queries are called include_error: record queries that have error during execution >>> with session.query_history(True) as query_history: ... df = session.create_dataframe([[1, 2], [3, 4]], schema=["a", "b"]) ... df = df.filter(df.a == 1) ... res = df.collect() >>> assert len(query_history.queries) == 2 >>> assert query_history.queries[0].is_describe >>> assert not query_history.queries[1].is_describe )rradd_query_listener)r r~rrrquery_listeners r query_historyzSession.query_history|s7,&     '   %%n5rcTt||}|jj||S)a Creates an instance of :class:`AstListener` as a context manager to capture ast batches flushed. Returns: AstListener instance holding base64 encoded batches. Args: include_error: Include ast objects that may have failed previous execution. )rrr)r rals r ast_listenerzSession.ast_listeners'} - %%b) rraw_table_namecrt|}t|jtr%|jjj |St |dk(r"|jdt|dd}nt |dk(r'|jdt|dd|d}nut |dk(rC|ddk(r d |dd n d |dd |d}|jdt|dd |}n$tjd j||d uxrt |dkDS)r6rzshow tables like 'rr8r)z ' in schema rrzschema z.PUBLICrz' in N) r7rrrentity_registryis_existing_tablerrrkr5GENERAL_INVALID_OBJECT_NAMEr)r rqualified_table_nametables conditions rrzSession._table_existss $N3 djj"6 7::--??@TU U'(A-()\]qrs]t)u(vvwx)*a/()\]qrs]t)u(vwCDXYZD[C\])*a/,A."42156g>"#7#:";1=QRS=T>r\rstringbooleanrWfloatrc |j5|}||jvr/tttt t t d}t|}trttj}d|}|j|djd|jjt |dddt"|dt$j&j)t }nt }|j*j-||||ttgdd gddd }||j|<|j|cd d d S#1swYy xYw) a3 Get or register an XPath UDF for the specified return type. This function manages UDF registration for XPath evaluation. It uses session-level caching to avoid re-registering the same UDF multiple times. The cache is stored in the session object for thread safety. rz create temp stage if not exists FrT)rkrlrnrdrzlxml<6)r\ input_typesrrXrrN)rrrrrrrrQrcrjrSrrcollectrrtrPrNrIr:rrr?register_from_file) r r\ cache_keyreturn_type_map handler_name temp_stagesql_create_temp_stagepython_file_path xpath_udfs r_get_or_register_xpath_udfz"Session._get_or_register_xpath_udfsu ' '5 4#I 5 55'z|4(l*}&=&[ # 1= *+"=^=Q=Q!RJ::,G*HH2eHDLL"'MJJ**0"&+"&59 ++7 |1RWWEUEUVnEoDp'q$'?$!HH77$ / Unified internal executor for sync/async, table/scalar SPROCs.)rqueryIdrSr])rEz Session.callF)r^rr) r'execute_async_and_notify_query_listenerrwrxROWCOUNTexecute_and_get_sfqidrr rDr) r rrrcr`r^rir~results_cursorqidrs rrozSession._execute_sproc_internals!ZZOO)9PNy)(7 $$!1  >N=S=S!1   **22(83C/4IB N 3I%84B N 3::/?5:QRSTUVW Wrr c|jtr|n t|}d}|rA|jj}t |j j |}||_|jd|d||S)a Returns a DataFrame representing the results of a directory table query on the specified stage. A directory table query retrieves file-level metadata about the data files in a Snowflake stage. This includes information like relative path, file size, last modified timestamp, file URL, and checksums. Note: The stage must have a directory table enabled for this method to work. The query is executed lazily, which means the SQL is not executed until methods like :func:`DataFrame.collect` or :func:`DataFrame.to_pandas` evaluate the DataFrame. Args: stage_name: The name of the stage to query. The stage name should not include the '@' prefix as it will be added automatically. Returns: A DataFrame containing metadata about files in the stage with the following columns: - ``RELATIVE_PATH``: Path to the files to access using the file URL - ``SIZE``: Size of the file in bytes - ``LAST_MODIFIED``: Timestamp when the file was last updated in the stage - ``MD5``: MD5 checksum for the file - ``ETAG``: ETag header for the file - ``FILE_URL``: Snowflake file URL to access the file Examples:: >>> # Get all file metadata from a stage named 'test_stage' >>> _ = session.sql("CREATE OR REPLACE TEMP STAGE test_stage DIRECTORY = (ENABLE = TRUE)").collect() >>> _ = session.file.put("tests/resources/testCSV.csv", "@test_stage", auto_compress=False) >>> _ = session.file.put("tests/resources/testJson.json", "@test_stage", auto_compress=False) >>> _ = session.sql("ALTER STAGE test_stage REFRESH").collect() >>> # List all files in the stage >>> df = session.directory('test_stage') >>> df.count() 2 >>> # Get file URLs for CSV files only >>> csv_files = session.directory('test_stage').filter( ... col('RELATIVE_PATH').like('%.csv%') ... ).select('RELATIVE_PATH') >>> csv_files.show() ------------------- |"RELATIVE_PATH" | ------------------- |testCSV.csv | ------------------- For details, see the Snowflake documentation on `Snowflake Directory Tables Documentation `_ NzSELECT * FROM DIRECTORY(r*rU) rHrNrrFr4rG directoryr r)r r rrJrKs rrzSession.directoryCsn$$\2  >*.   ??'')D#DII$7$7>C'CNxx&zl! 4  rcd}|rM|jj}t|jj|}|||j _d|rd|znd}|j|||jdy)a Begins a new transaction in the current session. Args: name: Optional string that assigns a name to the transaction. A name helps identify a transaction, but is not required and does not need to be unique. Example:: >>> # Begin an anonymous transaction >>> session.begin_transaction() >>> # Begin a named transaction >>> session.begin_transaction("my_transaction") NzBEGIN TRANSACTION zNAME rrUFr) rrFr4rGbegin_transactionrrrr)r rrrJrKrrs rrzSession.begin_transactionsz& ??'')D#DII$?$?FC!%$gn2$FG $)<DDuDUrcd}|r:|jj}t|jj||j d||j dy)z Commits an open transaction in the current session. Example:: >>> session.begin_transaction() >>> session.commit() NCOMMITrUFr)rrFr4rGcommitrrr rrJs rrzSession.commitsS ??'')D dii.. 5 TY?GGRWGXrcd}|r:|jj}t|jj||j d||j dy)z Rolls back an open transaction in the current session. Example:: >>> session.begin_transaction() >>> session.rollback() NROLLBACKrUFr)rrFr4rGrollbackrrrs rrzSession.rollbacksX ??'')D dii00$ 7 tyAII J rrrS)Ni F)NF)NTFNN)TN)r)FT)NNT)rr~)rr)FTN)NNTFFFNr)NT)NrT)NFFBOTHT)FFFFrT)NNF)T)rrrrVr"rOrY__annotations__rrCrrrr r r r rrrrrrr!rzrWrrrr classmethodrgetActiveSessionrZrrrrrsetterr[rrrr rr r rrrrrr9rErMrP staticmethodrBr}rrorrrrrrrrrrrrrrrrrr(r.r>rer=rhrrrrrr rrFr|r`ryrgrprotoBindrryr{r:rr#rrrr!rrrrrr rwrrrrrrrrrr(r*r,r.r2r'r@rrrrDrr?rrGrrIrrArrLrvr6rNrrPrrRr^rergrdrXrzrrrrrrrrYrorrrrrrrrrosB..`A,A,J-.G^. -1p-$&:MIJp-$sCx.)p-  p-d  $   S  T  ((  +8 + +8I#6* (# $ &2m,,,   T    H-11$1.1..$.. >$>> 6$ 6 63t33=sCx== 3t 3 38D88  ) ) )%1T%1%1N"" 1D 1T 1# 1$$3d3t3%3.44H-dt.5"&,,H-dt.-"#))H-4D.**-33BU38_BQUB4B*#))H- 4 D .* (../%++Td, !''G,$4-( 3T#Y3&* % P@P@c]P@ P@  P@  P@d1#1$1>'&* % ?,?,c]?,?, ?, sHSM8C=0 1 ?,?,N  O$6:O$O$"%O$!) eHSM8C=899 :! O$#4S>2O$ cO$f)-B6: B  B#4S>2 B S B& ) )cSVh )".2E j(5j3I*JJKE &c]E   E T.2)O)O&c])O  )OZ.2 '%c] '  '".2:M:M&c]:M  :Mx'">CI$"3xI$7;I$ I$#I$V!uS*_-.! c5dK/00 1!!R6:05o#3c4&< ==>o#o# o# sCx. o# #4S>2 o#*.o# k o#b eCO,- <@cN  c  <@!%$59-1yuS*_-.y!)c3h 8y y  y #4S>2 y&c]y cyv^9s)^9^938n ^9 &*#s(^ ^9 k  ^9@XXG#%(G#69G# k G#Z"&59 *Cy* * * #4S>2 * c49n  *:8C=."S"T""(s( )%C)%C)%$)%V&D&T&P+0 b ?C#' $=ABF $bC#&'b$(b b #7>#:; bC=b bE#x'8'8"89:b!s,='=!>?b b bbH  od3i#s();=NNOo&o o !- o  oob vvv v  v  vvp+/ $ QQ#'Q:: Q  Q  QQf%%  C    ',!%59   $   #4S>2  c CGEE(0#(?E iE6:6"4S>26 6<(# #' $$:!)',"&"'DF+/#eee 3- e  eSMeee!%ee e ee@Ae #4.!e"#e$sCx.%e& 'e$e^#' $"&"'.2DFJ  # J  J J 3-J  J  J  J J J l+J @AJ !J X#' $$;!)"&"'"'DF+/',-O  # OO3-O OSMOOOO O  !O" #O$%O&@A'O(#4.)O*!%+O,-O.sCx./O0 1OObCG WD%!3_DEWz8C=#=>?W W sCx. W  WWr" 66c]6 6  6  66p....x}> 9(3-9 /S/T/+++1s1t1'S'T'  '-2H)I  d  LsLLL05455( : :m&_&&'&'''&''%2%%!+B!!X&0&"50&'0&d"k""($5((EJ""&)"=A" "H 6:!&+/D D D #4S>2 D  D  D #4.D D  sH} D D L 6:!&+/8 8 8 #4S>2 8  8 #4. 8 8  8 8 |6:*.!&< < < #4S>2 < "$ <  < < <  sH} < |D> #ggsmg g  g  gg g  gV"'"'#,1    &*   @ $ ; ):HSM):VCHSM@4"#OP@4 @4D'O6:!&"X"X"X "X #4S>2 "X"X sH} "XHE CE DE IE N<@VSMV59V VV8YYYY  $ $  rrU)rrrN)rrrr(=rrrrr#rIrrrrr collectionsr functoolsrloggingr threadingrtypesrtypingr r r r r rrrrrrrrimportlib.metadatarpackaging.requirementsrpackaging.versionrr4snowflake.snowpark._internal.proto.generated.ast_pb2rrr generatedast_pb2snowflake.snowpark.contextrsnowflake.connectorrrsnowflake.connector.optionsrrr snowflake.connector.pandas_toolsrsnowflake.snowparkr%snowflake.snowpark._internal.analyzerr.snowflake.snowpark._internal.analyzer.analyzerrrr r!5snowflake.snowpark._internal.analyzer.datatype_mapperr"0snowflake.snowpark._internal.analyzer.expressionr#6snowflake.snowpark._internal.analyzer.select_statementr$r%r&4snowflake.snowpark._internal.analyzer.snowflake_planr'9snowflake.snowpark._internal.analyzer.snowflake_plan_noder(r)4snowflake.snowpark._internal.analyzer.table_functionr*r+r,6snowflake.snowpark._internal.analyzer.unary_expressionr-&snowflake.snowpark._internal.ast.batchr.&snowflake.snowpark._internal.ast.utilsr/r0r1r2r3r4*snowflake.snowpark._internal.error_messager52snowflake.snowpark._internal.event_table_telemetryr6,snowflake.snowpark._internal.packaging_utilsr7r8r9r:r;r<r=r>r?r@rArB.snowflake.snowpark._internal.server_connectionrC&snowflake.snowpark._internal.telemetryrD4snowflake.snowpark._internal.temp_table_auto_cleanerrE'snowflake.snowpark._internal.type_utilsrFrGrHrIrJrK&snowflake.snowpark._internal.udf_utilsrL"snowflake.snowpark._internal.utilsrMrNrOrPrQrRrSrTrUrVrWrXrYrZr[r\r]r^r_r`rarbrcrdrerfrgrhrirjrkrlrmrnrorprqrrrsrtrurvsnowflake.snowpark.async_jobrwrxsnowflake.snowpark.columnryrzr{snowflake.snowpark.dataframer|#snowflake.snowpark.dataframe_readerr~snowflake.snowpark.exceptionsrr!snowflake.snowpark.file_operationrsnowflake.snowpark.functionsrrrrrrrrrrrrrrrrsnowflake.snowpark.lineager!snowflake.snowpark.mock._analyzerrrlr%snowflake.snowpark.mock._nop_analyzerr'snowflake.snowpark.mock._nop_connectionr$snowflake.snowpark.mock._pandas_utilrr%snowflake.snowpark.mock._plan_builderr)snowflake.snowpark.mock._stored_procedurersnowflake.snowpark.mock._udafrsnowflake.snowpark.mock._udfrsnowflake.snowpark.mock._udtfr snowflake.snowpark.query_historyrrsnowflake.snowpark.rowr#snowflake.snowpark.stored_procedurer,snowflake.snowpark.stored_procedure_profilerr%snowflake.snowpark.dataframe_profilerrsnowflake.snowpark.tabler!snowflake.snowpark.table_functionrrsnowflake.snowpark.typesrrrrrrrrrrrrrrrrrrrrrsnowflake.snowpark.udafrsnowflake.snowpark.udfrsnowflake.snowpark.udtfr modin.pandasr]r version_inforcollections.abcrrrrrrrsrxr}rr{rrrrrr+_PYTHON_SNOWPARK_ENABLE_THREAD_SAFE_SESSIONrrtrrrrrrrrrrrrrWrrrrrrrrrrrsm  #    .4DDD,,EII9*@CMF V H;WR    LFUO+++++++++++XD,3?<$/:D=AKU><>F&KPC*.542244:: v(( H  7#&5#i.(-0.R*;> 003.?:?:4/E@C>C> 1, A< 9472$E 0,1,/V+84-W)5).&(2$'1$)?)AvtK(>(@fdJNNc)nN& ZI ZI r