fume-manage-python.git

U  
¸ý°dzã@shdZddlmZddlmZddlZddlmZddlm    Z    ddlm
Z
ddlmZddlmZdd    lm Z dd
lmZddlmZddlmZdd lmZddlmZddlmZddlmZddlmZddlmZddlmZddlmZddlmZddlmZddlmZddlm Z GdddeZ!ddddd Z"d!dd"d#d$Z#d!d!d%d&d'Z$eZ%dS)(aProvides the :class:`~sqlalchemy.engine.url.URL` class which encapsulates
information about a database connection specification.
 
The URL object is created automatically when
:func:`~sqlalchemy.engine.create_engine` is called with a string
argument; alternatively, the URL is a public-facing construct which can
be used directly and is also accepted directly by ``create_engine()``.
é)ÚannotationsN)ÚAny)Úcast)ÚDict)ÚIterable)ÚList)ÚMapping)Ú
NamedTuple)ÚOptional)Úoverload)ÚSequence)ÚTuple)ÚType)ÚUnion)Ú    parse_qsl)Ú
quote_plus)Úunquoteé)ÚDialecté)Úexc)Úutil)Úplugins)Úregistryc@sDeZdZUdZded<ded<ded<ded<ded    <ded
<ded<ed d d d d ejfdddddddddddZedddddZ    eddddddZ
eddddddZedddddZdeddddddddddd Z d!dd"d#d$Zdfdd&dd'd(d)Zdgd*d&dd+d,d-Zdhd.d&dd/d0d1Zd2dd3d4d5Zed6d7d8d9Ze d:d;¡did&dd=d>d?Zdjd&dd=d@dAZdd7dBdCZdd7dDdEZd!ddFdGdHZdId7dJdKZd!d&dLdMdNZd!d&dLdOdPZdd7dQdRZdd7dSdTZdUdVdWdXdYZ dZd7d[d\Z!dkd&dZd]d^d_Z"dld`d!dadbdcddZ#d S)mÚURLa 
    Represent the components of a URL used to connect to a database.
 
    URLs are typically constructed from a fully formatted URL string, where the
    :func:`.make_url` function is used internally by the
    :func:`_sa.create_engine` function in order to parse the URL string into
    its individual components, which are then used to construct a new
    :class:`.URL` object. When parsing from a formatted URL string, the parsing
    format generally follows
    `RFC-1738 <https://www.ietf.org/rfc/rfc1738.txt>`_, with some exceptions.
 
    A :class:`_engine.URL` object may also be produced directly, either by
    using the :func:`.make_url` function with a fully formed URL string, or
    by using the :meth:`_engine.URL.create` constructor in order
    to construct a :class:`_engine.URL` programmatically given individual
    fields. The resulting :class:`.URL` object may be passed directly to
    :func:`_sa.create_engine` in place of a string argument, which will bypass
    the usage of :func:`.make_url` within the engine's creation process.
 
    .. versionchanged:: 1.4
 
        The :class:`_engine.URL` object is now an immutable object.  To
        create a URL, use the :func:`_engine.make_url` or
        :meth:`_engine.URL.create` function / method.  To modify
        a :class:`_engine.URL`, use methods like
        :meth:`_engine.URL.set` and
        :meth:`_engine.URL.update_query_dict` to return a new
        :class:`_engine.URL` object with modifications.   See notes for this
        change at :ref:`change_5526`.
 
    .. seealso::
 
        :ref:`database_urls`
 
    :class:`_engine.URL` contains the following attributes:
 
    * :attr:`_engine.URL.drivername`: database backend and driver name, such as
      ``postgresql+psycopg2``
    * :attr:`_engine.URL.username`: username string
    * :attr:`_engine.URL.password`: password string
    * :attr:`_engine.URL.host`: string hostname
    * :attr:`_engine.URL.port`: integer port number
    * :attr:`_engine.URL.database`: string database name
    * :attr:`_engine.URL.query`: an immutable mapping representing the query
      string.  contains strings for keys and either strings or tuples of
      strings for values.
 
 
    ÚstrÚ
