o

we�f�@s�
dZd
dl
Z
d
dlZd
dlZd
dlZd
dlZd
dlZd
dlmZm	Z	
d
dl
mZ
d
dlm
Z
mZ
d
dlmZmZmZmZmZmZmZmZmZmZ
Gdd�de�ZGd	d
�d
e�ZGdd�de�ZGd
d�de�Ze�Z 								d(de!dedee"dee!dee!de#dee!deeeg
dfddfdd�Z$	d)deee!de#dee!fdd�Z%d*d e!de#ddfd!d"�Z&d+d#eeddfd$d%�Z'degdfddfd&d'�Z(ee �

dS),a�A command line parsing module that lets modules define their own options.

This module is inspired by Google's `gflags
<https://github.com/google/python-gflags>`_. The primary difference
with libraries such as `argparse` is that a global registry is used so
that options may be defined in any module (it also enables
`tornado.log` by default). The rest of Tornado does not depend on this
module, so feel free to use `argparse` or other configuration
libraries if you prefer them.

Options must be defined with `tornado.options.define` before use,
generally at the top level of a module. The options are then
accessible as attributes of `tornado.options.options`::

    # myapp/db.py
    from tornado.options import define, options

    define("mysql_host", default="127.0.0.1:3306", help="Main user DB")
    define("memcache_hosts", default="127.0.0.1:11011", multiple=True,
           help="Main user memcache servers")

    def connect():
        db = database.Connection(options.mysql_host)
        ...

    # myapp/server.py
    from tornado.options import define, options

    define("port", default=8080, help="port to listen on")

    def start_server():
        app = make_app()
        app.listen(options.port)

The ``main()`` method of your application does not need to be aware of all of
the options used throughout your program; they are all automatically loaded
when the modules are loaded.  However, all modules that define options
must have been imported before the command line is parsed.

Your ``main()`` method can parse the command line or parse a config file with
either `parse_command_line` or `parse_config_file`::

    import myapp.db, myapp.server
    import tornado

    if __name__ == '__main__':
        tornado.options.parse_command_line()
        # or
        tornado.options.parse_config_file("/etc/server.conf")

.. note::

   When using multiple ``parse_*`` functions, pass ``final=False`` to all
   but the last one, or side effects may occur twice (in particular,
   this can result in log messages being doubled).

`tornado.options.options` is a singleton instance of `OptionParser`, and
the top-level functions in this module (`define`, `parse_command_line`, etc)
simply call methods on it.  You may create additional `OptionParser`
instances to define isolated sets of options, such as for subcommands.

.. note::

   By default, several options are defined that will configure the
   standard `logging` module when `parse_command_line` or `parse_config_file`
   are called.  If you want Tornado to leave the logging configuration
   alone so you can manage it yourself, either pass ``--logging=none``
   on the command line or do the following to disable it in code::

       from tornado.options import options, parse_command_line
       options.logging = None
       parse_command_line()

.. note::

   `parse_command_line` or `parse_config_file` function should called after
   logging configuration and user-defined command line flags using the
   ``callback`` option definition, or these configurations will not take effect.

.. versionchanged:: 4.3
   Dashes and underscores are fully interchangeable in option names;
   options can be defined, set, and read with any mix of the two.
   Dashes are typical for command-line usage while config files require
   underscores.
�N)�_unicode�
native_str)
�define_logging_options)�basestring_type�exec_in)
�Any�Iterator�Iterable�Tuple�Set�Dict�Callable�List�TextIO�Optionalc
@seZ
dZd
ZdS)�Errorz1Exception raised by errors in the options module.N)�__name__�
__module__�__qualname__�__doc__�rr�H/home/arjun/projects/env/lib/python3.10/site-packages/tornado/options.pyrs
rc@s�
eZ
dZd
Zd<dd�Zdedefdd�Zdedefd	d
�Zdededdfdd
�Z	de
fdd�Zdedefdd�Z
dedefdd�Zdededdfdd�Zdeeeeffdd�Zdeefdd�Zdedeeeffdd�Zdeeeffdd�Z							d=ded ed!eed"eed#eed$edeed%eeeg
dfddfd&d'�Z	(d>d)eeed*edeefd+d,�Zd?d-ed*eddfd.d/�Zd@d0eeddfd1d2�Z deddfd3d4�Z!d%egdfddfd5d6�Z"d<d7d8�Z#dAd:d;�Z$dS)B�OptionParserz�A collection of options, a dictionary with object-like access.

    Normally accessed via static functions in the `tornado.options` module,
    which reference a global instance.
    �returnNc

