к Ї╙g─<ЦСІ≈UddlmZddlZddlZddlmZmZmZmZm Z m Z ddlmZm Z mZmZddlmZddlmZddlmZddlmZdd lmZerdd lmZe eed°Zej:d╚Zd dddddd°Zde d<e dee╛╚Z!ed╚ d# d$d└╚Z"d%d└Z#e d& d'd└╚Z$e d& d(d└╚Z$e d& d)d└╚Z$e d& d*d└╚Z$e d# d+d└╚Z$e d# d,d└╚Z$e d# d-d └╚Z$e d. d/d!└╚Z$ d.d"└Z$y)0И)зannotationsN)з TYPE_CHECKINGзAnyзFinalзLiteralзTypeVarзoverload)зBaseConnectionзSnowflakeConnectionзSnowparkConnectionз SQLConnection)зdeprecate_obj_name)зStreamlitAPIException)зcache_resource)зgather_metrics)зsecrets_singleton)з timedelta)з snowflakeзsnowparkзsqlzNo module named \'(.+)\'зmysqlclientzpsycopg2-binaryз sqlalchemyzsnowflake-connector-pythonzsnowflake-snowpark-python)зMySQLdbзpsycopg2rrzsnowflake.connectorzsnowflake.snowparkzFinal[dict[str, str]]зMODULES_TO_PYPI_PACKAGESзConnectionClass)зboundз connectioncСЖ≈ dd└}t|t╚st|⌡d²╚┌t|╚j dd╚}|j ⌡d|⌡d|⌡²|_t |d|╛╚|╚}|||fi|є▌S)apCreate an instance of connection_class with the given name and kwargs. The weird implementation of this function with the @cache_resource annotated function defined internally is done to: - Always @gather_metrics on the call even if the return value is a cached one. - Allow the user to specify ttl and max_entries when calling st.connection. cС≈|dd|i|є▌S)Nзconnection_name╘r")зnameзconnection_classзkwargss ЗY/var/www/openai/venv/lib/python3.12/site-packages/streamlit/runtime/connection_factory.pyз__create_connectionz/_create_connection..__create_connectionNs─Я я?╟п?╦я?п?Сz% is not a subclass of BaseConnection!з.з_zRunning `st.connection(...)`.)зmax_entriesзshow_spinnerзttl)r#зstrr$Зtype[ConnectionClass]зreturnr)з issubclassr rr.зreplaceз__qualname__r)r#r$r+r-r%r'зttl_strs r&з_create_connectionr5>sю─П @ьП@ь%:П@Ю С@Т п&╛т7э#ьп п EпFС П Т░#▀hвяь┬SС─GПв+я+п ,╗A╗g╗Y╟a╦╟}пEПт$П°.ьь4ьТПС пЯ≤tп%5я@╦я@п@r(cСN≈|tvr t|Std|⌡dt⌡²╚┌)NzInvalid connection 'z!'. Supported connection classes: )зFIRST_PARTY_CONNECTIONSr)r$s r&з_get_first_party_connectionr8js>─ьт2я2э&п'7я8п8Д ь п/п0П1)э)@п(AП CСПr(cС≈y╘Nr"╘r#r+r-з autocommitr%s r&зconnection_factoryr=tС─П r(cС≈yr:r"╘r#зtyper+r-r<r%s r&r=r=С─П r(cС≈yr:r"r;s r&r=r=▀r>r(cС≈yr:r"r@s r&r=r=√rBr(cС≈yr:r")r#r+r-r%s r&r=r=╒s─П r(cС≈yr:r"╘r#rAr+r-r%s r&r=r=╛r>r(cС≈yr:r"rGs r&r=r=Їr>r(cС≈yr:r"rGs r&r=r=бr>r(cС"≈d}|j|╚r!|t|╚d}tj|}|─7|tvrt|╚}n#t j╚td|d}|}t|t╚rad|vrR|jd╚}|j╚} ddl} | jdj|╚╚}t|| ╚}nt|╚} t!||f||d°|є▌}t|t"╚rt%|dd d ╚}|S#t&$rs} t| ╚}t)j*t,|╚}d}|r,t.j1|j3d╚╚}|rd |⌡d²}t't| ╚⌡d|⌡²╚┌d} ~ wwxYw)a6Create a new connection to a data store or API, or return an existing one. Configuration options, credentials, and secrets for connections are combined from the following sources: - The keyword arguments passed to this command. - The app's ``secrets.toml`` files. - Any connection-specific configuration files. The connection returned from ``st.connection`` is internally cached with ``st.cache_resource`` and is therefore shared between sessions. Parameters ---------- name : str The connection name used for secrets lookup in ``secrets.toml``. Streamlit uses secrets under ``[connections.]`` for the connection. ``type`` will be inferred if ``name`` is one of the following: ``"snowflake"``, ``"snowpark"``, or ``"sql"``. type : str, connection class, or None The type of connection to create. This can be one of the following: - ``None`` (default): Streamlit will infer the connection type from ``name``. If the type is not inferrable from ``name``, the type must be specified in ``secrets.toml`` instead. - ``"snowflake"``: Streamlit will initialize a connection with |SnowflakeConnection|_. - ``"snowpark"``: Streamlit will initialize a connection with |SnowparkConnection|_. This is deprecated. - ``"sql"``: Streamlit will initialize a connection with |SQLConnection|_. - A string path to an importable class: This must be a dot-separated module path ending in the importable class. Streamlit will import the class and initialize a connection with it. The class must extend ``st.connections.BaseConnection``. - An imported class reference: Streamlit will initialize a connection with the referenced class, which must extend ``st.connections.BaseConnection``. .. |SnowflakeConnection| replace:: ``SnowflakeConnection`` .. _SnowflakeConnection: https://docs.streamlit.io/develop/api-reference/connections/st.connections.snowflakeconnection .. |SnowparkConnection| replace:: ``SnowparkConnection`` .. _SnowparkConnection: https://docs.streamlit.io/develop/api-reference/connections/st.connections.snowparkconnection .. |SQLConnection| replace:: ``SQLConnection`` .. _SQLConnection: https://docs.streamlit.io/develop/api-reference/connections/st.connections.sqlconnection max_entries : int or None The maximum number of connections to keep in the cache. If this is ``None`` (default), the cache is unbounded. Otherwise, when a new entry is added to a full cache, the oldest cached entry is removed. ttl : float, timedelta, or None The maximum number of seconds to keep results in the cache. If this is ``None`` (default), cached results do not expire with time. **kwargs : any Connection-specific keyword arguments that are passed to the connection's ``._connect()`` method. ``**kwargs`` are typically combined with (and take precendence over) key-value pairs in ``secrets.toml``. To learn more, see the specific connection's documentation. Returns ------- Subclass of BaseConnection An initialized connection object of the specified ``type``. Examples -------- **Example 1: Inferred connection type** The easiest way to create a first-party (SQL, Snowflake, or Snowpark) connection is to use their default names and define corresponding sections in your ``secrets.toml`` file. The following example creates a ``"sql"``-type connection. ``.streamlit/secrets.toml``: >>> [connections.sql] >>> dialect = "xxx" >>> host = "xxx" >>> username = "xxx" >>> password = "xxx" Your app code: >>> import streamlit as st >>> conn = st.connection("sql") **Example 2: Named connections** Creating a connection with a custom name requires you to explicitly specify the type. If ``type`` is not passed as a keyword argument, it must be set in the appropriate section of ``secrets.toml``. The following example creates two ``"sql"``-type connections, each with their own custom name. The first defines ``type`` in the ``st.connection`` command; the second defines ``type`` in ``secrets.toml``. ``.streamlit/secrets.toml``: >>> [connections.first_connection] >>> dialect = "xxx" >>> host = "xxx" >>> username = "xxx" >>> password = "xxx" >>> >>> [connections.second_connection] >>> type = "sql" >>> dialect = "yyy" >>> host = "yyy" >>> username = "yyy" >>> password = "yyy" Your app code: >>> import streamlit as st >>> conn1 = st.connection("first_connection", type="sql") >>> conn2 = st.connection("second_connection") **Example 3: Using a path to the connection class** Passing the full module path to the connection class can be useful, especially when working with a custom connection. Although this is not the typical way to create first party connections, the following example creates the same type of connection as one with ``type="sql"``. Note that ``type`` is a string path. ``.streamlit/secrets.toml``: >>> [connections.my_sql_connection] >>> url = "xxx+xxx://xxx:xxx@xxx:xxx/xxx" Your app code: >>> import streamlit as st >>> conn = st.connection( ... "my_sql_connection", type="streamlit.connections.SQLConnection" ... ) **Example 4: Importing the connection class** You can pass the connection class directly to the ``st.connection`` command. Doing so allows static type checking tools such as ``mypy`` to infer the exact return type of ``st.connection``. The following example creates the same connection as in Example 3. ``.streamlit/secrets.toml``: >>> [connections.my_sql_connection] >>> url = "xxx+xxx://xxx:xxx@xxx:xxx/xxx" Your app code: >>> import streamlit as st >>> from streamlit.connections import SQLConnection >>> conn = st.connection("my_sql_connection", type=SQLConnection) zenv:NзconnectionsrAr)r)r+r-zconnection("snowpark")zconnection("snowflake")z 2024-04-01z@You may be missing a dependency required to use this connection.ИzYou need to install the 'z!' package to use this connection.z. )з startswithзlenзosзenvironr7r8rзload_if_toml_existsз isinstancer.зsplitзpopз importlibз import_moduleзjoinзgetattrr5rrзModuleNotFoundErrorзreзsearchзMODULE_EXTRACTION_REGEXrзgetзgroup)r#rAr+r-r%зUSE_ENV_PREFIXзenvvar_namer$зpartsз classnamerUзconnection_moduleзconnзeз err_stringзmissing_moduleз extra_infoзpypi_packages r&r=r=мsґ─ПJ─NЮ┤│░~т&П°3≤~с.п0п1┬э▐z┴z≤+я&┬Ю─|ьт*я*Т/╗tс4┴DТ в1я1т3э$═]я3╟Dя9╦&яA┬DП пДп"єCт(П п"я"ь$в*я*╗3с/┬Eь÷ ≥ ⌡┬IЦЮ )в 7я 7╦©╧ю╩с Hпэ&п'8╦)сDяД:п;KсLпП=э!ьп"П ь0;юЯ ьHNЯ ┬Т░dт.т/э%ьь(ь)ьС ┬DП┬ЬэР =э≤⌠V┬ э÷≥т#:╦JсG┬ЮW┬ ыэ3в7я7╦в8Lя8LхQс8OсP┬Lыь8╦╦пFgпh░ Д!єS╗ёV═H╗B╗z╗lп";с<п<ШП =Зsц"/Dд FдA.F ф F)NN) r#r.r$r/r+З int | Noner-Зfloat | timedelta | Noner0r)r$r.)NNF) r#ЗLiteral['sql']r+rjr-rkr<зboolr0r )r#r.rArlr+rjr-rkr<rmr0r ) r#ЗLiteral['snowflake']r+rjr-rkr<rmr0r)r#r.rArnr+rjr-rkr<rmr0r)r#ЗLiteral['snowpark']r+rjr-rkr0r) r#r.rAror+rjr-rkr0r) r#r.rAr/r+rjr-rkr0r)NNN) r#r.rAz str | Noner+rjr-rkr0zBaseConnection[Any])%з __future__rrOrZзtypingrrrrrr зstreamlit.connectionsr rrr зstreamlit.deprecation_utilrзstreamlit.errorsrзstreamlit.runtime.cachingrзstreamlit.runtime.metrics_utilrзstreamlit.runtime.secretsrзdatetimerr7зcompiler\rз__annotations__rr5r8r=r"r(r&зr{sjПЖ#Ц ш ъHвHВСУ:щ2щ4щ9щ7Ащ"П%ь"ьЯпП %≤"÷*≥*п%@сAпЮь!ьь-ь7ь5Я 3пп/СЯп+╟>ю#я3FтG─Я░сП#ь$(П (Aь П(AЮ+П(AПП(AП "П (AПР (AСП(AСVП П#ь$(ьП ь П ЮП П "П ПП ПР С П П П#ь$(ьП ь П Ю П ПП П "П П П ПР С П П П#ь$(ьП ь П ЮП П "П ПП ПР С П П П#ь$(ьП ь П Ю П ПП П "П П П ПР С П П П#ь$(П ь П ЮП П "П П Р С П П П#ь$(П ь П Ю П ПП П "П ПР С П П П#ь$(П ь П Ю П ПП П "П ПР С П П Пь"ь$(П ь П Ю П ПП П "П ПР С П П ььТ g=r(