drivernamez Optional[str]ÚusernameÚpasswordÚhostz Optional[int]ÚportÚdatabasez4util.immutabledict[str, Union[Tuple[str, ...], str]]ÚqueryNz'Mapping[str, Union[Sequence[str], str]])rrrrr r!r"Úreturnc
Cs@|| |d¡| |d¡|| |d¡| |¡| |d¡| |¡S)aàCreate a new :class:`_engine.URL` object.
 
        .. seealso::
 
            :ref:`database_urls`
 
        :param drivername: the name of the database backend. This name will
          correspond to a module in sqlalchemy/databases or a third party
          plug-in.
        :param username: The user name.
        :param password: database password.  Is typically a string, but may
          also be an object that can be stringified with ``str()``.
 
          .. note::  A password-producing object will be stringified only
             **once** per :class:`_engine.Engine` object.  For dynamic password
             generation per connect, see :ref:`engines_dynamic_tokens`.
 
        :param host: The name of the host.
        :param port: The port number.
        :param database: The database name.
        :param query: A dictionary of string keys to string values to be passed
          to the dialect and/or the DBAPI upon connect.   To specify non-string
          parameters to a Python DBAPI directly, use the
          :paramref:`_sa.create_engine.connect_args` parameter to
          :func:`_sa.create_engine`.   See also
          :attr:`_engine.URL.normalized_query` for a dictionary that is
          consistently string->list of string.
        :return: new :class:`_engine.URL` object.
 
        .. versionadded:: 1.4
 
            The :class:`_engine.URL` object is now an **immutable named
            tuple**.  In addition, the ``query`` dictionary is also immutable.
            To create a URL, use the :func:`_engine.url.make_url` or
            :meth:`_engine.URL.create` function/ method.  To modify a
            :class:`_engine.URL`, use the :meth:`_engine.URL.set` and
            :meth:`_engine.URL.update_query` methods.
 
        rrrr!)Ú_assert_strÚ_assert_none_strÚ_assert_portÚ    _str_dict)Úclsrrrrr r!r"©r)úLd:\z\workplace\vscode\pyvenv\venv\Lib\site-packages\sqlalchemy/engine/url.pyÚcreates3
 
 
 
