o h<@sUddlmZddlZddlZddlmZmZmZmZm Z m Z ddl m Z m Z mZmZddlmZddlmZddlmZddlmZdd lmZerQdd lmZe eed Zed Zd ddddddZde d<e de edZ!ed  d;dd?d*d+Z$e   %d>d@d-d+Z$e   %d>dAd0d+Z$e   %d>dBd1d+Z$e  d;dCd4d+Z$e  d;dDd5d+Z$e  d;dEd6d+Z$e   dFdGd9d+Z$   dFd:d+Z$dS)H) annotationsN) TYPE_CHECKINGAnyFinalLiteralTypeVaroverload)BaseConnectionSnowflakeConnectionSnowparkConnection SQLConnection)deprecate_obj_name)StreamlitAPIException)cache_resource)gather_metrics)secrets_singleton) timedelta) snowflakesnowparksqlzNo module named \'(.+)\' mysqlclientzpsycopg2-binary sqlalchemyzsnowflake-connector-pythonzsnowflake-snowpark-python)MySQLdbpsycopg2rrzsnowflake.connectorzsnowflake.snowparkzFinal[dict[str, str]]MODULES_TO_PYPI_PACKAGESConnectionClass)bound connectionnamestrconnection_classtype[ConnectionClass] max_entries int | Nonettlfloat | timedelta | NonereturncKsnddd}t|tst|d t|d d }|jd |d ||_t|d |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. rrr r!r&rc[s|dd|i|S)Nconnection_namer()rr kwargsr(r(X/var/www/vscode/kcb/lib/python3.10/site-packages/streamlit/runtime/connection_factory.py__create_connectionNsz/_create_connection..__create_connectionz% is not a subclass of BaseConnection!._zRunning `st.connection(...)`.)r" show_spinnerr$N)rrr r!r&r) issubclassr rrreplace __qualname__r)rr r"r$r)r+ttl_strr(r(r*_create_connection>s$  r3cCs$|tvrt|Std|dt)NzInvalid connection 'z!'. Supported connection classes: )FIRST_PARTY_CONNECTIONSr)r r(r(r*_get_first_party_connectionjsr5FLiteral['sql'] autocommitboolr cKdSNr(rr"r$r7r)r(r(r*connection_factorytr<typecKr9r:r(rr>r"r$r7r)r(r(r*r< Literal['snowflake']r cKr9r:r(r;r(r(r*r<r=cKr9r:r(r?r(r(r*r<r@Literal['snowpark']r cKr9r:r()rr"r$r)r(r(r*r<scKr9r:r(rr>r"r$r)r(r(r*r<r=cKr9r:r(rCr(r(r*r<r= str | NoneBaseConnection[Any]cKr9r:r(rCr(r(r*r<r=c KsPd}||r|t|d}tj|}|dur-|tvr!t|}n ttd|d}|}t|t rWd|vrS| d}| } ddl } | d|} t| | }nt|}zt||f||d|} t| trpt| dd d } | WSty} z)t | }tt|}d }|rt|d }|rd |d}tt | d|d} ~ ww)a5Create 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 connectionsr>r,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. ) startswithlenosenvironr4r5rload_if_toml_exists isinstancersplitpop importlib import_modulejoingetattrr3r r ModuleNotFoundErrorresearchMODULE_EXTRACTION_REGEXrgetgroup)rr>r"r$r)USE_ENV_PREFIX envvar_namer parts classnamerPconnection_moduleconne err_stringmissing_module extra_info pypi_packager(r(r*r<s\%         )NN) rrr r!r"r#r$r%r&r)r r)NNF) rr6r"r#r$r%r7r8r&r ) rrr>r6r"r#r$r%r7r8r&r ) rrAr"r#r$r%r7r8r&r ) rrr>rAr"r#r$r%r7r8r&r )rrBr"r#r$r%r&r ) rrr>rBr"r#r$r%r&r ) rrr>r!r"r#r$r%r&r)NNN) rrr>rDr"r#r$r%r&rE)% __future__rrJrUtypingrrrrrrstreamlit.connectionsr r r r streamlit.deprecation_utilr streamlit.errorsrstreamlit.runtime.cachingrstreamlit.runtime.metrics_utilrstreamlit.runtime.secretsrdatetimerr4compilerWr__annotations__rr3r5r<r(r(r(r*s          +