MheFdZddlZddlZddlZddlZddlZddlZddlmZm Z ddl m Z ddl m Z mZddlmZmZmZmZmZmZmZmZmZmZGddeZGd d ZGd d ZGd dZeZ d#de dedee!dee dee de"dee deeegdfddfdZ# d$deee de"dee fdZ$d%de de"ddfdZ%d&d eeddfd!Z&degdfddfd"Z'e edS)'a A command line parsing module that lets modules define their own options. This module is inspired by Google's `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_typeexec_in) AnyIteratorIterableTupleSetDictCallableListTextIOOptionalceZdZdZdS)Errorz1Exception raised by errors in the options module.N)__name__ __module__ __qualname____doc__O/var/www/html/test/jupyter/venv/lib/python3.11/site-packages/tornado/options.pyrrs;;DrrcDeZdZdZd(dZdedefdZdedefdZdededdfd Z de fd Z dede fd Z dedefd Zdededdfd ZdeeeeffdZdeefdZdedeeeffdZdeeeffdZ d)dededeedeedeede deedeeegdfddfdZ d*deeede deefdZd+dede ddfd Zd,d!eeddfd"Z de ddfd#Z!degdfddfd$Z"d(d%Z#d-d'Z$dS). OptionParserzA collection of options, a dictionary with object-like access. Normally accessed via static functions in the `tornado.options` module, which reference a global instance. returnNcti|jd<g|jd<|dtd|jdS)N_options_parse_callbackshelpzshow this help information)typer!callback)__dict__definebool_help_callbackselfs r__init__zOptionParser.__init__sO$& j!,. () -(      rnamec.|ddS)N_-)replacer)r+s r_normalize_namezOptionParser._normalize_names||C%%%rc||}t|j|tr|j|St d|zNzUnrecognized option %r)r1 isinstancerget_OptionvalueAttributeErrorr0s r __getattr__zOptionParser.__getattr__sd##D)) dm''--w 7 7 /=&,,.. .5<===rr7c||}t|j|tr |j||St d|zr3)r1r4rr5r6setr8r)r+r7s r __setattr__zOptionParser.__setattr__sf##D)) dm''--w 7 7 2=&**511 15<===rcHd|jDS)Nc3$K|] }|jV dSNr+.0opts r z(OptionParser.__iter__..s$;;S;;;;;;rrvaluesr(s r__iter__zOptionParser.__iter__s$;;DM$8$8$:$:;;;;rc>||}||jvSr@)r1rr0s r __contains__zOptionParser.__contains__s"##D))t}$$rc,||Sr@)r9r0s r __getitem__zOptionParser.__getitem__s%%%rc.|||Sr@)r=r<s r __setitem__zOptionParser.__setitem__se,,,rcHd|jDS)zKAn iterable of (name, value) pairs. .. versionadded:: 3.1 cJg|] \}}|j|f!Srr+r7rCr+rDs r z&OptionParser.items..s+OOOID#399;;'OOOrritemsr(s rrUzOptionParser.itemss' PO9L9L9N9NOOOOrcHd|jDS)zWThe set of option-groups created by ``define``. .. versionadded:: 3.1 ch|] }|j Sr) group_namerBs r z&OptionParser.groups..sAAA3AAArrFr(s rgroupszOptionParser.groupss' BA$-*>*>*@*@AAAArgroupcNfd|jDS)aThe 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 cdi|],\}}r |jk|j|-Sr)rXr+r7)rCr+rDr[s r z+OptionParser.group_dict..sJ   c "S^33 Hciikk333rrT)r)r[s `r group_dictzOptionParser.group_dicts<"    !]0022    rcHd|jDS)zLThe names and values of all options. .. versionadded:: 3.1 cHi|]\}}|j| SrrQrRs rr^z(OptionParser.as_dict..s(MMM)$#))++MMMrrTr(s ras_dictzOptionParser.as_dicts' NMt}7J7J7L7LMMMMrFdefaultr"r!metavarmultipler#c ||} | |jvr%td| d|j| jt jd} | _| jj} | j1| jjj| kr| jjj dkr| j} | jJ| jjj} nd} | | krd} ||s ||j }nt}|r|} n| } t|| |||||| | }||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. Option z already defined in rNr%z ) file_namercr"r!rdrerXr#) r1rrrisys _getframef_code co_filenamef_backco_name __class__strr6)r)r+rcr"r!rdrer[r# normalizedframe options_filerirXoptions rr%zOptionParser.definesWZ))$//  & &%::t}Z8BBD  a     <3L  (L'3|CCL'/8;; <+++ +7II#I  $ $I <  3(  #JJ"J !    %+ j!!!rTargsfinalc| tj}g}tdt|D]}||ds ||d}n||dkr||dzd}n||d}|d\}}}||}||jvr&| td|z|j|} |s%| j tkrd}ntd|z| ||r||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. Nr.z--=z$Unrecognized command line option: %rtruezOption %r requires a value)rjargvrangelen startswithlstrip partitionr1r print_helprr"r&parserun_parse_callbacks) r)rvrw remainingiargr+equalsr7rus rparse_command_linezOptionParser.parse_command_line;sf0 <8D q#d))$$  A7%%c**  H Aw$ QM q'..%%C"%--"4"4 D&%''--D4=((!!!BTIJJJ]4(F E;$&&"EE \}}|r1tdtj |z||d|D]}||j}|jr |d |jzz }|jpd }|j|jd kr |d |jzz }t)j|d }t-|d kst-|dkr|dd td|dd|d||ddD]} tddd| |@t|dS)z@Prints all the command line options to stderr (or another file).NzUsage: %s [OPTIONS]rrz Options: z %s options: c|jSr@rA)rus rz)OptionParser.print_help..sfkr)keyrzrhz (default %s),z --30 ry34)rjstderrprintr|rrG setdefaultrXappendsortedrUrrnormpathsortr1r+rdr!rctextwrapwrapr~insert) r)rby_grouprufilenameoprefix descriptionlineslines rrzOptionParser.print_helps4 <:D #chqk1==== n4((((m**,, F FF    12 6 6 = =f E E E E!(.."2"233 ? ?KHa Q'"'*:*:8*D*DD4PPPP FF11F 2 2 2 ? ?--fk::>3cFN22F$k/R >-&.B2F2F?V^#CCK k7;;v;;##s5zzQLLB'''a9EEEE!!""I??DTT2>>>>>? ? 4rc^|r*|tjddSdS)Nr)rrjexitr)r7s rr'zOptionParser._help_callbacks5   OO    HQKKKKK  rc:|j|dS)zAAdds a parse callback, to be invoked when option parsing is done.N)r rr)r#s radd_parse_callbackzOptionParser.add_parse_callbacks $$X.....rc.|jD] }| dSr@)r rs rrz OptionParser.run_parse_callbackss+-  H HJJJJ  r _Mockablec t|S)aReturns a wrapper around self that is compatible with `unittest.mock.patch`. The `unittest.mock.patch` function is incompatible with objects like ``options`` that override ``__getattr__`` and ``__setattr__``. This function returns an object that can be used with `mock.patch.object ` to modify option values:: with mock.patch.object(options.mockable(), 'name', value): assert options.name == value )rr(s rmockablezOptionParser.mockablesr)rNNNNNFNNNTTr@)rr)%rrrrr*rqr1rr9r=r rHr&rJrLrNr r rUr rZr r_rbrr"rr%rrrrrr'rrrrrrrrs     &C&C&&&&>>>>>> >>C>D>>>> <(<<<<%%%%%%&&&&&&--C-D----Pxc3h0PPPPBCBBBB  S#X    .Nc3hNNNN#"!%#48Z+Z+Z+Z+tn Z+ sm Z+ # Z+Z+}Z+8SE4K01Z+ Z+Z+Z+Z+z?C44T#Y'47;4 c4444lE'E'cE'$E'$E'E'E'E'Nx/4<DT /8BH+=/$////      rrcVeZdZdZdeddfdZdedefdZdededdfd Z deddfd Z dS) ra`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. optionsrNc.||jd<i|jd<dS)Nr _originals)r$)r)rs rr*z_Mockable.__init__s $+ j!&( l###rr+c,t|j|Sr@)getattrrr0s rr9z_Mockable.__getattr__st}d+++rr7c||jvs Jdt|j||j|<t|j||dS)Nzdon't reuse mockable objects)rrrsetattrr<s rr=z_Mockable.__setattr__sP4?***,J*** ' t < < tU+++++rcbt|j||j|dSr@)rrrpopr0s r __delattr__z_Mockable.__delattr__ s, tT_%8%8%>%>?????r) rrrrrr*rqrr9r=rrrrrrs  ) ))))) ,,,,,,,,C,D,,,, @@@@@@@@rrceZdZeZ d!dededeedeedeede d eed eed ee egdfd dfd Z d efdZ ded efdZ ded dfdZgdZded ejfdZdddddddddd ZdZejdezejZded ejfdZded e fdZded efd ZdS)"r6NFr+rcr"r!rdrerirXr#rc ||rg}||_|td||_||_||_||_||_||_| |_||_ tj |_ dS)Nztype must not be None) r+ ValueErrorr"r!rdrerirXr#rcr6UNSET_value) r)r+rcr"r!rdrerirXr#s rr*z_Option.__init__sr ?x?G <455 5     "$   m rcD|jtjur|jn|jSr@)rr6rrcr(s rr7z _Option.value0s#{gm;;t||Lrr7ctj|jtj|jt|jt |ji|j |j }|j rg|_ | dD]}t|j tjr_|d\}}}||}|r ||n|}|j t%||dz|j ||n|||_ |j||j |S)N,:ry)datetime_parse_datetime timedelta_parse_timedeltar& _parse_boolr _parse_stringr5r"rersplit issubclassnumbersIntegralrextendr}rr#r7) r)r7_parsepartlo_strr-hi_strlohis rrz _Option.parse3sT  t3   5 $" T/  # Ity   = (DK C(( 5 5di)9::5(,s(;(;%FAvB+19rBK&&uRa'8'89999K&&vvd||4444 5!&--DK = $ MM$+ & & &zz||rc |jrzt|ts$td|jd|jj|D]=}|9t||js$td|jd|jj>nL|Jt||js5td|jd|jjdt |d||_|j||jdSdS)Nrgrz is required to be a z (z given)) rer4rrr+r"rrr#)r)r7items rr;z _Option.setMs, = eT** eyyy$)"4"46  #JtTY,G,G#%999di&8&8:  E49)E)E eyyy$)"4"4"4d5kkkkC = $ MM$+ & & & & & % $r) 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|jD]4} tj||cS#t$rY1wxYwt d|z)Nz!Unrecognized date/time format: %r)_DATETIME_FORMATSrstrptimerr)r)r7formats rrz_Option._parse_datetimersl,  F (11%@@@@@    7%?@@@s - ::hoursminutesseconds milliseconds microsecondsdaysweeks) hmminssecmsusdwz-[-+]?(?:\d+(?:\.\d*)?|\.\d+)(?:[eE][-+]?\d+)?z\s*(%s)\s*(\w*)\s*c tj}d}|t|kr|j||}|st t |d}|dpd}|j ||}|tjdi||iz }| }|t|k|S#t $rwxYw)Nrryrr) rrr~_TIMEDELTA_PATTERNmatch Exceptionfloatr[_TIMEDELTA_ABBREV_DICTr5end)r)r7sumstartrnumunitss rrz_Option._parse_timedeltas $&&CE#e**$$+11%??&#++%AGGAJJ'' /i377uEEx)99UCL999#e**$$J     s C%C(( C4c.|dvS)N)false0r)lowerrs rrz_Option._parse_bools{{}}$777rc t|Sr@)rrs rrz_Option._parse_stringsr)NNNNFNNN)rrrobjectrrqrrr"r&rr*r7rr;rrrr_FLOAT_PATTERNrecompile IGNORECASErrrrrrrrr6r6s6 FHHE #"!%#'$(48$$$$tn $ sm $ # $$C=$SM$8SE4K01$ $$$$6MsMMMM334''''''0   ASAX->AAAA      FN#. ch.@$88888833rr6Fr+rcr"r!rdrer[r#rc Ft||||||||S)zODefines an option in the global namespace. See `OptionParser.define`. )rcr"r!rdrer[r#)rr%)r+rcr"r!rdrer[r#s rr%r%s7 >>       rTrvrwc:t||S)z]Parses global options from the command line. See `OptionParser.parse_command_line`. rw)rr)rvrws rrrs  % %d% % 8 88rrc:t||S)zYParses global options from a config file. See `OptionParser.parse_config_file`. r)rr)rrws rrrs  $ $T $ 7 77rrc6t|S)ziPrints all the command line options to stderr (or another file). See `OptionParser.print_help`. )rrrs rrrs   d # ##rc:t|dS)zqAdds a parse callback, to be invoked when option parsing is done. See `OptionParser.add_parse_callback` N)rr)r#s rrrs  x(((((rrrrr@)(rrrrrjrrtornado.escaperr tornado.logr tornado.utilrrtypingrr r r r r rrrrrrrrr6rrqr"r&r%rrrrrrrrsY TTl ////////......11111111                             I   iiiiiiiiX @@@@@@@@