ùz
URL.create)r r#cCs8|dkrdSz
t|WStk
r2tdYnXdS)Nz(Port argument must be an integer or None)ÚintÚ    TypeError)r(r r)r)r*r&Òs
zURL._assert_port)ÚvÚ    paramnamer#cCst|tstd||S)Nz%s must be a string©Ú
isinstancerr-©r(r.r/r)r)r*r$Ûs
zURL._assert_strcCs|dkr|S| ||¡S©N)r$r2r)r)r*r%ászURL._assert_none_strziOptional[Union[Sequence[Tuple[str, Union[Sequence[str], str]]], Mapping[str, Union[Sequence[str], str]]]])Údict_r#cs|dkrtjStdddddtddddddddfd    dddd
ddt|tjrl|}n| ¡}t fd d|D¡S)Nr)Úvalr#cSsdSr3r)©r5r)r)r*Ú _assert_value÷sz$URL._str_dict.<locals>._assert_valuez Sequence[str]zUnion[str, Tuple[str, ...]]cSsdSr3r)r6r)r)r*r7ýszUnion[str, Sequence[str]]cs<t|tr|St|tjr0tfdd|DStddS)Nc3s|]}|VqdSr3r))Ú.0Úelem©r7r)r*Ú    <genexpr>    sz7URL._str_dict.<locals>._assert_value.<locals>.<genexpr>z?Query dictionary values must be strings or sequences of strings)r1rÚcollections_abcrÚtupler-r6r:r)r*r7s
ÿ)r.r#cSst|tstd|S)Nz%Query dictionary keys must be stringsr0)r.r)r)r*r$s
z"URL._str_dict.<locals>._assert_strcsi|]\}}||qSr)r))r8ÚkeyÚvalue©r$r7r)r*Ú
<dictcomp>s
ýÿz!URL._str_dict.<locals>.<dictcomp>)rÚ
EMPTY_DICTrr1r<rÚitemsÚ immutabledict)r(r4Ú
dict_itemsr)r@r*r'ês 
 üÿz URL._str_dictz1Optional[Mapping[str, Union[Sequence[str], str]]]c    Csi}|dk    r||d<|dk    r$||d<|dk    r4||d<|dk    rD||d<|dk    rT||d<|dk    rd||d<|dk    rt||d<|jf|S)    areturn a new :class:`_engine.URL` object with modifications.
 
        Values are used if they are non-None.  To set a value to ``None``
        explicitly, use the :meth:`_engine.URL._replace` method adapted
        from ``namedtuple``.
 
        :param drivername: new drivername
        :param username: new username
        :param password: new password
        :param host: new hostname
        :param port: new port
        :param query: new query parameters, passed a dict of string keys
         referring to string or sequence of string values.  Fully
         replaces the previous list of arguments.
 
        :return: new :class:`_engine.URL` object.
 
        .. versionadded:: 1.4
 
        .. seealso::
 
            :meth:`_engine.URL.update_query_dict`
 
        Nrrrrr r!r")Ú_assert_replace)    Úselfrrrrr r!r"Úkwr)r)r*Úset$s #zURL.setr)rHr#cKsvd|kr| |dd¡dD]}||kr| |||¡qd|krP| |d¡d|krj| |d¡|d<|jf|S)z)argument checks before calling _replace()r)rrr!r r")r$r%r&r'Ú_replace)rGrHÚnamer)r)r*rFYszURL._assert_replaceFÚbool)Úquery_stringÚappendr#cCs|jt||dS)aEReturn a new :class:`_engine.URL` object with the :attr:`_engine.URL.query`
        parameter dictionary updated by the given query string.
 
        E.g.::
 
            >>> from sqlalchemy.engine import make_url
            >>> url = make_url("postgresql+psycopg2://user:pass@host/dbname")
            >>> url = url.update_query_string("alt_host=host1&alt_host=host2&ssl_cipher=%2Fpath%2Fto%2Fcrt")
            >>> str(url)
            'postgresql+psycopg2://user:pass@host/dbname?alt_host=host1&alt_host=host2&ssl_cipher=%2Fpath%2Fto%2Fcrt'
 
        :param query_string: a URL escaped query string, not including the
         question mark.
 
        :param append: if True, parameters in the existing query string will
         not be removed; new parameters will be in addition to those present.
         If left at its default of False, keys present in the given query
         parameters will replace those of the existing query string.
 
        .. versionadded:: 1.4
 
        .. seealso::
 
            :attr:`_engine.URL.query`
 
            :meth:`_engine.URL.update_query_dict`
 
        ©rN)Úupdate_query_pairsr)rGrMrNr)r)r*Úupdate_query_stringhszURL.update_query_stringz+Iterable[Tuple[str, Union[str, List[str]]]])Úkey_value_pairsrNr#cs|ji}|D]\\}}||krLt ||¡||<td|| tt|¡qt|ttfrbt|n|||<q|rÜi}|D]>}|krªtt |¡t ||¡||<qx||||<qx|     fddt
 |¡D¡n|j dd|  ¡D¡}|j
|dS)aReturn a new :class:`_engine.URL` object with the
        :attr:`_engine.URL.query`
        parameter dictionary updated by the given sequence of key/value pairs
 
        E.g.::
 
            >>> from sqlalchemy.engine import make_url
            >>> url = make_url("postgresql+psycopg2://user:pass@host/dbname")
            >>> url = url.update_query_pairs([("alt_host", "host1"), ("alt_host", "host2"), ("ssl_cipher", "/path/to/crt")])
            >>> str(url)
            'postgresql+psycopg2://user:pass@host/dbname?alt_host=host1&alt_host=host2&ssl_cipher=%2Fpath%2Fto%2Fcrt'
 
        :param key_value_pairs: A sequence of tuples containing two strings
         each.
 
        :param append: if True, parameters in the existing query string will
         not be removed; new parameters will be in addition to those present.
         If left at its default of False, keys present in the given query
         parameters will replace those of the existing query string.
 
        .. versionadded:: 1.4
 
        .. seealso::
 
            :attr:`_engine.URL.query`
 
            :meth:`_engine.URL.difference_update_query`
 
            :meth:`_engine.URL.set`
 
        ú    List[str]csi|]}||qSr)r))r8Úk©Zexisting_queryr)r*rAÈsÿz*URL.update_query_pairs.<locals>.<dictcomp>cSs(i|] \}}|t|tr t|n|qSr))r1Úlistr=©r8rTr.r)r)r*rAÏsÿ©r")r"rÚto_listrrNrr1rVr=ÚupdaterIÚ
differenceÚunionrC)rGrRrNZnew_keysr>r?Z    new_queryrTr)rUr*rPs:%ÿÿÿ
 