Cs,i|jd
<g|jd<|j
dtd|jd�
dS)N�_options�_parse_callbacks�helpzshow this help information)�typer�callback)�__dict__�define�bool�_help_callback�
�selfrrr�__init__�s








�zOptionParser.__init__�namecCs|
�d
d�S)N�
_�
-)
�replace�r$r&rrr�_normalize_name��
zOptionParser._normalize_namecCs6|�|
�
}
t
|j�|
�
t�r|j|
��Std
|
�
�
�NzUnrecognized option %r)r+�
isinstancer�get�_Option�value�AttributeErrorr*rrr�__getattr__�s




zOptionParser.__getattr__r1cCs8|�|
�
}
t
|j�|
�
t�r|j|
�|�
Std
|
�
�
r-)r+r.rr/r0�setr2�r$r&r1rrr�__setattr__�s




zOptionParser.__setattr__c

C�d
d�|j�
�D�
S)Nc
s��|]}
|
jV
qdS�
N�
r&��.0�optrrr�	<genexpr>���z(OptionParser.__iter__.<locals>.<genexpr>)r�valuesr#rrr�__iter__�s
zOptionParser.__iter__cCs|�|
�
}
|
|j
vSr9)r+rr*rrr�__contains__�s



zOptionParser.__contains__cCs
|�|
�
Sr9)
r3r*rrr�__getitem__�s

zOptionParser.__getitem__cCs|�|
|�Sr9)
r6r5rrr�__setitem__�r,zOptionParser.__setitem__c

Cr7)zKAn iterable of (name, value) pairs.

        .. versionadded:: 3.1
        c
Ssg|]\}
}|j|�
�f�qSr�r&r1�r<r&r=rrr�
<listcomp>�sz&OptionParser.items.<locals>.<listcomp>)r�itemsr#rrrrH�szOptionParser.itemsc

C�td
d�|j
��D�
�
S)zWThe set of option-groups created by ``define``.

        .. versionadded:: 3.1
        c
sr8r9)
�
group_namer;rrrr>�r?z&OptionParser.groups.<locals>.<genexpr>)r4rr@r#rrr�groups��zOptionParser.groups�groupcst�f
d
d�|j
��D�
�
S)a�
The names and values of options in a group.

        Useful for copying options into Application settings::

            from tornado.options import define, parse_command_line, options

            define('template_path', group='application')
            define('static_path', group='application')

            parse_command_line()

            application = Application(
                handlers, **options.group_dict('application'))

        .. versionadded:: 3.1
        c
3s0�|]\}
}�r
�|jkr|j
|��fV
qdSr9)rJr&r1rF�
rMrrr>�s�
�
��z*OptionParser.group_dict.<locals>.<genexpr>��dictrrH)r$rMrrNr�
group_dict�s�zOptionParser.group_dictc

CrI)zLThe names and values of all options.

        .. versionadded:: 3.1
        c
ss"�|]\}
}|j|�
�fV
qdSr9rErFrrrr>�s� z'OptionParser.as_dict.<locals>.<genexpr>rOr#rrr�as_dict�rLzOptionParser.as_dictF�defaultrr�metavar�multiplerc	Cs�|�|
�
}	|	|j
vrtd
|	|j
|	jf�
�
t�d�
}
|
du
rF|
jj}|
jdu
r9|
jjj|kr9|
jjj	dkr9|
j}
|
jdu
s@J�
|
jjj}nd}||krNd}|dur^|s\|du
r\|j
}nt}|rc|}
n|}
t|
|||||||
|d�	}||j
|	<dS)acDefines a new command line option.

        ``type`` can be any of `str`, `int`, `float`, `bool`,
        `~datetime.datetime`, or `~datetime.timedelta`. If no ``type``
        is given but a ``default`` is, ``type`` is the type of
        ``default``. Otherwise, ``type`` defaults to `str`.

        If ``multiple`` is True, the option value is a list of ``type``
        instead of an instance of ``type``.

        ``help`` and ``metavar`` are used to construct the
        automatically generated command line help string. The help
        message is formatted like::

           --name=METAVAR      help string

        ``group`` is used to group the defined options in logical
        groups. By default, command line options are grouped by the
        file in which they are defined.

        Command line option names must be unique globally.

        If a ``callback`` is given, it will be run with the new value whenever
        the option is changed.  This can be used to combine command-line
        and file-based options::

            define("config", type=str, help="path to config file",
                   callback=lambda path: parse_config_file(path, final=False))

        With this definition, options in the file specified by ``--config`` will
        override options set earlier on the command line, but can be overridden
        by later flags.

        zOption %r already defined in %sr
