к ©L iї<ЦСР≈UddlmZddlZddlZddlmZmZmZmZm Z m Z ddlmZm Z mZmZddlmZddlmZddlmZddlmZdd lmZerdd lmZe eed°Zded <ej<d╚Zddddddd°Z ded<dZ!ded<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( d0d#└╚Z%e d( d1d$└╚Z%e d( d2d%└╚Z%e d3 d4d&└╚Z% d3d'└Z%y)5И)з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зsqlz+Final[dict[str, type[BaseConnection[Any]]]]з_FIRST_PARTY_CONNECTIONSzNo module named \'(.+)\'зmysqlclientzpsycopg2-binaryз sqlalchemyzsnowflake-connector-pythonzsnowflake-snowpark-python)зMySQLdbзpsycopg2rrzsnowflake.connectorzsnowflake.snowparkzFinal[dict[str, str]]з_MODULES_TO_PYPI_PACKAGESzenv:rз_USE_ENV_PREFIXз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 Зj/mnt/ssd/data/python-lab/Trading/venv/lib/python3.12/site-packages/streamlit/runtime/connection_factory.pyз__create_connectionz/_create_connection..__create_connectionOs─Я я?╟п?╦я?п?Сz% is not a subclass of BaseConnection!З.з_zRunning `st.connection(...)`.)зmax_entriesзshow_spinnerзttl)r%зstrr&Зtype[ConnectionClass]r'rзreturnr)з issubclassr rr0зreplaceз__qualname__r)r%r&r-r/r'r)зttl_strs r(з_create_connectionr7?sи─П @ьП@ь%:П@ьFIП@Ю С@Т п&╛т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: )rr)r&s r(з_get_first_party_connectionr9ks>─ьт3я3э'п(8я9п9Д ь п/п0П1)э)Aп(BП DСПr*cС≈y╘Nr$╘r%r-r/з autocommitr's r(зconnection_factoryr>uС─П 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$rAs r(r>r>≈rCr*cС≈yr;r$)r%r-r/r's r(r>r>ёs─П r*cС≈yr;r$╘r%rBr-r/r's r(r>r>ґr?r*cС≈yr;r$rHs r(r>r>╦r?r*cС≈yr;r$rHs r(r>r>цr?r*cС"≈|jt╚r(|jt╚}tj|}|}|─7|t vrt |╚}n#tj╚td|d}t|t╚rad|vrR|jd╚}|j╚}ddl } | jdj|╚╚} t!| |╚}nt |╚} t#||f||d°|є▌}t|t$╚rt'|ddd ╚}|S#t($rj}t|╚} t+j,t.| ╚}d }|r,t0j3|j5d╚╚}|rd|⌡d ²}t)|⌡d|⌡²╚┌d}~wwxYw)a3Create 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 inferable 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 precedence 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) NзconnectionsrBr+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. )з startswithrзremoveprefixзosзenvironrr9rзload_if_toml_existsз isinstancer0зsplitзpopз importlibз import_moduleзjoinзgetattrr7rrзModuleNotFoundErrorзreзsearchз_MODULE_EXTRACTION_REGEXrзgetзgroup)r%rBr-r/r'зenvvar_namer&зpartsз classnamerVзconnection_moduleзconnзeз err_stringзmissing_moduleз extra_infoзpypi_packages r(r>r>нsё─ПJ┤│■т'ьв'я'╛с8┬э▐z┴z≤+я&┬П пЮпьт+я+Т ;╦4с@яТ в1я1т3э0╟я?юяEюfяMпДп"єCт(П п"я"ь$в*я*╗3с/┬Eь÷ ≥ ⌡┬IЦЮ )в 7я 7╦©╧ю╩с Hпэ&п'8╦)сDяД:п;KсLпП8э!ьп"П ь0;юЯ ьHNЯ ┬Т░dт.т/э%ьь(ь)ьС ┬DП┬ЬэР 8э≤⌠V┬ э÷≥т#;╦ZсH┬ЮW┬ ыэ4в8я8╦в9Mя9Mхaс9PсQ┬Lыь8╦╦пFgпh░ Д!═Q═C═r╗*╗п"6с7п7ШП 8Зsц+/Dд Fд$A%F ф F)NN)r%r0r&r1r-З int | Noner/Зfloat | timedelta | Noner'rr2r)r&r0r2ztype[BaseConnection[Any]])NNF)r%ЗLiteral['sql']r-rjr/rkr=зboolr'rr2r )r%r0rBrlr-rjr/rkr=rmr'rr2r )r%ЗLiteral['snowflake']r-rjr/rkr=rmr'rr2r)r%r0rBrnr-rjr/rkr=rmr'rr2r) r%ЗLiteral['snowpark']r-rjr/rkr'rr2r)r%r0rBror-rjr/rkr'rr2r)r%r0rBr1r-rjr/rkr'rr2r)NNN)r%r0rBz str | Noner-rjr/rkr'rr2zBaseConnection[Any])&з __future__rrPr[зtypingrrrrrr зstreamlit.connectionsr rrr зstreamlit.deprecation_utilrзstreamlit.errorsrзstreamlit.runtime.cachingrзstreamlit.runtime.metrics_utilrзstreamlit.runtime.secretsrзdatetimerrз__annotations__зcompiler]rrrr7r9r>r$r*r(Зr{sзПЖ#Ц ш ъHвHВСУ:щ2щ4щ9щ7Ащ"П%ь"ьЯIппEСП &≤2÷:≥:п&AсBпЮь!ьь-ь7ь5Я 4пп0СП ─░сЯ п+╟>ю#я3FтG─Я░сП#ь$(П (Aь П(AЮ+П(AПП(AП "П (AП П(AПР (AСП(AСVП П#ь$(ьП ь П ЮП П "П ПП П П ПР С П П П#ь$(ьП ь П Ю П ПП П "П П П ПП ПР С П П П#ь$(ьП ь П ЮП П "П ПП П П ПР С П П П#ь$(ьП ь П Ю П ПП П "П П П ПП ПР С П П П#ь$(П ь П ЮП П "П ПП П Р С П П П#ь$(П ь П Ю П ПП П "П П П ПР С П П П#ь$(П ь П Ю П ПП П "П П П ПР С П П Пь"ь$(П ь П Ю П ПП П "П П П ПР С П П ььТ c8r*