þÿþÿzURL.update_query_pairsz#Mapping[str, Union[str, List[str]]])Úquery_parametersrNr#cCs|j| ¡|dS)aÉReturn a new :class:`_engine.URL` object with the
        :attr:`_engine.URL.query` parameter dictionary updated by the given
        dictionary.
 
        The dictionary typically contains string keys and string values.
        In order to represent a query parameter that is expressed multiple
        times, pass a sequence of string values.
 
        E.g.::
 
 
            >>> from sqlalchemy.engine import make_url
            >>> url = make_url("postgresql+psycopg2://user:pass@host/dbname")
            >>> url = url.update_query_dict({"alt_host": ["host1", "host2"], "ssl_cipher": "/path/to/crt"})
            >>> str(url)
            'postgresql+psycopg2://user:pass@host/dbname?alt_host=host1&alt_host=host2&ssl_cipher=%2Fpath%2Fto%2Fcrt'
 
 
        :param query_parameters: A dictionary with string keys and values
         that are either strings, or sequences of strings.
 
        :param append: if True, parameters in the existing query string will
         not be removed; new parameters will be in addition to those present.
         If left at its default of False, keys present in the given query
         parameters will replace those of the existing query string.
 
 
        .. versionadded:: 1.4
 
        .. seealso::
 
            :attr:`_engine.URL.query`
 
            :meth:`_engine.URL.update_query_string`
 
            :meth:`_engine.URL.update_query_pairs`
 
            :meth:`_engine.URL.difference_update_query`
 
            :meth:`_engine.URL.set`
 
        rO)rPrC)rGr]rNr)r)r*Úupdate_query_dictÖs/zURL.update_query_dictz Iterable[str])Únamesr#c sTt| j¡sStjjjjjj    t
 fddtj |¡D¡S)a
        Remove the given names from the :attr:`_engine.URL.query` dictionary,
        returning the new :class:`_engine.URL`.
 
        E.g.::
 
            url = url.difference_update_query(['foo', 'bar'])
 
        Equivalent to using :meth:`_engine.URL.set` as follows::
 
            url = url.set(
                query={
                    key: url.query[key]
                    for key in set(url.query).difference(['foo', 'bar'])
                }
            )
 
        .. versionadded:: 1.4
 
        .. seealso::
 
            :attr:`_engine.URL.query`
 
            :meth:`_engine.URL.update_query_dict`
 
            :meth:`_engine.URL.set`
 
        csi|]}|j|qSr)rX)r8r>©rGr)r*rA0sÿz/URL.difference_update_query.<locals>.<dictcomp>) rIÚintersectionr"rrrrrr r!rrDr[)rGr_r)r`r*Údifference_update_querys
þÿùzURL.difference_update_queryzMapping[str, Sequence[str]])r#cCst dd|j ¡D¡S)aReturn the :attr:`_engine.URL.query` dictionary with values normalized
        into sequences.
 
        As the :attr:`_engine.URL.query` dictionary may contain either
        string values or sequences of string values to differentiate between
        parameters that are specified multiple times in the query string,
        code that needs to handle multiple parameters generically will wish
        to use this attribute so that all parameters present are presented
        as sequences.   Inspiration is from Python's ``urllib.parse.parse_qs``
        function.  E.g.::
 
 
            >>> from sqlalchemy.engine import make_url
            >>> url = make_url("postgresql+psycopg2://user:pass@host/dbname?alt_host=host1&alt_host=host2&ssl_cipher=%2Fpath%2Fto%2Fcrt")
            >>> url.query
            immutabledict({'alt_host': ('host1', 'host2'), 'ssl_cipher': '/path/to/crt'})
            >>> url.normalized_query
            immutabledict({'alt_host': ('host1', 'host2'), 'ssl_cipher': ('/path/to/crt',)})
 
        cSs&i|]\}}|t|ts|fn|qSr))r1r=rWr)r)r*rAOsÿz(URL.normalized_query.<locals>.<dictcomp>)rrDr"rCr`r)r)r*Únormalized_query7s