Nr z	<unknown>�)�	file_namerSrrrTrUrJr)
r+rrrW�sys�	_getframe�f_code�co_filename�f_back�co_name�	__class__�strr0)r$r&rSrrrTrUrMr�
normalized�frame�options_filerWrJ�optionrrrr �sL
-




��























�zOptionParser.defineT�args�finalc
Cs�|
d
urtj
}
g}tdt|
�
�D]^}|
|�d�
s!|
|d
�}
nN|
|dkr1|
|dd
�}
n>|
|�d�
}|�d�
\}}}|�|�
}||jv
rT|�	�
t
d|�
�
|j|}	|si|	jtkrcd}nt
d|�
�
|	�
|�

q|ru|��
|S)	a+Parses all options given on the command line (defaults to
        `sys.argv`).

        Options look like ``--option=value`` and are parsed according
        to their ``type``. For boolean options, ``--option`` is
        equivalent to ``--option=true``

        If the option has ``multiple=True``, comma-separated values
        are accepted. For multi-value integer options, the syntax
        ``x:y`` is also accepted and equivalent to ``range(x, y)``.

        Note that ``args[0]`` is ignored since it is the program name
        in `sys.argv`.

        We return a list of all arguments that are not parsed as options.

        If ``final`` is ``False``, parse callbacks will not be run.
        This is useful for applications that wish to combine configurations
        from multiple sources.

        N�
r(z--�
=z$Unrecognized command line option: %r�truezOption %r requires a value)rX�argv�range�len�
startswith�lstrip�	partitionr+r�
print_helprrr!�parse�run_parse_callbacks)
r$rdre�	remaining�
i�argr&�equalsr1rcrrr�parse_command_line;
s2























zOptionParser.parse_command_line�pathcCs�d
tj
�|
�
i
}t|
d��}tt|���
||�
Wd�
n1s"w



Y
|D]G}|�|�
}||jvrp|j|}|j	rQt
||ttf�sQt
d|j|jjf�
�
t||�
tkri|jtksa|j	ri|�||�

q)|�||�

q)|ry|��
dSdS)a!Parses and loads the config file at the given path.

        The config file contains Python code that will be executed (so
        it is **not safe** to use untrusted config files). Anything in
        the global namespace that matches a defined option will be
        used to set that option's value.

        Options may either be the specified type for the option or
        strings (in which case they will be parsed the same way as in
        `.parse_command_line`)

        Example (using the options defined in the top-level docs of
        this module)::

            port = 80
            mysql_host = 'mydb.example.com:3306'
            # Both lists and comma-separated strings are allowed for
            # multiple=True.
            memcache_hosts = ['cache1.example.com:11011',
                              'cache2.example.com:11011']
            memcache_hosts = 'cache1.example.com:11011,cache2.example.com:11011'

        If ``final`` is ``False``, parse callbacks will not be run.
        This is useful for applications that wish to combine configurations
        from multiple sources.

        .. note::

            `tornado.options` is primarily a command-line library.
            Config file support is provided for applications that wish
            to use it, but applications that prefer config files may
            wish to look at other libraries instead.

        .. versionchanged:: 4.1
           Config files are now always interpreted as utf-8 instead of
           the system default encoding.

        .. versionchanged:: 4.4
           The special variable ``__file__`` is available inside config
           files, specifying the absolute path to the config file itself.

        .. versionchanged:: 5.1
           Added the ability to set options via strings in config files.

        �__file__�rbNzDOption %r is required to be a list of %s or a comma-separated string)�osrw�abspath�openrr�readr+rrUr.�listr_rr&rrrpr4rq)r$rwre�config�
fr&r`rcrrr�parse_config_fileq
s..

�









��
�
�zOptionParser.parse_config_file�filec
Csl
|
d
urtj
}
tdtjd|
d�
td|
d�
i}|j��D]}|�|jg��|�

qt	|�
��
D]|\}}|rDtdtj�
|�
|
d�
|jdd�d	�

|D]_}|�|j�
}|jr`|d
|j7}|jpdd}|jd
u
rv|jdkrv|d|j7}t�|d
�}t|�
dks�t|�
dkr�|�dd�
td||df|
d�
|dd
�D]}	tdd|	f|
d�
q�qNq2t|
d�

d
S)z@Prints all the command line options to stderr (or another file).NzUsage: %s [OPTIONS]r
�
r�z

Options:
z
%s options:
c


Ss|jSr9r:)
rcrrr�<lambda>�
sz)OptionParser.print_help.<locals>.<lambda>)
�keyrgrVz
 (default %s)�,�z  --%-30s %srfz%-34s %s�
 )rX�stderr�printrirr@�
setdefaultrJ�append�sortedrHrzrw�normpath�sortr+r&rTrrS�textwrap�wraprk�insert)
r$r��by_grouprc�filename�
o�prefix�description�lines�linerrrro�
s6





















��zOptionParser.print_helpcCs|
r
|��
t
�d
�

dSdS)Nr
)rorX�exit�r$r1rrrr"�
s


�zOptionParser._help_callbackcCs|j�
|
�

d
S)zAAdds a parse callback, to be invoked when option parsing is done.N)rr��r$rrrr�add_parse_callback�
szOptionParser.add_parse_callbackc
Cs|jD]}
|
�
qdSr9)
rr�rrrrq�
s


�z OptionParser.run_parse_callbacks�	_Mockablec

Cst|�
S)
a�Returns a wrapper around self that is compatible with
        `mock.patch <unittest.mock.patch>`.

        The `mock.patch <unittest.mock.patch>` function (included in
        the standard library `unittest.mock` package since Python 3.3,
        or in the third-party ``mock`` package for older versions of
        Python) is incompatible with objects like ``options`` that
        override ``__getattr__`` and ``__setattr__``.  This function
        returns an object that can be used with `mock.patch.object
        <unittest.mock.patch.object>` to modify option values::

            with mock.patch.object(options.mockable(), 'name', value):
                assert options.name == value
        )
r�r#rrr�mockable�
szOptionParser.mockable)rN�NNNNFNN�NT�
Tr9)rr�)%rrrrr%r_r+rr3r6rrAr!rBrCrDr	r
rHrrKrrQrRrrr
r rrvr�rror"r�rqr�rrrrr�sl








��������	�

�]�

�
�
�6G
rc@s\eZ
dZd
Zdeddfdd�Zdedefdd	�Zded
eddfdd�Z	deddfd
d�Z
dS)r�a
`mock.patch` compatible wrapper for `OptionParser`.

    As of ``mock`` version 1.0.1, when an object uses ``__getattr__``
    hooks instead of ``__dict__``, ``patch.__exit__`` tries to delete
    the attribute it set instead of setting a new one (assuming that
    the object does not capture ``__setattr__``, so the patch
    created a new attribute in ``__dict__``).

    _Mockable's getattr and setattr pass through to the underlying
    OptionParser, and delattr undoes the effect of a previous setattr.
    �optionsrNcCs|
|jd
<i|jd<dS)Nr�
_originals)
r)r$r�rrrr%s

z_Mockable.__init__r&cCst|j
|
�Sr9)�getattrrr*rrrr3r,z_Mockable.__getattr__r1cCs6|
|jv
s	Jd
�
�
t
|j|
�|j|
<t|j|
|�
dS)Nzdon't reuse mockable objects)r�r�r�setattrr5rrrr6
s


z_Mockable.__setattr__cCst|j
|
|j�|
�
�
dSr9)r�rr��popr*rrr�__delattr__s
z_Mockable.__delattr__)rrrrrr%r_rr3r6r�rrrrr��
s
r�c@s,
eZ
dZe�Z	
	
	
	
		
	
	
d)dededeedeedeede	d	eed
eedee
eg
d
fdd
fd
d�Zdefdd�Zdedefdd�Z
dedd
fdd�Zgd�
Zdedejfdd�Zdddddddddd �	Zd!Ze�d"eej�Zdedejfd#d$�Zdede	fd%d&�Zdedefd'd(�Zd
S)*r0NFr&rSrrrTrUrWrJrrc

Csb|dur|rg}|
|_|durt
d
�
�
||_||_||_||_||_||_|	|_||_	t
j|_dS)Nztype must not be None)
r&�
ValueErrorrrrTrUrWrJrrSr0�UNSET�_value)
r$r&rSrrrTrUrWrJrrrrr%s