þÿzURL.normalized_queryú1.4zThe :meth:`_engine.URL.__to_string__ method is deprecated and will be removed in a future release.  Please use the :meth:`_engine.URL.render_as_string` method.T)Ú hide_passwordr#cCs|j|dS)z¿Render this :class:`_engine.URL` object as a string.
 
        :param hide_password: Defaults to True.   The password is not shown
         in the string unless this is set to False.
 
        )re©Úrender_as_string)rGrer)r)r*Ú __to_string__Us zURL.__to_string__csðjd}jdk    rR|tj7}jdk    rJ|d|r8dnttj7}|d7}jdk    rdjkrv|dj7}n
|j7}jdk    r|dtj7}jdk    r´|dj7}jrìt    j}| 
¡|dd     fd
d|D¡7}|S)aRRender this :class:`_engine.URL` object as a string.
 
        This method is used when the ``__str__()`` or ``__repr__()``
        methods are used.   The method directly includes additional options.
 
        :param hide_password: Defaults to True.   The password is not shown
         in the string unless this is set to False.
 
        z://Nú:z***ú@z[%s]ú/ú?ú&c3s8|]0}t j|¡D]}dt|t|fVqqdS)z%s=%sN)rrYr"r)r8rTÚelementr`r)r*r;sþz'URL.render_as_string.<locals>.<genexpr>)rrÚ_sqla_url_quoterrrr r!r"rVÚsortÚjoin)rGreÚsÚkeysr)r`r*rgds2
 
 
 
ÿý
 
 
 
 
 
þzURL.render_as_stringcCs| ¡Sr3rfr`r)r)r*Ú__repr__szURL.__repr__c    Cs&|j |j|j|j|j|j|j|j¡Sr3)    Ú    __class__r+rrrrr r!r"r`r)r)r*Ú__copy__s÷zURL.__copy__)Úmemor#cCs| ¡Sr3)rv)rGrwr)r)r*Ú__deepcopy__szURL.__deepcopy__r,cCstt|Sr3)Úhashrr`r)r)r*Ú__hash__szURL.__hash__)Úotherr#cCs^t|to\|j|jko\|j|jko\|j|jko\|j|jko\|j|jko\|j|jko\|j|jkSr3)    r1rrrrrr!r"r ©rGr{r)r)r*Ú__eq__¡s
 
ÿ
þ
ý
ü
û
ú
øz
URL.__eq__cCs
||kSr3r)r|r)r)r*Ú__ne__sz
URL.__ne__cCs$d|jkr|jS|j d¡dSdS)zÜReturn the backend name.
 
        This is the name that corresponds to the database backend in
        use, and is the portion of the :attr:`_engine.URL.drivername`
        that is to the left of the plus sign.
 
        ú+rN)rÚsplitr`r)r)r*Úget_backend_name°s
zURL.get_backend_namecCs(d|jkr| ¡jS|j d¡dSdS)a«Return the backend name.
 
        This is the name that corresponds to the DBAPI driver in
        use, and is the portion of the :attr:`_engine.URL.drivername`
        that is to the right of the plus sign.
 
        If the :attr:`_engine.URL.drivername` does not include a plus sign,
        then the default :class:`_engine.Dialect` for this :class:`_engine.URL`
        is imported in order to get the driver name.
 
        rrN)rÚget_dialectZdriverrr`r)r)r*Úget_driver_name½s 
 
zURL.get_driver_namezMapping[str, Any]z%Tuple[URL, List[Any], Dict[str, Any]])Úkwargsr#cst j dd¡¡}| dg¡7}tfdd|D} ddg¡}|D]}| |¡}|dk    rR|}qR dd¡||fS)NÚpluginr)rcsg|]}t |¡qSr))rÚload)r8Zplugin_name©rrGr)r*Ú
<listcomp>×sÿz,URL._instantiate_plugins.<locals>.<listcomp>)rrYr"ÚgetÚdictrbZ
update_urlÚpop)rGrZplugin_namesZloaded_pluginsÚurZnew_ur)rr*Ú_instantiate_pluginsÏsþ
zURL._instantiate_pluginsú Type[Dialect]cCs`d|jkr|j}n|j dd¡}t |¡}t|drRt|jtrRt|jt    rR|jSt
d|SdS)zºReturn the "entry point" dialect class.
 
        This is normally the dialect itself except in the case when the
        returned class implements the get_dialect_cls() method.
 
        rÚ.ÚdialectrN)rÚreplacerrÚhasattrr1rÚtypeÚ
issubclassrr)rGrKr(r)r)r*Ú_get_entrypointçs
 
ÿ
þ
ýzURL._get_entrypoint)Ú    _is_asyncr#cCs&| ¡}|r| |¡}n
| |¡}|S)zoReturn the SQLAlchemy :class:`_engine.Dialect` class corresponding
        to this URL's driver name.
 
        )rZget_async_dialect_clsZget_dialect_cls)rGrZ
entrypointZdialect_clsr)r)r*rÿs
 
zURL.get_dialectzOptional[List[str]]zDict[str, Any])r_rHr#cKs|dk    rt dd¡i}dddddg}|D]h}|r>| d    ¡}n||krP||}n|}|dk    r*t||d
r*|dkrtt||||<q*t||||<q*|S)a2Translate url attributes into a dictionary of connection arguments.
 
        Returns attributes of this url (`host`, `database`, `username`,
        `password`, `port`) as a plain dictionary.  The attribute names are
        used as the keys by default.  Unset or false attributes are omitted
        from the final dictionary.
 
        :param \**kw: Optional, alternate key names for url attributes.
 
        :param names: Deprecated.  Same purpose as the keyword-based alternate
            names, but correlates the name to the original positionally.
        NzpThe `URL.translate_connect_args.name`s parameter is deprecated. Please pass the alternate names as kw arguments.rdrr!rrr rF)rZwarn_deprecatedrÚgetattrr)rGr_rHZ
translatedZattribute_namesZsnamerKr)r)r*Útranslate_connect_argss$ü
zURL.translate_connect_args)NNNNNNN)F)F)F)T)T)F)N)$Ú__name__Ú
__module__Ú__qualname__Ú__doc__Ú__annotations__ÚclassmethodrrBr+r&r$r%r'rIrFrQrPr^rbÚpropertyrcÚ
deprecatedrhrgrtrvrxrzr}r~rrrrrrr)r)r)r*r-sz
2ø <;ø5ÿ$ýPý10þ    '   ÿrzUnion[str, URL])Úname_or_urlr#cCst|trt|S|SdS)aGiven a string, produce a new URL instance.
 
    The format of the URL generally follows `RFC-1738
    <https://www.ietf.org/rfc/rfc1738.txt>`_, with some exceptions, including
    that underscores, and not dashes or periods, are accepted within the
    "scheme" portion.
 
    If a :class:`.URL` object is passed, it is returned as is.
 
    .. seealso::
 
        :ref:`database_urls`
 
    N)r1rÚ
_parse_url)r¡r)r)r*Úmake_url5s
r£r)rKr#c    Cs2t dtj¡}| |¡}|dk    r | ¡}|ddk    ri}t|dD]@\}}||kr~t ||¡||<td||     |¡qF|||<qFnd}||d<|ddk    r²t
|d|d<|ddk    rÎt
|d|d<| d¡}| d¡}|pè||d<| d    ¡}|d
rt|d
|d
<t j|f|St d|¡dS)Na®
            (?P<name>[\w\+]+)://
            (?:
                (?P<username>[^:/]*)
                (?::(?P<password>[^@]*))?
            @)?
            (?:
                (?:
                    \[(?P<ipv6host>[^/\?]+)\] |
                    (?P<ipv4host>[^/:\?]+)
                )?
                (?::(?P<port>[^/\?]*))?
            )?
            (?:/(?P<database>[^\?]*))?
            (?:\?(?P<query>.*))?
            r"rSrrÚipv4hostÚipv6hostrrKr z/Could not parse SQLAlchemy URL from string '%s')ÚreÚcompileÚXÚmatchÚ    groupdictrrrYrrNÚ_sqla_url_unquoterr,rr+rÚ ArgumentError)    rKÚpatternÚmÚ
componentsr"r>r?r¤r¥r)r)r*r¢Ks<ï
 
 
 
 
 
ÿr¢)Útextr#cCst ddd|¡S)Nz[:@/]cSsdt| d¡S)Nz%%%Xr)ÚordÚgroup)r®r)r)r*Ú<lambda>óz!_sqla_url_quote.<locals>.<lambda>)r¦Úsub)r°r)r)r*rosro)&rÚ
__future__rÚcollections.abcÚabcr<r¦Útypingrrrrrrr    r
rrr rrÚurllib.parserrrZ
interfacesrÚrrZdialectsrrrr£r¢ror«r)r)r)r*Ú<module>sF    <