z_Option.__init__c

Cs|jt
jur	|jS|jSr9)r�r0r�rSr#rrrr14s
z
_Option.valuer1c	Cs�tj|j
tj|jt|jt|ji�|j	|j	�}|j
rTg|_|
�d
�
D]1}t
|j	tj�rJ|�d�
\}}}||�
}|r<||�
n
|}|j�t||d��

q!|j�||�
�

q!n||
�
|_|jdu
rd|�|j�

|��S)N�
,�
:rf)�datetime�_parse_datetime�	timedelta�_parse_timedeltar!�_parse_boolr�
_parse_stringr/rrUr��split�
issubclass�numbers�Integralrn�extendrjr�rr1)	r$r1�_parse�part�lo_strr'�hi_str�lo�hirrrrp7s.


�
��





�





z
_Option.parsecCs�|jr.t
|
t�std
|j|jjf�
�
|
D]}|du
r,t
||j�s,td
|j|jjf�
�
qn|
du
rFt
|
|j�sFtd|j|jjt|
�
f�
�
|
|_|jdu
rV|�|j�

dSdS)Nz(Option %r is required to be a list of %sz+Option %r is required to be a %s (%s given))	rUr.r~rr&rrr�r)r$r1�itemrrrr4Qs4





��



����


��


�z_Option.set)
z%a %b %d %H:%M:%S %Yz%Y-%m-%d %H:%M:%Sz%Y-%m-%d %H:%Mz%Y-%m-%dT%H:%Mz%Y%m%d %H:%M:%Sz%Y%m%d %H:%Mz%Y-%m-%dz%Y%m%dz%H:%M:%Sz%H:%Mc	Cs>|jD]}z
t
j
�|
|�W
Sty


Yqwtd
|
�
�
)Nz!Unrecognized date/time format: %r)�_DATETIME_FORMATSr��strptimer�r)r$r1�formatrrrr�vs





�z_Option._parse_datetime�hours�minutes�seconds�milliseconds�microseconds�days�weeks)	�
h�
m�min�
s�sec�ms�us�
d�
wz-[-+]?(?:\d+(?:\.\d*)?|\.\d+)(?:[eE][-+]?\d+)?z\s*(%s)\s*(\w*)\s*cCs�zFt�
�}d
}|t|
�
krD|j�|
|�}|st��
t|�d�
�
}|�d�
p&d}|j�	||�}|tj
di||i
�
�
7}|�
�}|t|
�
ks
|WStyN


�w)Nr
rf�r�r)r�r�rk�_TIMEDELTA_PATTERN�match�	Exception�floatrM�_TIMEDELTA_ABBREV_DICTr/�end)r$r1�sum�startr��num�unitsrrrr��s"










�

�z_Option._parse_timedeltacCs|
��d
v
S)N)�false�
0r�)
�lowerr�rrrr��r,z_Option._parse_boolcCst|
�
Sr9)
rr�rrrr��s
z_Option._parse_string)NNNNFNNN)rrr�objectr�r_rrrr!r
r%r1rpr4r�r�r�r��_FLOAT_PATTERN�re�compile�
IGNORECASEr�r�r�r�r�rrrrr0sj






��������	�
�
�
	







�

�r0Fr&rSrrrTrUrMrrc
Cstj
||
||||||d
�S)zODefines an option in the global namespace.

    See `OptionParser.define`.
    )rSrrrTrUrMr)r�r )r&rSrrrTrUrMrrrrr �s







�r TrdrecC�tj
||
d
�S)z]Parses global options from the command line.

    See `OptionParser.parse_command_line`.
    �
re)r�rv)rdrerrrrv�srvrwcCr�)zYParses global options from a config file.

    See `OptionParser.parse_config_file`.
    r�)r�r�)rwrerrrr���r�r�c

Cs
t�
|�
S)
ziPrints all the command line options to stderr (or another file).

    See `OptionParser.print_help`.
    )r�ror�rrrro�s
roc

Cst�
|�

d
S)zqAdds a parse callback, to be invoked when option parsing is done.

    See `OptionParser.add_parse_callback`
    N)r�r�)
rrrrr��r�r�r�r�r�r9))rr�r�r�rXrzr��tornado.escaperr�tornado.logr�tornado.utilrr�typingrrr	r
rrr
rrrr�rr�rr�r0r�r_rr!r rvr�ror�rrrr�<module>
stV






0r






�
��������	
��

�
�
