p!ranha?

:mod:`optparse` --- Parser for command line options =================================================== .. module:: optparse :synopsis: Command-line option parsing library. :deprecated: .. moduleauthor:: Greg Ward <gward@python.net> .. sectionauthor:: Greg Ward <gward@python.net> .. versionadded:: 2.3 .. deprecated:: 2.7 The :mod:`optparse` module is deprecated and will not be developed further; development will continue with the :mod:`argparse` module. **Source code:** :source:`Lib/optparse.py` -------------- :mod:`optparse` is a more convenient, flexible, and powerful library for parsing command-line options than the old :mod:`getopt` module. :mod:`optparse` uses a more declarative style of command-line parsing: you create an instance of :class:`OptionParser`, populate it with options, and parse the command line. :mod:`optparse` allows users to specify options in the conventional GNU/POSIX syntax, and additionally generates usage and help messages for you. Here's an example of using :mod:`optparse` in a simple script:: from optparse import OptionParser [...] parser = OptionParser() parser.add_option("-f", "--file", dest="filename", help="write report to FILE", metavar="FILE") parser.add_option("-q", "--quiet", action="store_false", dest="verbose", default=True, help="don't print status messages to stdout") (options, args) = parser.parse_args() With these few lines of code, users of your script can now do the "usual thing" on the command-line, for example:: <yourscript> --file=outfile -q As it parses the command line, :mod:`optparse` sets attributes of the ``options`` object returned by :meth:`parse_args` based on user-supplied command-line values. When :meth:`parse_args` returns from parsing this command line, ``options.filename`` will be ``"outfile"`` and ``options.verbose`` will be ``False``. :mod:`optparse` supports both long and short options, allows short options to be merged together, and allows options to be associated with their arguments in a variety of ways. Thus, the following command lines are all equivalent to the above example:: <yourscript> -f outfile --quiet <yourscript> --quiet --file outfile <yourscript> -q -foutfile <yourscript> -qfoutfile Additionally, users can run one of :: <yourscript> -h <yourscript> --help and :mod:`optparse` will print out a brief summary of your script's options: .. code-block:: text Usage: <yourscript> [options] Options: -h, --help show this help message and exit -f FILE, --file=FILE write report to FILE -q, --quiet don't print status messages to stdout where the value of *yourscript* is determined at runtime (normally from ``sys.argv[0]``). .. _optparse-background: Background ---------- :mod:`optparse` was explicitly designed to encourage the creation of programs with straightforward, conventional command-line interfaces. To that end, it supports only the most common command-line syntax and semantics conventionally used under Unix. If you are unfamiliar with these conventions, read this section to acquaint yourself with them. .. _optparse-terminology: Terminology ^^^^^^^^^^^ argument a string entered on the command-line, and passed by the shell to ``execl()`` or ``execv()``. In Python, arguments are elements of ``sys.argv[1:]`` (``sys.argv[0]`` is the name of the program being executed). Unix shells also use the term "word". It is occasionally desirable to substitute an argument list other than ``sys.argv[1:]``, so you should read "argument" as "an element of ``sys.argv[1:]``, or of some other list provided as a substitute for ``sys.argv[1:]``". option an argument used to supply extra information to guide or customize the execution of a program. There are many different syntaxes for options; the traditional Unix syntax is a hyphen ("-") followed by a single letter, e.g. ``-x`` or ``-F``. Also, traditional Unix syntax allows multiple options to be merged into a single argument, e.g. ``-x -F`` is equivalent to ``-xF``. The GNU project introduced ``--`` followed by a series of hyphen-separated words, e.g. ``--file`` or ``--dry-run``. These are the only two option syntaxes provided by :mod:`optparse`. Some other option syntaxes that the world has seen include: * a hyphen followed by a few letters, e.g. ``-pf`` (this is *not* the same as multiple options merged into a single argument) * a hyphen followed by a whole word, e.g. ``-file`` (this is technically equivalent to the previous syntax, but they aren't usually seen in the same program) * a plus sign followed by a single letter, or a few letters, or a word, e.g. ``+f``, ``+rgb`` * a slash followed by a letter, or a few letters, or a word, e.g. ``/f``, ``/file`` These option syntaxes are not supported by :mod:`optparse`, and they never will be. This is deliberate: the first three are non-standard on any environment, and the last only makes sense if you're exclusively targeting VMS, MS-DOS, and/or Windows. option argument an argument that follows an option, is closely associated with that option, and is consumed from the argument list when that option is. With :mod:`optparse`, option arguments may either be in a separate argument from their option: .. code-block:: text -f foo --file foo or included in the same argument: .. code-block:: text -ffoo --file=foo Typically, a given option either takes an argument or it doesn't. Lots of people want an "optional option arguments" feature, meaning that some options will take an argument if they see it, and won't if they don't. This is somewhat controversial, because it makes parsing ambiguous: if ``-a`` takes an optional argument and ``-b`` is another option entirely, how do we interpret ``-ab``? Because of this ambiguity, :mod:`optparse` does not support this feature. positional argument something leftover in the argument list after options have been parsed, i.e. after options and their arguments have been parsed and removed from the argument list. required option an option that must be supplied on the command-line; note that the phrase "required option" is self-contradictory in English. :mod:`optparse` doesn't prevent you from implementing required options, but doesn't give you much help at it either. For example, consider this hypothetical command-line:: prog -v --report report.txt foo bar ``-v`` and ``--report`` are both options. Assuming that ``--report`` takes one argument, ``report.txt`` is an option argument. ``foo`` and ``bar`` are positional arguments. .. _optparse-what-options-for: What are options for? ^^^^^^^^^^^^^^^^^^^^^ Options are used to provide extra information to tune or customize the execution of a program. In case it wasn't clear, options are usually *optional*. A program should be able to run just fine with no options whatsoever. (Pick a random program from the Unix or GNU toolsets. Can it run without any options at all and still make sense? The main exceptions are ``find``, ``tar``, and ``dd``\ ---all of which are mutant oddballs that have been rightly criticized for their non-standard syntax and confusing interfaces.) Lots of people want their programs to have "required options". Think about it. If it's required, then it's *not optional*! If there is a piece of information that your program absolutely requires in order to run successfully, that's what positional arguments are for. As an example of good command-line interface design, consider the humble ``cp`` utility, for copying files. It doesn't make much sense to try to copy files without supplying a destination and at least one source. Hence, ``cp`` fails if you run it with no arguments. However, it has a flexible, useful syntax that does not require any options at all:: cp SOURCE DEST cp SOURCE ... DEST-DIR You can get pretty far with just that. Most ``cp`` implementations provide a bunch of options to tweak exactly how the files are copied: you can preserve mode and modification time, avoid following symlinks, ask before clobbering existing files, etc. But none of this distracts from the core mission of ``cp``, which is to copy either one file to another, or several files to another directory. .. _optparse-what-positional-arguments-for: What are positional arguments for? ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Positional arguments are for those pieces of information that your program absolutely, positively requires to run. A good user interface should have as few absolute requirements as possible. If your program requires 17 distinct pieces of information in order to run successfully, it doesn't much matter *how* you get that information from the user---most people will give up and walk away before they successfully run the program. This applies whether the user interface is a command-line, a configuration file, or a GUI: if you make that many demands on your users, most of them will simply give up. In short, try to minimize the amount of information that users are absolutely required to supply---use sensible defaults whenever possible. Of course, you also want to make your programs reasonably flexible. That's what options are for. Again, it doesn't matter if they are entries in a config file, widgets in the "Preferences" dialog of a GUI, or command-line options---the more options you implement, the more flexible your program is, and the more complicated its implementation becomes. Too much flexibility has drawbacks as well, of course; too many options can overwhelm users and make your code much harder to maintain. .. _optparse-tutorial: Tutorial -------- While :mod:`optparse` is quite flexible and powerful, it's also straightforward to use in most cases. This section covers the code patterns that are common to any :mod:`optparse`\ -based program. First, you need to import the OptionParser class; then, early in the main program, create an OptionParser instance:: from optparse import OptionParser [...] parser = OptionParser() Then you can start defining options. The basic syntax is:: parser.add_option(opt_str, ..., attr=value, ...) Each option has one or more option strings, such as ``-f`` or ``--file``, and several option attributes that tell :mod:`optparse` what to expect and what to do when it encounters that option on the command line. Typically, each option will have one short option string and one long option string, e.g.:: parser.add_option("-f", "--file", ...) You're free to define as many short option strings and as many long option strings as you like (including zero), as long as there is at least one option string overall. The option strings passed to :meth:`OptionParser.add_option` are effectively labels for the option defined by that call. For brevity, we will frequently refer to *encountering an option* on the command line; in reality, :mod:`optparse` encounters *option strings* and looks up options from them. Once all of your options are defined, instruct :mod:`optparse` to parse your program's command line:: (options, args) = parser.parse_args() (If you like, you can pass a custom argument list to :meth:`parse_args`, but that's rarely necessary: by default it uses ``sys.argv[1:]``.) :meth:`parse_args` returns two values: * ``options``, an object containing values for all of your options---e.g. if ``--file`` takes a single string argument, then ``options.file`` will be the filename supplied by the user, or ``None`` if the user did not supply that option * ``args``, the list of positional arguments leftover after parsing options This tutorial section only covers the four most important option attributes: :attr:`~Option.action`, :attr:`~Option.type`, :attr:`~Option.dest` (destination), and :attr:`~Option.help`. Of these, :attr:`~Option.action` is the most fundamental. .. _optparse-understanding-option-actions: Understanding option actions ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Actions tell :mod:`optparse` what to do when it encounters an option on the command line. There is a fixed set of actions hard-coded into :mod:`optparse`; adding new actions is an advanced topic covered in section :ref:`optparse-extending-optparse`. Most actions tell :mod:`optparse` to store a value in some variable---for example, take a string from the command line and store it in an attribute of ``options``. If you don't specify an option action, :mod:`optparse` defaults to ``store``. .. _optparse-store-action: The store action ^^^^^^^^^^^^^^^^ The most common option action is ``store``, which tells :mod:`optparse` to take the next argument (or the remainder of the current argument), ensure that it is of the correct type, and store it to your chosen destination. For example:: parser.add_option("-f", "--file", action="store", type="string", dest="filename") Now let's make up a fake command line and ask :mod:`optparse` to parse it:: args = ["-f", "foo.txt"] (options, args) = parser.parse_args(args) When :mod:`optparse` sees the option string ``-f``, it consumes the next argument, ``foo.txt``, and stores it in ``options.filename``. So, after this call to :meth:`parse_args`, ``options.filename`` is ``"foo.txt"``. Some other option types supported by :mod:`optparse` are ``int`` and ``float``. Here's an option that expects an integer argument:: parser.add_option("-n", type="int", dest="num") Note that this option has no long option string, which is perfectly acceptable. Also, there's no explicit action, since the default is ``store``. Let's parse another fake command-line. This time, we'll jam the option argument right up against the option: since ``-n42`` (one argument) is equivalent to ``-n 42`` (two arguments), the code :: (options, args) = parser.parse_args(["-n42"]) print options.num will print ``42``. If you don't specify a type, :mod:`optparse` assumes ``string``. Combined with the fact that the default action is ``store``, that means our first example can be a lot shorter:: parser.add_option("-f", "--file", dest="filename") If you don't supply a destination, :mod:`optparse` figures out a sensible default from the option strings: if the first long option string is ``--foo-bar``, then the default destination is ``foo_bar``. If there are no long option strings, :mod:`optparse` looks at the first short option string: the default destination for ``-f`` is ``f``. :mod:`optparse` also includes built-in ``long`` and ``complex`` types. Adding types is covered in section :ref:`optparse-extending-optparse`. .. _optparse-handling-boolean-options: Handling boolean (flag) options ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Flag options---set a variable to true or false when a particular option is seen ---are quite common. :mod:`optparse` supports them with two separate actions, ``store_true`` and ``store_false``. For example, you might have a ``verbose`` flag that is turned on with ``-v`` and off with ``-q``:: parser.add_option("-v", action="store_true", dest="verbose") parser.add_option("-q", action="store_false", dest="verbose") Here we have two different options with the same destination, which is perfectly OK. (It just means you have to be a bit careful when setting default values--- see below.) When :mod:`optparse` encounters ``-v`` on the command line, it sets ``options.verbose`` to ``True``; when it encounters ``-q``, ``options.verbose`` is set to ``False``. .. _optparse-other-actions: Other actions ^^^^^^^^^^^^^ Some other actions supported by :mod:`optparse` are: ``"store_const"`` store a constant value ``"append"`` append this option's argument to a list ``"count"`` increment a counter by one ``"callback"`` call a specified function These are covered in section :ref:`optparse-reference-guide`, Reference Guide and section :ref:`optparse-option-callbacks`. .. _optparse-default-values: Default values ^^^^^^^^^^^^^^ All of the above examples involve setting some variable (the "destination") when certain command-line options are seen. What happens if those options are never seen? Since we didn't supply any defaults, they are all set to ``None``. This is usually fine, but sometimes you want more control. :mod:`optparse` lets you supply a default value for each destination, which is assigned before the command line is parsed. First, consider the verbose/quiet example. If we want :mod:`optparse` to set ``verbose`` to ``True`` unless ``-q`` is seen, then we can do this:: parser.add_option("-v", action="store_true", dest="verbose", default=True) parser.add_option("-q", action="store_false", dest="verbose") Since default values apply to the *destination* rather than to any particular option, and these two options happen to have the same destination, this is exactly equivalent:: parser.add_option("-v", action="store_true", dest="verbose") parser.add_option("-q", action="store_false", dest="verbose", default=True) Consider this:: parser.add_option("-v", action="store_true", dest="verbose", default=False) parser.add_option("-q", action="store_false", dest="verbose", default=True) Again, the default value for ``verbose`` will be ``True``: the last default value supplied for any particular destination is the one that counts. A clearer way to specify default values is the :meth:`set_defaults` method of OptionParser, which you can call at any time before calling :meth:`parse_args`:: parser.set_defaults(verbose=True) parser.add_option(...) (options, args) = parser.parse_args() As before, the last value specified for a given option destination is the one that counts. For clarity, try to use one method or the other of setting default values, not both. .. _optparse-generating-help: Generating help ^^^^^^^^^^^^^^^ :mod:`optparse`'s ability to generate help and usage text automatically is useful for creating user-friendly command-line interfaces. All you have to do is supply a :attr:`~Option.help` value for each option, and optionally a short usage message for your whole program. Here's an OptionParser populated with user-friendly (documented) options:: usage = "usage: %prog [options] arg1 arg2" parser = OptionParser(usage=usage) parser.add_option("-v", "--verbose", action="store_true", dest="verbose", default=True, help="make lots of noise [default]") parser.add_option("-q", "--quiet", action="store_false", dest="verbose", help="be vewwy quiet (I'm hunting wabbits)") parser.add_option("-f", "--filename", metavar="FILE", help="write output to FILE") parser.add_option("-m", "--mode", default="intermediate", help="interaction mode: novice, intermediate, " "or expert [default: %default]") If :mod:`optparse` encounters either ``-h`` or ``--help`` on the command-line, or if you just call :meth:`parser.print_help`, it prints the following to standard output: .. code-block:: text Usage: <yourscript> [options] arg1 arg2 Options: -h, --help show this help message and exit -v, --verbose make lots of noise [default] -q, --quiet be vewwy quiet (I'm hunting wabbits) -f FILE, --filename=FILE write output to FILE -m MODE, --mode=MODE interaction mode: novice, intermediate, or expert [default: intermediate] (If the help output is triggered by a help option, :mod:`optparse` exits after printing the help text.) There's a lot going on here to help :mod:`optparse` generate the best possible help message: * the script defines its own usage message:: usage = "usage: %prog [options] arg1 arg2" :mod:`optparse` expands ``%prog`` in the usage string to the name of the current program, i.e. ``os.path.basename(sys.argv[0])``. The expanded string is then printed before the detailed option help. If you don't supply a usage string, :mod:`optparse` uses a bland but sensible default: ``"Usage: %prog [options]"``, which is fine if your script doesn't take any positional arguments. * every option defines a help string, and doesn't worry about line-wrapping--- :mod:`optparse` takes care of wrapping lines and making the help output look good. * options that take a value indicate this fact in their automatically-generated help message, e.g. for the "mode" option:: -m MODE, --mode=MODE Here, "MODE" is called the meta-variable: it stands for the argument that the user is expected to supply to ``-m``/``--mode``. By default, :mod:`optparse` converts the destination variable name to uppercase and uses that for the meta-variable. Sometimes, that's not what you want---for example, the ``--filename`` option explicitly sets ``metavar="FILE"``, resulting in this automatically-generated option description:: -f FILE, --filename=FILE This is important for more than just saving space, though: the manually written help text uses the meta-variable ``FILE`` to clue the user in that there's a connection between the semi-formal syntax ``-f FILE`` and the informal semantic description "write output to FILE". This is a simple but effective way to make your help text a lot clearer and more useful for end users. .. versionadded:: 2.4 Options that have a default value can include ``%default`` in the help string---\ :mod:`optparse` will replace it with :func:`str` of the option's default value. If an option has no default value (or the default value is ``None``), ``%default`` expands to ``none``. Grouping Options ++++++++++++++++ When dealing with many options, it is convenient to group these options for better help output. An :class:`OptionParser` can contain several option groups, each of which can contain several options. An option group is obtained using the class :class:`OptionGroup`: .. class:: OptionGroup(parser, title, description=None) where * parser is the :class:`OptionParser` instance the group will be insterted in to * title is the group title * description, optional, is a long description of the group :class:`OptionGroup` inherits from :class:`OptionContainer` (like :class:`OptionParser`) and so the :meth:`add_option` method can be used to add an option to the group. Once all the options are declared, using the :class:`OptionParser` method :meth:`add_option_group` the group is added to the previously defined parser. Continuing with the parser defined in the previous section, adding an :class:`OptionGroup` to a parser is easy:: group = OptionGroup(parser, "Dangerous Options", "Caution: use these options at your own risk. " "It is believed that some of them bite.") group.add_option("-g", action="store_true", help="Group option.") parser.add_option_group(group) This would result in the following help output: .. code-block:: text Usage: <yourscript> [options] arg1 arg2 Options: -h, --help show this help message and exit -v, --verbose make lots of noise [default] -q, --quiet be vewwy quiet (I'm hunting wabbits) -f FILE, --filename=FILE write output to FILE -m MODE, --mode=MODE interaction mode: novice, intermediate, or expert [default: intermediate] Dangerous Options: Caution: use these options at your own risk. It is believed that some of them bite. -g Group option. A bit more complete example might involve using more than one group: still extending the previous example:: group = OptionGroup(parser, "Dangerous Options", "Caution: use these options at your own risk. " "It is believed that some of them bite.") group.add_option("-g", action="store_true", help="Group option.") parser.add_option_group(group) group = OptionGroup(parser, "Debug Options") group.add_option("-d", "--debug", action="store_true", help="Print debug information") group.add_option("-s", "--sql", action="store_true", help="Print all SQL statements executed") group.add_option("-e", action="store_true", help="Print every action done") parser.add_option_group(group) that results in the following output: .. code-block:: text Usage: <yourscript> [options] arg1 arg2 Options: -h, --help show this help message and exit -v, --verbose make lots of noise [default] -q, --quiet be vewwy quiet (I'm hunting wabbits) -f FILE, --filename=FILE write output to FILE -m MODE, --mode=MODE interaction mode: novice, intermediate, or expert [default: intermediate] Dangerous Options: Caution: use these options at your own risk. It is believed that some of them bite. -g Group option. Debug Options: -d, --debug Print debug information -s, --sql Print all SQL statements executed -e Print every action done Another interesting method, in particular when working programmatically with option groups is: .. method:: OptionParser.get_option_group(opt_str) Return the :class:`OptionGroup` to which the short or long option string *opt_str* (e.g. ``'-o'`` or ``'--option'``) belongs. If there's no such :class:`OptionGroup`, return ``None``. .. _optparse-printing-version-string: Printing a version string ^^^^^^^^^^^^^^^^^^^^^^^^^ Similar to the brief usage string, :mod:`optparse` can also print a version string for your program. You have to supply the string as the ``version`` argument to OptionParser:: parser = OptionParser(usage="%prog [-f] [-q]", version="%prog 1.0") ``%prog`` is expanded just like it is in ``usage``. Apart from that, ``version`` can contain anything you like. When you supply it, :mod:`optparse` automatically adds a ``--version`` option to your parser. If it encounters this option on the command line, it expands your ``version`` string (by replacing ``%prog``), prints it to stdout, and exits. For example, if your script is called ``/usr/bin/foo``:: $ /usr/bin/foo --version foo 1.0 The following two methods can be used to print and get the ``version`` string: .. method:: OptionParser.print_version(file=None) Print the version message for the current program (``self.version``) to *file* (default stdout). As with :meth:`print_usage`, any occurrence of ``%prog`` in ``self.version`` is replaced with the name of the current program. Does nothing if ``self.version`` is empty or undefined. .. method:: OptionParser.get_version() Same as :meth:`print_version` but returns the version string instead of printing it. .. _optparse-how-optparse-handles-errors: How :mod:`optparse` handles errors ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ There are two broad classes of errors that :mod:`optparse` has to worry about: programmer errors and user errors. Programmer errors are usually erroneous calls to :func:`OptionParser.add_option`, e.g. invalid option strings, unknown option attributes, missing option attributes, etc. These are dealt with in the usual way: raise an exception (either :exc:`optparse.OptionError` or :exc:`TypeError`) and let the program crash. Handling user errors is much more important, since they are guaranteed to happen no matter how stable your code is. :mod:`optparse` can automatically detect some user errors, such as bad option arguments (passing ``-n 4x`` where ``-n`` takes an integer argument), missing arguments (``-n`` at the end of the command line, where ``-n`` takes an argument of any type). Also, you can call :func:`OptionParser.error` to signal an application-defined error condition:: (options, args) = parser.parse_args() [...] if options.a and options.b: parser.error("options -a and -b are mutually exclusive") In either case, :mod:`optparse` handles the error the same way: it prints the program's usage message and an error message to standard error and exits with error status 2. Consider the first example above, where the user passes ``4x`` to an option that takes an integer:: $ /usr/bin/foo -n 4x Usage: foo [options] foo: error: option -n: invalid integer value: '4x' Or, where the user fails to pass a value at all:: $ /usr/bin/foo -n Usage: foo [options] foo: error: -n option requires an argument :mod:`optparse`\ -generated error messages take care always to mention the option involved in the error; be sure to do the same when calling :func:`OptionParser.error` from your application code. If :mod:`optparse`'s default error-handling behaviour does not suit your needs, you'll need to subclass OptionParser and override its :meth:`~OptionParser.exit` and/or :meth:`~OptionParser.error` methods. .. _optparse-putting-it-all-together: Putting it all together ^^^^^^^^^^^^^^^^^^^^^^^ Here's what :mod:`optparse`\ -based scripts usually look like:: from optparse import OptionParser [...] def main(): usage = "usage: %prog [options] arg" parser = OptionParser(usage) parser.add_option("-f", "--file", dest="filename", help="read data from FILENAME") parser.add_option("-v", "--verbose", action="store_true", dest="verbose") parser.add_option("-q", "--quiet", action="store_false", dest="verbose") [...] (options, args) = parser.parse_args() if len(args) != 1: parser.error("incorrect number of arguments") if options.verbose: print "reading %s..." % options.filename [...] if __name__ == "__main__": main() .. _optparse-reference-guide: Reference Guide --------------- .. _optparse-creating-parser: Creating the parser ^^^^^^^^^^^^^^^^^^^ The first step in using :mod:`optparse` is to create an OptionParser instance. .. class:: OptionParser(...) The OptionParser constructor has no required arguments, but a number of optional keyword arguments. You should always pass them as keyword arguments, i.e. do not rely on the order in which the arguments are declared. ``usage`` (default: ``"%prog [options]"``) The usage summary to print when your program is run incorrectly or with a help option. When :mod:`optparse` prints the usage string, it expands ``%prog`` to ``os.path.basename(sys.argv[0])`` (or to ``prog`` if you passed that keyword argument). To suppress a usage message, pass the special value :data:`optparse.SUPPRESS_USAGE`. ``option_list`` (default: ``[]``) A list of Option objects to populate the parser with. The options in ``option_list`` are added after any options in ``standard_option_list`` (a class attribute that may be set by OptionParser subclasses), but before any version or help options. Deprecated; use :meth:`add_option` after creating the parser instead. ``option_class`` (default: optparse.Option) Class to use when adding options to the parser in :meth:`add_option`. ``version`` (default: ``None``) A version string to print when the user supplies a version option. If you supply a true value for ``version``, :mod:`optparse` automatically adds a version option with the single option string ``--version``. The substring ``%prog`` is expanded the same as for ``usage``. ``conflict_handler`` (default: ``"error"``) Specifies what to do when options with conflicting option strings are added to the parser; see section :ref:`optparse-conflicts-between-options`. ``description`` (default: ``None``) A paragraph of text giving a brief overview of your program. :mod:`optparse` reformats this paragraph to fit the current terminal width and prints it when the user requests help (after ``usage``, but before the list of options). ``formatter`` (default: a new :class:`IndentedHelpFormatter`) An instance of optparse.HelpFormatter that will be used for printing help text. :mod:`optparse` provides two concrete classes for this purpose: IndentedHelpFormatter and TitledHelpFormatter. ``add_help_option`` (default: ``True``) If true, :mod:`optparse` will add a help option (with option strings ``-h`` and ``--help``) to the parser. ``prog`` The string to use when expanding ``%prog`` in ``usage`` and ``version`` instead of ``os.path.basename(sys.argv[0])``. ``epilog`` (default: ``None``) A paragraph of help text to print after the option help. .. _optparse-populating-parser: Populating the parser ^^^^^^^^^^^^^^^^^^^^^ There are several ways to populate the parser with options. The preferred way is by using :meth:`OptionParser.add_option`, as shown in section :ref:`optparse-tutorial`. :meth:`add_option` can be called in one of two ways: * pass it an Option instance (as returned by :func:`make_option`) * pass it any combination of positional and keyword arguments that are acceptable to :func:`make_option` (i.e., to the Option constructor), and it will create the Option instance for you The other alternative is to pass a list of pre-constructed Option instances to the OptionParser constructor, as in:: option_list = [ make_option("-f", "--filename", action="store", type="string", dest="filename"), make_option("-q", "--quiet", action="store_false", dest="verbose"), ] parser = OptionParser(option_list=option_list) (:func:`make_option` is a factory function for creating Option instances; currently it is an alias for the Option constructor. A future version of :mod:`optparse` may split Option into several classes, and :func:`make_option` will pick the right class to instantiate. Do not instantiate Option directly.) .. _optparse-defining-options: Defining options ^^^^^^^^^^^^^^^^ Each Option instance represents a set of synonymous command-line option strings, e.g. ``-f`` and ``--file``. You can specify any number of short or long option strings, but you must specify at least one overall option string. The canonical way to create an :class:`Option` instance is with the :meth:`add_option` method of :class:`OptionParser`. .. method:: OptionParser.add_option(option) OptionParser.add_option(*opt_str, attr=value, ...) To define an option with only a short option string:: parser.add_option("-f", attr=value, ...) And to define an option with only a long option string:: parser.add_option("--foo", attr=value, ...) The keyword arguments define attributes of the new Option object. The most important option attribute is :attr:`~Option.action`, and it largely determines which other attributes are relevant or required. If you pass irrelevant option attributes, or fail to pass required ones, :mod:`optparse` raises an :exc:`OptionError` exception explaining your mistake. An option's *action* determines what :mod:`optparse` does when it encounters this option on the command-line. The standard option actions hard-coded into :mod:`optparse` are: ``"store"`` store this option's argument (default) ``"store_const"`` store a constant value ``"store_true"`` store a true value ``"store_false"`` store a false value ``"append"`` append this option's argument to a list ``"append_const"`` append a constant value to a list ``"count"`` increment a counter by one ``"callback"`` call a specified function ``"help"`` print a usage message including all options and the documentation for them (If you don't supply an action, the default is ``"store"``. For this action, you may also supply :attr:`~Option.type` and :attr:`~Option.dest` option attributes; see :ref:`optparse-standard-option-actions`.) As you can see, most actions involve storing or updating a value somewhere. :mod:`optparse` always creates a special object for this, conventionally called ``options`` (it happens to be an instance of :class:`optparse.Values`). Option arguments (and various other values) are stored as attributes of this object, according to the :attr:`~Option.dest` (destination) option attribute. For example, when you call :: parser.parse_args() one of the first things :mod:`optparse` does is create the ``options`` object:: options = Values() If one of the options in this parser is defined with :: parser.add_option("-f", "--file", action="store", type="string", dest="filename") and the command-line being parsed includes any of the following:: -ffoo -f foo --file=foo --file foo then :mod:`optparse`, on seeing this option, will do the equivalent of :: options.filename = "foo" The :attr:`~Option.type` and :attr:`~Option.dest` option attributes are almost as important as :attr:`~Option.action`, but :attr:`~Option.action` is the only one that makes sense for *all* options. .. _optparse-option-attributes: Option attributes ^^^^^^^^^^^^^^^^^ The following option attributes may be passed as keyword arguments to :meth:`OptionParser.add_option`. If you pass an option attribute that is not relevant to a particular option, or fail to pass a required option attribute, :mod:`optparse` raises :exc:`OptionError`. .. attribute:: Option.action (default: ``"store"``) Determines :mod:`optparse`'s behaviour when this option is seen on the command line; the available options are documented :ref:`here <optparse-standard-option-actions>`. .. attribute:: Option.type (default: ``"string"``) The argument type expected by this option (e.g., ``"string"`` or ``"int"``); the available option types are documented :ref:`here <optparse-standard-option-types>`. .. attribute:: Option.dest (default: derived from option strings) If the option's action implies writing or modifying a value somewhere, this tells :mod:`optparse` where to write it: :attr:`~Option.dest` names an attribute of the ``options`` object that :mod:`optparse` builds as it parses the command line. .. attribute:: Option.default The value to use for this option's destination if the option is not seen on the command line. See also :meth:`OptionParser.set_defaults`. .. attribute:: Option.nargs (default: 1) How many arguments of type :attr:`~Option.type` should be consumed when this option is seen. If > 1, :mod:`optparse` will store a tuple of values to :attr:`~Option.dest`. .. attribute:: Option.const For actions that store a constant value, the constant value to store. .. attribute:: Option.choices For options of type ``"choice"``, the list of strings the user may choose from. .. attribute:: Option.callback For options with action ``"callback"``, the callable to call when this option is seen. See section :ref:`optparse-option-callbacks` for detail on the arguments passed to the callable. .. attribute:: Option.callback_args Option.callback_kwargs Additional positional and keyword arguments to pass to ``callback`` after the four standard callback arguments. .. attribute:: Option.help Help text to print for this option when listing all available options after the user supplies a :attr:`~Option.help` option (such as ``--help``). If no help text is supplied, the option will be listed without help text. To hide this option, use the special value :data:`optparse.SUPPRESS_HELP`. .. attribute:: Option.metavar (default: derived from option strings) Stand-in for the option argument(s) to use when printing help text. See section :ref:`optparse-tutorial` for an example. .. _optparse-standard-option-actions: Standard option actions ^^^^^^^^^^^^^^^^^^^^^^^ The various option actions all have slightly different requirements and effects. Most actions have several relevant option attributes which you may specify to guide :mod:`optparse`'s behaviour; a few have required attributes, which you must specify for any option using that action. * ``"store"`` [relevant: :attr:`~Option.type`, :attr:`~Option.dest`, :attr:`~Option.nargs`, :attr:`~Option.choices`] The option must be followed by an argument, which is converted to a value according to :attr:`~Option.type` and stored in :attr:`~Option.dest`. If :attr:`~Option.nargs` > 1, multiple arguments will be consumed from the command line; all will be converted according to :attr:`~Option.type` and stored to :attr:`~Option.dest` as a tuple. See the :ref:`optparse-standard-option-types` section. If :attr:`~Option.choices` is supplied (a list or tuple of strings), the type defaults to ``"choice"``. If :attr:`~Option.type` is not supplied, it defaults to ``"string"``. If :attr:`~Option.dest` is not supplied, :mod:`optparse` derives a destination from the first long option string (e.g., ``--foo-bar`` implies ``foo_bar``). If there are no long option strings, :mod:`optparse` derives a destination from the first short option string (e.g., ``-f`` implies ``f``). Example:: parser.add_option("-f") parser.add_option("-p", type="float", nargs=3, dest="point") As it parses the command line :: -f foo.txt -p 1 -3.5 4 -fbar.txt :mod:`optparse` will set :: options.f = "foo.txt" options.point = (1.0, -3.5, 4.0) options.f = "bar.txt" * ``"store_const"`` [required: :attr:`~Option.const`; relevant: :attr:`~Option.dest`] The value :attr:`~Option.const` is stored in :attr:`~Option.dest`. Example:: parser.add_option("-q", "--quiet", action="store_const", const=0, dest="verbose") parser.add_option("-v", "--verbose", action="store_const", const=1, dest="verbose") parser.add_option("--noisy", action="store_const", const=2, dest="verbose") If ``--noisy`` is seen, :mod:`optparse` will set :: options.verbose = 2 * ``"store_true"`` [relevant: :attr:`~Option.dest`] A special case of ``"store_const"`` that stores a true value to :attr:`~Option.dest`. * ``"store_false"`` [relevant: :attr:`~Option.dest`] Like ``"store_true"``, but stores a false value. Example:: parser.add_option("--clobber", action="store_true", dest="clobber") parser.add_option("--no-clobber", action="store_false", dest="clobber") * ``"append"`` [relevant: :attr:`~Option.type`, :attr:`~Option.dest`, :attr:`~Option.nargs`, :attr:`~Option.choices`] The option must be followed by an argument, which is appended to the list in :attr:`~Option.dest`. If no default value for :attr:`~Option.dest` is supplied, an empty list is automatically created when :mod:`optparse` first encounters this option on the command-line. If :attr:`~Option.nargs` > 1, multiple arguments are consumed, and a tuple of length :attr:`~Option.nargs` is appended to :attr:`~Option.dest`. The defaults for :attr:`~Option.type` and :attr:`~Option.dest` are the same as for the ``"store"`` action. Example:: parser.add_option("-t", "--tracks", action="append", type="int") If ``-t3`` is seen on the command-line, :mod:`optparse` does the equivalent of:: options.tracks = [] options.tracks.append(int("3")) If, a little later on, ``--tracks=4`` is seen, it does:: options.tracks.append(int("4")) The ``append`` action calls the ``append`` method on the current value of the option. This means that any default value specified must have an ``append`` method. It also means that if the default value is non-empty, the default elements will be present in the parsed value for the option, with any values from the command line appended after those default values:: >>> parser.add_option("--files", action="append", default=['~/.mypkg/defaults']) >>> opts, args = parser.parse_args(['--files', 'overrides.mypkg']) >>> opts.files ['~/.mypkg/defaults', 'overrides.mypkg'] * ``"append_const"`` [required: :attr:`~Option.const`; relevant: :attr:`~Option.dest`] Like ``"store_const"``, but the value :attr:`~Option.const` is appended to :attr:`~Option.dest`; as with ``"append"``, :attr:`~Option.dest` defaults to ``None``, and an empty list is automatically created the first time the option is encountered. * ``"count"`` [relevant: :attr:`~Option.dest`] Increment the integer stored at :attr:`~Option.dest`. If no default value is supplied, :attr:`~Option.dest` is set to zero before being incremented the first time. Example:: parser.add_option("-v", action="count", dest="verbosity") The first time ``-v`` is seen on the command line, :mod:`optparse` does the equivalent of:: options.verbosity = 0 options.verbosity += 1 Every subsequent occurrence of ``-v`` results in :: options.verbosity += 1 * ``"callback"`` [required: :attr:`~Option.callback`; relevant: :attr:`~Option.type`, :attr:`~Option.nargs`, :attr:`~Option.callback_args`, :attr:`~Option.callback_kwargs`] Call the function specified by :attr:`~Option.callback`, which is called as :: func(option, opt_str, value, parser, *args, **kwargs) See section :ref:`optparse-option-callbacks` for more detail. * ``"help"`` Prints a complete help message for all the options in the current option parser. The help message is constructed from the ``usage`` string passed to OptionParser's constructor and the :attr:`~Option.help` string passed to every option. If no :attr:`~Option.help` string is supplied for an option, it will still be listed in the help message. To omit an option entirely, use the special value :data:`optparse.SUPPRESS_HELP`. :mod:`optparse` automatically adds a :attr:`~Option.help` option to all OptionParsers, so you do not normally need to create one. Example:: from optparse import OptionParser, SUPPRESS_HELP # usually, a help option is added automatically, but that can # be suppressed using the add_help_option argument parser = OptionParser(add_help_option=False) parser.add_option("-h", "--help", action="help") parser.add_option("-v", action="store_true", dest="verbose", help="Be moderately verbose") parser.add_option("--file", dest="filename", help="Input file to read data from") parser.add_option("--secret", help=SUPPRESS_HELP) If :mod:`optparse` sees either ``-h`` or ``--help`` on the command line, it will print something like the following help message to stdout (assuming ``sys.argv[0]`` is ``"foo.py"``): .. code-block:: text Usage: foo.py [options] Options: -h, --help Show this help message and exit -v Be moderately verbose --file=FILENAME Input file to read data from After printing the help message, :mod:`optparse` terminates your process with ``sys.exit(0)``. * ``"version"`` Prints the version number supplied to the OptionParser to stdout and exits. The version number is actually formatted and printed by the ``print_version()`` method of OptionParser. Generally only relevant if the ``version`` argument is supplied to the OptionParser constructor. As with :attr:`~Option.help` options, you will rarely create ``version`` options, since :mod:`optparse` automatically adds them when needed. .. _optparse-standard-option-types: Standard option types ^^^^^^^^^^^^^^^^^^^^^ :mod:`optparse` has six built-in option types: ``"string"``, ``"int"``, ``"long"``, ``"choice"``, ``"float"`` and ``"complex"``. If you need to add new option types, see section :ref:`optparse-extending-optparse`. Arguments to string options are not checked or converted in any way: the text on the command line is stored in the destination (or passed to the callback) as-is. Integer arguments (type ``"int"`` or ``"long"``) are parsed as follows: * if the number starts with ``0x``, it is parsed as a hexadecimal number * if the number starts with ``0``, it is parsed as an octal number * if the number starts with ``0b``, it is parsed as a binary number * otherwise, the number is parsed as a decimal number The conversion is done by calling either :func:`int` or :func:`long` with the appropriate base (2, 8, 10, or 16). If this fails, so will :mod:`optparse`, although with a more useful error message. ``"float"`` and ``"complex"`` option arguments are converted directly with :func:`float` and :func:`complex`, with similar error-handling. ``"choice"`` options are a subtype of ``"string"`` options. The :attr:`~Option.choices` option attribute (a sequence of strings) defines the set of allowed option arguments. :func:`optparse.check_choice` compares user-supplied option arguments against this master list and raises :exc:`OptionValueError` if an invalid string is given. .. _optparse-parsing-arguments: Parsing arguments ^^^^^^^^^^^^^^^^^ The whole point of creating and populating an OptionParser is to call its :meth:`parse_args` method:: (options, args) = parser.parse_args(args=None, values=None) where the input parameters are ``args`` the list of arguments to process (default: ``sys.argv[1:]``) ``values`` a :class:`optparse.Values` object to store option arguments in (default: a new instance of :class:`Values`) -- if you give an existing object, the option defaults will not be initialized on it and the return values are ``options`` the same object that was passed in as ``values``, or the optparse.Values instance created by :mod:`optparse` ``args`` the leftover positional arguments after all options have been processed The most common usage is to supply neither keyword argument. If you supply ``values``, it will be modified with repeated :func:`setattr` calls (roughly one for every option argument stored to an option destination) and returned by :meth:`parse_args`. If :meth:`parse_args` encounters any errors in the argument list, it calls the OptionParser's :meth:`error` method with an appropriate end-user error message. This ultimately terminates your process with an exit status of 2 (the traditional Unix exit status for command-line errors). .. _optparse-querying-manipulating-option-parser: Querying and manipulating your option parser ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ The default behavior of the option parser can be customized slightly, and you can also poke around your option parser and see what's there. OptionParser provides several methods to help you out: .. method:: OptionParser.disable_interspersed_args() Set parsing to stop on the first non-option. For example, if ``-a`` and ``-b`` are both simple options that take no arguments, :mod:`optparse` normally accepts this syntax:: prog -a arg1 -b arg2 and treats it as equivalent to :: prog -a -b arg1 arg2 To disable this feature, call :meth:`disable_interspersed_args`. This restores traditional Unix syntax, where option parsing stops with the first non-option argument. Use this if you have a command processor which runs another command which has options of its own and you want to make sure these options don't get confused. For example, each command might have a different set of options. .. method:: OptionParser.enable_interspersed_args() Set parsing to not stop on the first non-option, allowing interspersing switches with command arguments. This is the default behavior. .. method:: OptionParser.get_option(opt_str) Returns the Option instance with the option string *opt_str*, or ``None`` if no options have that option string. .. method:: OptionParser.has_option(opt_str) Return true if the OptionParser has an option with option string *opt_str* (e.g., ``-q`` or ``--verbose``). .. method:: OptionParser.remove_option(opt_str) If the :class:`OptionParser` has an option corresponding to *opt_str*, that option is removed. If that option provided any other option strings, all of those option strings become invalid. If *opt_str* does not occur in any option belonging to this :class:`OptionParser`, raises :exc:`ValueError`. .. _optparse-conflicts-between-options: Conflicts between options ^^^^^^^^^^^^^^^^^^^^^^^^^ If you're not careful, it's easy to define options with conflicting option strings:: parser.add_option("-n", "--dry-run", ...) [...] parser.add_option("-n", "--noisy", ...) (This is particularly true if you've defined your own OptionParser subclass with some standard options.) Every time you add an option, :mod:`optparse` checks for conflicts with existing options. If it finds any, it invokes the current conflict-handling mechanism. You can set the conflict-handling mechanism either in the constructor:: parser = OptionParser(..., conflict_handler=handler) or with a separate call:: parser.set_conflict_handler(handler) The available conflict handlers are: ``"error"`` (default) assume option conflicts are a programming error and raise :exc:`OptionConflictError` ``"resolve"`` resolve option conflicts intelligently (see below) As an example, let's define an :class:`OptionParser` that resolves conflicts intelligently and add conflicting options to it:: parser = OptionParser(conflict_handler="resolve") parser.add_option("-n", "--dry-run", ..., help="do no harm") parser.add_option("-n", "--noisy", ..., help="be noisy") At this point, :mod:`optparse` detects that a previously-added option is already using the ``-n`` option string. Since ``conflict_handler`` is ``"resolve"``, it resolves the situation by removing ``-n`` from the earlier option's list of option strings. Now ``--dry-run`` is the only way for the user to activate that option. If the user asks for help, the help message will reflect that:: Options: --dry-run do no harm [...] -n, --noisy be noisy It's possible to whittle away the option strings for a previously-added option until there are none left, and the user has no way of invoking that option from the command-line. In that case, :mod:`optparse` removes that option completely, so it doesn't show up in help text or anywhere else. Carrying on with our existing OptionParser:: parser.add_option("--dry-run", ..., help="new dry-run option") At this point, the original ``-n``/``--dry-run`` option is no longer accessible, so :mod:`optparse` removes it, leaving this help text:: Options: [...] -n, --noisy be noisy --dry-run new dry-run option .. _optparse-cleanup: Cleanup ^^^^^^^ OptionParser instances have several cyclic references. This should not be a problem for Python's garbage collector, but you may wish to break the cyclic references explicitly by calling :meth:`~OptionParser.destroy` on your OptionParser once you are done with it. This is particularly useful in long-running applications where large object graphs are reachable from your OptionParser. .. _optparse-other-methods: Other methods ^^^^^^^^^^^^^ OptionParser supports several other public methods: .. method:: OptionParser.set_usage(usage) Set the usage string according to the rules described above for the ``usage`` constructor keyword argument. Passing ``None`` sets the default usage string; use :data:`optparse.SUPPRESS_USAGE` to suppress a usage message. .. method:: OptionParser.print_usage(file=None) Print the usage message for the current program (``self.usage``) to *file* (default stdout). Any occurrence of the string ``%prog`` in ``self.usage`` is replaced with the name of the current program. Does nothing if ``self.usage`` is empty or not defined. .. method:: OptionParser.get_usage() Same as :meth:`print_usage` but returns the usage string instead of printing it. .. method:: OptionParser.set_defaults(dest=value, ...) Set default values for several option destinations at once. Using :meth:`set_defaults` is the preferred way to set default values for options, since multiple options can share the same destination. For example, if several "mode" options all set the same destination, any one of them can set the default, and the last one wins:: parser.add_option("--advanced", action="store_const", dest="mode", const="advanced", default="novice") # overridden below parser.add_option("--novice", action="store_const", dest="mode", const="novice", default="advanced") # overrides above setting To avoid this confusion, use :meth:`set_defaults`:: parser.set_defaults(mode="advanced") parser.add_option("--advanced", action="store_const", dest="mode", const="advanced") parser.add_option("--novice", action="store_const", dest="mode", const="novice") .. _optparse-option-callbacks: Option Callbacks ---------------- When :mod:`optparse`'s built-in actions and types aren't quite enough for your needs, you have two choices: extend :mod:`optparse` or define a callback option. Extending :mod:`optparse` is more general, but overkill for a lot of simple cases. Quite often a simple callback is all you need. There are two steps to defining a callback option: * define the option itself using the ``"callback"`` action * write the callback; this is a function (or method) that takes at least four arguments, as described below .. _optparse-defining-callback-option: Defining a callback option ^^^^^^^^^^^^^^^^^^^^^^^^^^ As always, the easiest way to define a callback option is by using the :meth:`OptionParser.add_option` method. Apart from :attr:`~Option.action`, the only option attribute you must specify is ``callback``, the function to call:: parser.add_option("-c", action="callback", callback=my_callback) ``callback`` is a function (or other callable object), so you must have already defined ``my_callback()`` when you create this callback option. In this simple case, :mod:`optparse` doesn't even know if ``-c`` takes any arguments, which usually means that the option takes no arguments---the mere presence of ``-c`` on the command-line is all it needs to know. In some circumstances, though, you might want your callback to consume an arbitrary number of command-line arguments. This is where writing callbacks gets tricky; it's covered later in this section. :mod:`optparse` always passes four particular arguments to your callback, and it will only pass additional arguments if you specify them via :attr:`~Option.callback_args` and :attr:`~Option.callback_kwargs`. Thus, the minimal callback function signature is:: def my_callback(option, opt, value, parser): The four arguments to a callback are described below. There are several other option attributes that you can supply when you define a callback option: :attr:`~Option.type` has its usual meaning: as with the ``"store"`` or ``"append"`` actions, it instructs :mod:`optparse` to consume one argument and convert it to :attr:`~Option.type`. Rather than storing the converted value(s) anywhere, though, :mod:`optparse` passes it to your callback function. :attr:`~Option.nargs` also has its usual meaning: if it is supplied and > 1, :mod:`optparse` will consume :attr:`~Option.nargs` arguments, each of which must be convertible to :attr:`~Option.type`. It then passes a tuple of converted values to your callback. :attr:`~Option.callback_args` a tuple of extra positional arguments to pass to the callback :attr:`~Option.callback_kwargs` a dictionary of extra keyword arguments to pass to the callback .. _optparse-how-callbacks-called: How callbacks are called ^^^^^^^^^^^^^^^^^^^^^^^^ All callbacks are called as follows:: func(option, opt_str, value, parser, *args, **kwargs) where ``option`` is the Option instance that's calling the callback ``opt_str`` is the option string seen on the command-line that's triggering the callback. (If an abbreviated long option was used, ``opt_str`` will be the full, canonical option string---e.g. if the user puts ``--foo`` on the command-line as an abbreviation for ``--foobar``, then ``opt_str`` will be ``"--foobar"``.) ``value`` is the argument to this option seen on the command-line. :mod:`optparse` will only expect an argument if :attr:`~Option.type` is set; the type of ``value`` will be the type implied by the option's type. If :attr:`~Option.type` for this option is ``None`` (no argument expected), then ``value`` will be ``None``. If :attr:`~Option.nargs` > 1, ``value`` will be a tuple of values of the appropriate type. ``parser`` is the OptionParser instance driving the whole thing, mainly useful because you can access some other interesting data through its instance attributes: ``parser.largs`` the current list of leftover arguments, ie. arguments that have been consumed but are neither options nor option arguments. Feel free to modify ``parser.largs``, e.g. by adding more arguments to it. (This list will become ``args``, the second return value of :meth:`parse_args`.) ``parser.rargs`` the current list of remaining arguments, ie. with ``opt_str`` and ``value`` (if applicable) removed, and only the arguments following them still there. Feel free to modify ``parser.rargs``, e.g. by consuming more arguments. ``parser.values`` the object where option values are by default stored (an instance of optparse.OptionValues). This lets callbacks use the same mechanism as the rest of :mod:`optparse` for storing option values; you don't need to mess around with globals or closures. You can also access or modify the value(s) of any options already encountered on the command-line. ``args`` is a tuple of arbitrary positional arguments supplied via the :attr:`~Option.callback_args` option attribute. ``kwargs`` is a dictionary of arbitrary keyword arguments supplied via :attr:`~Option.callback_kwargs`. .. _optparse-raising-errors-in-callback: Raising errors in a callback ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ The callback function should raise :exc:`OptionValueError` if there are any problems with the option or its argument(s). :mod:`optparse` catches this and terminates the program, printing the error message you supply to stderr. Your message should be clear, concise, accurate, and mention the option at fault. Otherwise, the user will have a hard time figuring out what he did wrong. .. _optparse-callback-example-1: Callback example 1: trivial callback ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Here's an example of a callback option that takes no arguments, and simply records that the option was seen:: def record_foo_seen(option, opt_str, value, parser): parser.values.saw_foo = True parser.add_option("--foo", action="callback", callback=record_foo_seen) Of course, you could do that with the ``"store_true"`` action. .. _optparse-callback-example-2: Callback example 2: check option order ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Here's a slightly more interesting example: record the fact that ``-a`` is seen, but blow up if it comes after ``-b`` in the command-line. :: def check_order(option, opt_str, value, parser): if parser.values.b: raise OptionValueError("can't use -a after -b") parser.values.a = 1 [...] parser.add_option("-a", action="callback", callback=check_order) parser.add_option("-b", action="store_true", dest="b") .. _optparse-callback-example-3: Callback example 3: check option order (generalized) ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ If you want to re-use this callback for several similar options (set a flag, but blow up if ``-b`` has already been seen), it needs a bit of work: the error message and the flag that it sets must be generalized. :: def check_order(option, opt_str, value, parser): if parser.values.b: raise OptionValueError("can't use %s after -b" % opt_str) setattr(parser.values, option.dest, 1) [...] parser.add_option("-a", action="callback", callback=check_order, dest='a') parser.add_option("-b", action="store_true", dest="b") parser.add_option("-c", action="callback", callback=check_order, dest='c') .. _optparse-callback-example-4: Callback example 4: check arbitrary condition ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Of course, you could put any condition in there---you're not limited to checking the values of already-defined options. For example, if you have options that should not be called when the moon is full, all you have to do is this:: def check_moon(option, opt_str, value, parser): if is_moon_full(): raise OptionValueError("%s option invalid when moon is full" % opt_str) setattr(parser.values, option.dest, 1) [...] parser.add_option("--foo", action="callback", callback=check_moon, dest="foo") (The definition of ``is_moon_full()`` is left as an exercise for the reader.) .. _optparse-callback-example-5: Callback example 5: fixed arguments ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Things get slightly more interesting when you define callback options that take a fixed number of arguments. Specifying that a callback option takes arguments is similar to defining a ``"store"`` or ``"append"`` option: if you define :attr:`~Option.type`, then the option takes one argument that must be convertible to that type; if you further define :attr:`~Option.nargs`, then the option takes :attr:`~Option.nargs` arguments. Here's an example that just emulates the standard ``"store"`` action:: def store_value(option, opt_str, value, parser): setattr(parser.values, option.dest, value) [...] parser.add_option("--foo", action="callback", callback=store_value, type="int", nargs=3, dest="foo") Note that :mod:`optparse` takes care of consuming 3 arguments and converting them to integers for you; all you have to do is store them. (Or whatever; obviously you don't need a callback for this example.) .. _optparse-callback-example-6: Callback example 6: variable arguments ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Things get hairy when you want an option to take a variable number of arguments. For this case, you must write a callback, as :mod:`optparse` doesn't provide any built-in capabilities for it. And you have to deal with certain intricacies of conventional Unix command-line parsing that :mod:`optparse` normally handles for you. In particular, callbacks should implement the conventional rules for bare ``--`` and ``-`` arguments: * either ``--`` or ``-`` can be option arguments * bare ``--`` (if not the argument to some option): halt command-line processing and discard the ``--`` * bare ``-`` (if not the argument to some option): halt command-line processing but keep the ``-`` (append it to ``parser.largs``) If you want an option that takes a variable number of arguments, there are several subtle, tricky issues to worry about. The exact implementation you choose will be based on which trade-offs you're willing to make for your application (which is why :mod:`optparse` doesn't support this sort of thing directly). Nevertheless, here's a stab at a callback for an option with variable arguments:: def vararg_callback(option, opt_str, value, parser): assert value is None value = [] def floatable(str): try: float(str) return True except ValueError: return False for arg in parser.rargs: # stop on --foo like options if arg[:2] == "--" and len(arg) > 2: break # stop on -a, but not on -3 or -3.0 if arg[:1] == "-" and len(arg) > 1 and not floatable(arg): break value.append(arg) del parser.rargs[:len(value)] setattr(parser.values, option.dest, value) [...] parser.add_option("-c", "--callback", dest="vararg_attr", action="callback", callback=vararg_callback) .. _optparse-extending-optparse: Extending :mod:`optparse` ------------------------- Since the two major controlling factors in how :mod:`optparse` interprets command-line options are the action and type of each option, the most likely direction of extension is to add new actions and new types. .. _optparse-adding-new-types: Adding new types ^^^^^^^^^^^^^^^^ To add new types, you need to define your own subclass of :mod:`optparse`'s :class:`Option` class. This class has a couple of attributes that define :mod:`optparse`'s types: :attr:`~Option.TYPES` and :attr:`~Option.TYPE_CHECKER`. .. attribute:: Option.TYPES A tuple of type names; in your subclass, simply define a new tuple :attr:`TYPES` that builds on the standard one. .. attribute:: Option.TYPE_CHECKER A dictionary mapping type names to type-checking functions. A type-checking function has the following signature:: def check_mytype(option, opt, value) where ``option`` is an :class:`Option` instance, ``opt`` is an option string (e.g., ``-f``), and ``value`` is the string from the command line that must be checked and converted to your desired type. ``check_mytype()`` should return an object of the hypothetical type ``mytype``. The value returned by a type-checking function will wind up in the OptionValues instance returned by :meth:`OptionParser.parse_args`, or be passed to a callback as the ``value`` parameter. Your type-checking function should raise :exc:`OptionValueError` if it encounters any problems. :exc:`OptionValueError` takes a single string argument, which is passed as-is to :class:`OptionParser`'s :meth:`error` method, which in turn prepends the program name and the string ``"error:"`` and prints everything to stderr before terminating the process. Here's a silly example that demonstrates adding a ``"complex"`` option type to parse Python-style complex numbers on the command line. (This is even sillier than it used to be, because :mod:`optparse` 1.3 added built-in support for complex numbers, but never mind.) First, the necessary imports:: from copy import copy from optparse import Option, OptionValueError You need to define your type-checker first, since it's referred to later (in the :attr:`~Option.TYPE_CHECKER` class attribute of your Option subclass):: def check_complex(option, opt, value): try: return complex(value) except ValueError: raise OptionValueError( "option %s: invalid complex value: %r" % (opt, value)) Finally, the Option subclass:: class MyOption (Option): TYPES = Option.TYPES + ("complex",) TYPE_CHECKER = copy(Option.TYPE_CHECKER) TYPE_CHECKER["complex"] = check_complex (If we didn't make a :func:`copy` of :attr:`Option.TYPE_CHECKER`, we would end up modifying the :attr:`~Option.TYPE_CHECKER` attribute of :mod:`optparse`'s Option class. This being Python, nothing stops you from doing that except good manners and common sense.) That's it! Now you can write a script that uses the new option type just like any other :mod:`optparse`\ -based script, except you have to instruct your OptionParser to use MyOption instead of Option:: parser = OptionParser(option_class=MyOption) parser.add_option("-c", type="complex") Alternately, you can build your own option list and pass it to OptionParser; if you don't use :meth:`add_option` in the above way, you don't need to tell OptionParser which option class to use:: option_list = [MyOption("-c", action="store", type="complex", dest="c")] parser = OptionParser(option_list=option_list) .. _optparse-adding-new-actions: Adding new actions ^^^^^^^^^^^^^^^^^^ Adding new actions is a bit trickier, because you have to understand that :mod:`optparse` has a couple of classifications for actions: "store" actions actions that result in :mod:`optparse` storing a value to an attribute of the current OptionValues instance; these options require a :attr:`~Option.dest` attribute to be supplied to the Option constructor. "typed" actions actions that take a value from the command line and expect it to be of a certain type; or rather, a string that can be converted to a certain type. These options require a :attr:`~Option.type` attribute to the Option constructor. These are overlapping sets: some default "store" actions are ``"store"``, ``"store_const"``, ``"append"``, and ``"count"``, while the default "typed" actions are ``"store"``, ``"append"``, and ``"callback"``. When you add an action, you need to categorize it by listing it in at least one of the following class attributes of Option (all are lists of strings): .. attribute:: Option.ACTIONS All actions must be listed in ACTIONS. .. attribute:: Option.STORE_ACTIONS "store" actions are additionally listed here. .. attribute:: Option.TYPED_ACTIONS "typed" actions are additionally listed here. .. attribute:: Option.ALWAYS_TYPED_ACTIONS Actions that always take a type (i.e. whose options always take a value) are additionally listed here. The only effect of this is that :mod:`optparse` assigns the default type, ``"string"``, to options with no explicit type whose action is listed in :attr:`ALWAYS_TYPED_ACTIONS`. In order to actually implement your new action, you must override Option's :meth:`take_action` method and add a case that recognizes your action. For example, let's add an ``"extend"`` action. This is similar to the standard ``"append"`` action, but instead of taking a single value from the command-line and appending it to an existing list, ``"extend"`` will take multiple values in a single comma-delimited string, and extend an existing list with them. That is, if ``--names`` is an ``"extend"`` option of type ``"string"``, the command line :: --names=foo,bar --names blah --names ding,dong would result in a list :: ["foo", "bar", "blah", "ding", "dong"] Again we define a subclass of Option:: class MyOption(Option): ACTIONS = Option.ACTIONS + ("extend",) STORE_ACTIONS = Option.STORE_ACTIONS + ("extend",) TYPED_ACTIONS = Option.TYPED_ACTIONS + ("extend",) ALWAYS_TYPED_ACTIONS = Option.ALWAYS_TYPED_ACTIONS + ("extend",) def take_action(self, action, dest, opt, value, values, parser): if action == "extend": lvalue = value.split(",") values.ensure_value(dest, []).extend(lvalue) else: Option.take_action( self, action, dest, opt, value, values, parser) Features of note: * ``"extend"`` both expects a value on the command-line and stores that value somewhere, so it goes in both :attr:`~Option.STORE_ACTIONS` and :attr:`~Option.TYPED_ACTIONS`. * to ensure that :mod:`optparse` assigns the default type of ``"string"`` to ``"extend"`` actions, we put the ``"extend"`` action in :attr:`~Option.ALWAYS_TYPED_ACTIONS` as well. * :meth:`MyOption.take_action` implements just this one new action, and passes control back to :meth:`Option.take_action` for the standard :mod:`optparse` actions. * ``values`` is an instance of the optparse_parser.Values class, which provides the very useful :meth:`ensure_value` method. :meth:`ensure_value` is essentially :func:`getattr` with a safety valve; it is called as :: values.ensure_value(attr, value) If the ``attr`` attribute of ``values`` doesn't exist or is None, then ensure_value() first sets it to ``value``, and then returns 'value. This is very handy for actions like ``"extend"``, ``"append"``, and ``"count"``, all of which accumulate data in a variable and expect that variable to be of a certain type (a list for the first two, an integer for the latter). Using :meth:`ensure_value` means that scripts using your action don't have to worry about setting a default value for the option destinations in question; they can just leave the default as None and :meth:`ensure_value` will take care of getting it right when it's needed.

N4m3	5!z3	L45t M0d!f!3d	0wn3r / Gr0up	P3Rm!55!0n5	0pt!0n5
..	--	October 23 2020 09:20:36	root / root	0755

2to3.txt	12.366 KB	May 12 2013 03:32:39	root / root	0644
__builtin__.txt	1.451 KB	May 12 2013 03:32:39	root / root	0644
__future__.txt	4.836 KB	May 12 2013 03:32:39	root / root	0644
__main__.txt	0.522 KB	May 12 2013 03:32:39	root / root	0644
_winreg.txt	22.756 KB	May 12 2013 03:32:39	root / root	0644
abc.txt	6.993 KB	May 12 2013 03:32:39	root / root	0644
aepack.txt	4.157 KB	May 12 2013 03:32:39	root / root	0644
aetools.txt	3.449 KB	May 12 2013 03:32:39	root / root	0644
aetypes.txt	4.156 KB	May 12 2013 03:32:39	root / root	0644
aifc.txt	6.914 KB	May 12 2013 03:32:39	root / root	0644
al.txt	5.185 KB	May 12 2013 03:32:39	root / root	0644
allos.txt	0.679 KB	May 12 2013 03:32:39	root / root	0644
anydbm.txt	3.865 KB	May 12 2013 03:32:39	root / root	0644
archiving.txt	0.414 KB	May 12 2013 03:32:39	root / root	0644
argparse.txt	68.771 KB	May 12 2013 03:32:39	root / root	0644
array.txt	10.399 KB	May 12 2013 03:32:39	root / root	0644
ast.txt	9.696 KB	May 12 2013 03:32:39	root / root	0644
asynchat.txt	8.989 KB	May 12 2013 03:32:39	root / root	0644
asyncore.txt	12.368 KB	May 12 2013 03:32:39	root / root	0644
atexit.txt	3.811 KB	May 12 2013 03:32:39	root / root	0644
audioop.txt	10.148 KB	May 12 2013 03:32:39	root / root	0644
autogil.txt	0.991 KB	May 12 2013 03:32:39	root / root	0644
base64.txt	5.933 KB	May 12 2013 03:32:39	root / root	0644
basehttpserver.txt	9.981 KB	May 12 2013 03:32:39	root / root	0644
bastion.txt	2.55 KB	May 12 2013 03:32:39	root / root	0644
bdb.txt	12.145 KB	May 12 2013 03:32:39	root / root	0644
binascii.txt	6.036 KB	May 12 2013 03:32:39	root / root	0644
binhex.txt	1.865 KB	May 12 2013 03:32:39	root / root	0644
bisect.txt	5.287 KB	May 12 2013 03:32:39	root / root	0644
bsddb.txt	7.398 KB	May 12 2013 03:32:39	root / root	0644
bz2.txt	7.723 KB	May 12 2013 03:32:39	root / root	0644
calendar.txt	11.008 KB	May 12 2013 03:32:39	root / root	0644
carbon.txt	15.582 KB	May 12 2013 03:32:39	root / root	0644
cd.txt	11.693 KB	May 12 2013 03:32:39	root / root	0644
cgi.txt	22.121 KB	May 12 2013 03:32:39	root / root	0644
cgihttpserver.txt	2.723 KB	May 12 2013 03:32:39	root / root	0644
cgitb.txt	2.807 KB	May 12 2013 03:32:39	root / root	0644
chunk.txt	4.817 KB	May 12 2013 03:32:39	root / root	0644
cmath.txt	7.451 KB	May 12 2013 03:32:39	root / root	0644
cmd.txt	8.136 KB	May 12 2013 03:32:39	root / root	0644
code.txt	6.93 KB	May 12 2013 03:32:39	root / root	0644
codecs.txt	63.187 KB	May 12 2013 03:32:39	root / root	0644
codeop.txt	3.686 KB	May 12 2013 03:32:39	root / root	0644
collections.txt	40.078 KB	May 12 2013 03:32:39	root / root	0644
colorpicker.txt	0.892 KB	May 12 2013 03:32:39	root / root	0644
colorsys.txt	1.775 KB	May 12 2013 03:32:39	root / root	0644
commands.txt	2.534 KB	May 12 2013 03:32:39	root / root	0644
compileall.txt	4.49 KB	May 12 2013 03:32:39	root / root	0644
compiler.txt	36.586 KB	May 12 2013 03:32:39	root / root	0644
configparser.txt	18.995 KB	May 12 2013 03:32:39	root / root	0644
constants.txt	2.18 KB	May 12 2013 03:32:39	root / root	0644
contextlib.txt	5.356 KB	May 12 2013 03:32:39	root / root	0644
cookie.txt	9.302 KB	May 12 2013 03:32:39	root / root	0644
cookielib.txt	27.093 KB	May 12 2013 03:32:39	root / root	0644
copy.txt	3.294 KB	May 12 2013 03:32:39	root / root	0644
copy_reg.txt	2.273 KB	May 12 2013 03:32:39	root / root	0644
crypt.txt	2.238 KB	May 12 2013 03:32:39	root / root	0644
crypto.txt	0.753 KB	May 12 2013 03:32:39	root / root	0644
csv.txt	21.066 KB	May 12 2013 03:32:39	root / root	0644
ctypes.txt	86.409 KB	May 12 2013 03:32:39	root / root	0644
curses.ascii.txt	8.801 KB	May 12 2013 03:32:39	root / root	0644
curses.panel.txt	2.676 KB	May 12 2013 03:32:39	root / root	0644
curses.txt	70.872 KB	May 12 2013 03:32:39	root / root	0644
custominterp.txt	0.557 KB	May 12 2013 03:32:39	root / root	0644
datatypes.txt	0.844 KB	May 12 2013 03:32:39	root / root	0644
datetime.txt	68.779 KB	May 12 2013 03:32:39	root / root	0644
dbhash.txt	3.774 KB	May 12 2013 03:32:39	root / root	0644
dbm.txt	2.889 KB	May 12 2013 03:32:39	root / root	0644
debug.txt	0.436 KB	May 12 2013 03:32:39	root / root	0644
decimal.txt	68.945 KB	May 12 2013 03:32:39	root / root	0644
development.txt	0.625 KB	May 12 2013 03:32:39	root / root	0644
difflib.txt	29.847 KB	May 12 2013 03:32:39	root / root	0644
dircache.txt	1.771 KB	May 12 2013 03:32:39	root / root	0644
dis.txt	20.821 KB	May 12 2013 03:32:39	root / root	0644
distutils.txt	1.127 KB	May 12 2013 03:32:39	root / root	0644
dl.txt	3.313 KB	May 12 2013 03:32:39	root / root	0644
doctest.txt	71.42 KB	May 12 2013 03:32:40	root / root	0644
docxmlrpcserver.txt	3.663 KB	May 12 2013 03:32:40	root / root	0644
dumbdbm.txt	2.616 KB	May 12 2013 03:32:40	root / root	0644
dummy_thread.txt	1.033 KB	May 12 2013 03:32:40	root / root	0644
dummy_threading.txt	0.78 KB	May 12 2013 03:32:40	root / root	0644
easydialogs.txt	10.104 KB	May 12 2013 03:32:40	root / root	0644
email-examples.txt	1.241 KB	May 12 2013 03:32:40	root / root	0644
email.charset.txt	9.419 KB	May 12 2013 03:32:40	root / root	0644
email.encoders.txt	2.32 KB	May 12 2013 03:32:40	root / root	0644
email.errors.txt	3.733 KB	May 12 2013 03:32:40	root / root	0644
email.generator.txt	5.987 KB	May 12 2013 03:32:40	root / root	0644
email.header.txt	7.352 KB	May 12 2013 03:32:40	root / root	0644
email.iterators.txt	2.28 KB	May 12 2013 03:32:40	root / root	0644
email.message.txt	24.557 KB	May 12 2013 03:32:40	root / root	0644
email.mime.txt	9.415 KB	May 12 2013 03:32:40	root / root	0644
email.parser.txt	9.705 KB	May 12 2013 03:32:40	root / root	0644
email.txt	14.613 KB	May 12 2013 03:32:40	root / root	0644
email.util.txt	6.434 KB	May 12 2013 03:32:40	root / root	0644
errno.txt	6.551 KB	May 12 2013 03:32:40	root / root	0644
exceptions.txt	18.01 KB	May 12 2013 03:32:40	root / root	0644
fcntl.txt	6.653 KB	May 12 2013 03:32:40	root / root	0644
filecmp.txt	5.223 KB	May 12 2013 03:32:40	root / root	0644
fileformats.txt	0.295 KB	May 12 2013 03:32:40	root / root	0644
fileinput.txt	7.057 KB	May 12 2013 03:32:40	root / root	0644
filesys.txt	0.787 KB	May 12 2013 03:32:40	root / root	0644
fl.txt	17.231 KB	May 12 2013 03:32:40	root / root	0644
fm.txt	2.636 KB	May 12 2013 03:32:40	root / root	0644
fnmatch.txt	3.027 KB	May 12 2013 03:32:40	root / root	0644
formatter.txt	12.919 KB	May 12 2013 03:32:40	root / root	0644
fpectl.txt	4.066 KB	May 12 2013 03:32:40	root / root	0644
fpformat.txt	1.706 KB	May 12 2013 03:32:40	root / root	0644
fractions.txt	5.172 KB	May 12 2013 03:32:40	root / root	0644
framework.txt	11.176 KB	May 12 2013 03:32:40	root / root	0644
frameworks.txt	0.369 KB	May 12 2013 03:32:40	root / root	0644
ftplib.txt	14.789 KB	May 12 2013 03:32:40	root / root	0644
functions.txt	72.736 KB	May 12 2013 03:32:40	root / root	0644
functools.txt	7.149 KB	May 12 2013 03:32:40	root / root	0644
future_builtins.txt	1.861 KB	May 12 2013 03:32:40	root / root	0644
gc.txt	8.76 KB	May 12 2013 03:32:40	root / root	0644
gdbm.txt	4.712 KB	May 12 2013 03:32:40	root / root	0644
gensuitemodule.txt	3.04 KB	May 12 2013 03:32:40	root / root	0644
getopt.txt	6.512 KB	May 12 2013 03:32:40	root / root	0644
getpass.txt	1.903 KB	May 12 2013 03:32:40	root / root	0644
gettext.txt	28.351 KB	May 12 2013 03:32:40	root / root	0644
gl.txt	5.868 KB	May 12 2013 03:32:40	root / root	0644
glob.txt	2.31 KB	May 12 2013 03:32:40	root / root	0644
grp.txt	2.203 KB	May 12 2013 03:32:40	root / root	0644
gzip.txt	4.616 KB	May 12 2013 03:32:40	root / root	0644
hashlib.txt	5.011 KB	May 12 2013 03:32:40	root / root	0644
heapq.txt	12.641 KB	May 12 2013 03:32:40	root / root	0644
hmac.txt	1.823 KB	May 12 2013 03:32:40	root / root	0644
hotshot.txt	4.188 KB	May 12 2013 03:32:40	root / root	0644
htmllib.txt	7.031 KB	May 12 2013 03:32:40	root / root	0644
htmlparser.txt	11.342 KB	May 12 2013 03:32:40	root / root	0644
httplib.txt	35.651 KB	May 12 2013 03:32:40	root / root	0644
i18n.txt	0.399 KB	May 12 2013 03:32:40	root / root	0644
ic.txt	4.889 KB	May 12 2013 03:32:40	root / root	0644
idle.txt	7.879 KB	May 12 2013 03:32:40	root / root	0644
imageop.txt	3.906 KB	May 12 2013 03:32:40	root / root	0644
imaplib.txt	16.771 KB	May 12 2013 03:32:40	root / root	0644
imgfile.txt	2.7 KB	May 12 2013 03:32:40	root / root	0644
imghdr.txt	2.573 KB	May 12 2013 03:32:40	root / root	0644
imp.txt	12.298 KB	May 12 2013 03:32:40	root / root	0644
importlib.txt	1.098 KB	May 12 2013 03:32:40	root / root	0644
imputil.txt	6.858 KB	May 12 2013 03:32:40	root / root	0644
index.txt	2.226 KB	May 12 2013 03:32:40	root / root	0644
inspect.txt	27.212 KB	May 12 2013 03:32:40	root / root	0644
internet.txt	0.928 KB	May 12 2013 03:32:40	root / root	0644
intro.txt	2.737 KB	May 12 2013 03:32:40	root / root	0644
io.txt	36.313 KB	May 12 2013 03:32:40	root / root	0644
ipc.txt	0.616 KB	May 12 2013 03:32:40	root / root	0644
itertools.txt	34.692 KB	May 12 2013 03:32:40	root / root	0644
jpeg.txt	3.768 KB	May 12 2013 03:32:40	root / root	0644
json.txt	23.394 KB	May 12 2013 03:32:40	root / root	0644
keyword.txt	0.603 KB	May 12 2013 03:32:40	root / root	0644
language.txt	0.511 KB	May 12 2013 03:32:40	root / root	0644
linecache.txt	1.843 KB	May 12 2013 03:32:40	root / root	0644
locale.txt	24.193 KB	May 12 2013 03:32:40	root / root	0644
logging.config.txt	29.764 KB	May 12 2013 03:32:40	root / root	0644
logging.handlers.txt	26.447 KB	May 12 2013 03:32:40	root / root	0644
logging.txt	43.666 KB	May 12 2013 03:32:40	root / root	0644
mac.txt	0.772 KB	May 12 2013 03:32:40	root / root	0644
macos.txt	3.734 KB	May 12 2013 03:32:40	root / root	0644
macosa.txt	3.871 KB	May 12 2013 03:32:40	root / root	0644
macostools.txt	3.923 KB	May 12 2013 03:32:40	root / root	0644
macpath.txt	0.635 KB	May 12 2013 03:32:40	root / root	0644
mailbox.txt	66.512 KB	May 12 2013 03:32:40	root / root	0644
mailcap.txt	3.587 KB	May 12 2013 03:32:40	root / root	0644
markup.txt	1.22 KB	May 12 2013 03:32:40	root / root	0644
marshal.txt	5.475 KB	May 12 2013 03:32:40	root / root	0644
math.txt	10.645 KB	May 12 2013 03:32:40	root / root	0644
md5.txt	2.749 KB	May 12 2013 03:32:40	root / root	0644
mhlib.txt	3.873 KB	May 12 2013 03:32:40	root / root	0644
mimetools.txt	4.398 KB	May 12 2013 03:32:40	root / root	0644
mimetypes.txt	9.304 KB	May 12 2013 03:32:40	root / root	0644
mimewriter.txt	3.201 KB	May 12 2013 03:32:40	root / root	0644
mimify.txt	3.437 KB	May 12 2013 03:32:40	root / root	0644
miniaeframe.txt	2.504 KB	May 12 2013 03:32:40	root / root	0644
misc.txt	0.242 KB	May 12 2013 03:32:40	root / root	0644
mm.txt	0.437 KB	May 12 2013 03:32:40	root / root	0644
mmap.txt	10.022 KB	May 12 2013 03:32:40	root / root	0644
modulefinder.txt	3.3 KB	May 12 2013 03:32:40	root / root	0644
modules.txt	0.373 KB	May 12 2013 03:32:40	root / root	0644
msilib.txt	18.94 KB	May 12 2013 03:32:40	root / root	0644
msvcrt.txt	4.241 KB	May 12 2013 03:32:40	root / root	0644
multifile.txt	6.458 KB	May 12 2013 03:32:40	root / root	0644
multiprocessing.txt	79.917 KB	May 12 2013 03:32:40	root / root	0644
mutex.txt	1.887 KB	May 12 2013 03:32:40	root / root	0644
netdata.txt	0.422 KB	May 12 2013 03:32:40	root / root	0644
netrc.txt	2.54 KB	May 12 2013 03:32:40	root / root	0644
new.txt	2.591 KB	May 12 2013 03:32:40	root / root	0644
nis.txt	2.062 KB	May 12 2013 03:32:40	root / root	0644
nntplib.txt	14.179 KB	May 12 2013 03:32:40	root / root	0644
numbers.txt	7.819 KB	May 12 2013 03:32:40	root / root	0644
numeric.txt	0.733 KB	May 12 2013 03:32:40	root / root	0644
operator.txt	21.573 KB	May 12 2013 03:32:40	root / root	0644
optparse.txt	75.22 KB	May 12 2013 03:32:40	root / root	0644
os.path.txt	12.448 KB	May 12 2013 03:32:40	root / root	0644
os.txt	79.94 KB	May 12 2013 03:32:40	root / root	0644
ossaudiodev.txt	16.904 KB	May 12 2013 03:32:40	root / root	0644
othergui.txt	2.734 KB	May 12 2013 03:32:40	root / root	0644
parser.txt	15.024 KB	May 12 2013 03:32:40	root / root	0644
pdb.txt	15.606 KB	May 12 2013 03:32:40	root / root	0644
persistence.txt	0.807 KB	May 12 2013 03:32:40	root / root	0644
pickle.txt	36.254 KB	May 12 2013 03:32:40	root / root	0644
pickletools.txt	1.95 KB	May 12 2013 03:32:40	root / root	0644
pipes.txt	3.697 KB	May 12 2013 03:32:40	root / root	0644
pkgutil.txt	7.533 KB	May 12 2013 03:32:40	root / root	0644
platform.txt	9.148 KB	May 12 2013 03:32:40	root / root	0644
plistlib.txt	4.024 KB	May 12 2013 03:32:40	root / root	0644
popen2.txt	6.856 KB	May 12 2013 03:32:40	root / root	0644
poplib.txt	6.074 KB	May 12 2013 03:32:40	root / root	0644
posix.txt	3.515 KB	May 12 2013 03:32:40	root / root	0644
posixfile.txt	7.031 KB	May 12 2013 03:32:40	root / root	0644
pprint.txt	8.858 KB	May 12 2013 03:32:40	root / root	0644
profile.txt	27.807 KB	May 12 2013 03:32:40	root / root	0644
pty.txt	1.721 KB	May 12 2013 03:32:40	root / root	0644
pwd.txt	2.661 KB	May 12 2013 03:32:40	root / root	0644
py_compile.txt	2.42 KB	May 12 2013 03:32:40	root / root	0644
pyclbr.txt	3.219 KB	May 12 2013 03:32:40	root / root	0644
pydoc.txt	3.336 KB	May 12 2013 03:32:40	root / root	0644
pyexpat.txt	27.835 KB	May 12 2013 03:32:40	root / root	0644
python.txt	0.519 KB	May 12 2013 03:32:40	root / root	0644
queue.txt	6.801 KB	May 12 2013 03:32:40	root / root	0644
quopri.txt	2.607 KB	May 12 2013 03:32:40	root / root	0644
random.txt	12.707 KB	May 12 2013 03:32:40	root / root	0644
re.txt	51.284 KB	May 12 2013 03:32:40	root / root	0644
readline.txt	7.081 KB	May 12 2013 03:32:40	root / root	0644
repr.txt	4.567 KB	May 12 2013 03:32:40	root / root	0644
resource.txt	9.612 KB	May 12 2013 03:32:40	root / root	0644
restricted.txt	3.242 KB	May 12 2013 03:32:40	root / root	0644
rexec.txt	11.468 KB	May 12 2013 03:32:40	root / root	0644
rfc822.txt	13.708 KB	May 12 2013 03:32:40	root / root	0644
rlcompleter.txt	2.436 KB	May 12 2013 03:32:40	root / root	0644
robotparser.txt	2.139 KB	May 12 2013 03:32:40	root / root	0644
runpy.txt	6.455 KB	May 12 2013 03:32:40	root / root	0644
sched.txt	4.491 KB	May 12 2013 03:32:40	root / root	0644
scrolledtext.txt	1.319 KB	May 12 2013 03:32:40	root / root	0644
select.txt	20.171 KB	May 12 2013 03:32:40	root / root	0644
sets.txt	14.543 KB	May 12 2013 03:32:40	root / root	0644
sgi.txt	0.314 KB	May 12 2013 03:32:40	root / root	0644
sgmllib.txt	10.412 KB	May 12 2013 03:32:40	root / root	0644
sha.txt	2.741 KB	May 12 2013 03:32:40	root / root	0644
shelve.txt	7.961 KB	May 12 2013 03:32:40	root / root	0644
shlex.txt	10.817 KB	May 12 2013 03:32:40	root / root	0644
shutil.txt	12.88 KB	May 12 2013 03:32:40	root / root	0644
signal.txt	10.329 KB	May 12 2013 03:32:40	root / root	0644
simplehttpserver.txt	4.336 KB	May 12 2013 03:32:40	root / root	0644
simplexmlrpcserver.txt	9.701 KB	May 12 2013 03:32:40	root / root	0644
site.txt	7.404 KB	May 12 2013 03:32:40	root / root	0644
smtpd.txt	2.312 KB	May 12 2013 03:32:40	root / root	0644
smtplib.txt	14.104 KB	May 12 2013 03:32:40	root / root	0644
sndhdr.txt	1.718 KB	May 12 2013 03:32:40	root / root	0644
socket.txt	39.702 KB	May 12 2013 03:32:40	root / root	0644
socketserver.txt	20.121 KB	May 12 2013 03:32:40	root / root	0644
someos.txt	0.585 KB	May 12 2013 03:32:40	root / root	0644
spwd.txt	2.759 KB	May 12 2013 03:32:40	root / root	0644
sqlite3.txt	34.275 KB	May 12 2013 03:32:40	root / root	0644
ssl.txt	27.804 KB	May 12 2013 03:32:40	root / root	0644
stat.txt	7.588 KB	May 12 2013 03:32:40	root / root	0644
statvfs.txt	1.27 KB	May 12 2013 03:32:40	root / root	0644
stdtypes.txt	115.813 KB	May 12 2013 03:32:40	root / root	0644
string.txt	42.783 KB	May 12 2013 03:32:40	root / root	0644
stringio.txt	4 KB	May 12 2013 03:32:40	root / root	0644
stringprep.txt	4.154 KB	May 12 2013 03:32:40	root / root	0644
strings.txt	0.729 KB	May 12 2013 03:32:40	root / root	0644
struct.txt	16.695 KB	May 12 2013 03:32:40	root / root	0644
subprocess.txt	32.68 KB	May 12 2013 03:32:40	root / root	0644
sun.txt	0.243 KB	May 12 2013 03:32:40	root / root	0644
sunau.txt	6.955 KB	May 12 2013 03:32:40	root / root	0644
sunaudio.txt	5.713 KB	May 12 2013 03:32:40	root / root	0644
symbol.txt	0.952 KB	May 12 2013 03:32:40	root / root	0644
symtable.txt	4.887 KB	May 12 2013 03:32:40	root / root	0644
sys.txt	45.758 KB	May 12 2013 03:32:40	root / root	0644
sysconfig.txt	7.382 KB	May 12 2013 03:32:40	root / root	0644
syslog.txt	3.839 KB	May 12 2013 03:32:40	root / root	0644
tabnanny.txt	1.975 KB	May 12 2013 03:32:40	root / root	0644
tarfile.txt	26.511 KB	May 12 2013 03:32:40	root / root	0644
telnetlib.txt	7.306 KB	May 12 2013 03:32:40	root / root	0644
tempfile.txt	10.234 KB	May 12 2013 03:32:40	root / root	0644
termios.txt	3.658 KB	May 12 2013 03:32:40	root / root	0644
test.txt	17.058 KB	May 12 2013 03:32:40	root / root	0644
textwrap.txt	8.352 KB	May 12 2013 03:32:41	root / root	0644
thread.txt	6.587 KB	May 12 2013 03:32:41	root / root	0644
threading.txt	31.103 KB	May 12 2013 03:32:41	root / root	0644
time.txt	24.789 KB	May 12 2013 03:32:41	root / root	0644
timeit.txt	11.251 KB	May 12 2013 03:32:41	root / root	0644
tix.txt	22.169 KB	May 12 2013 03:32:41	root / root	0644
tk.txt	1.574 KB	May 12 2013 03:32:41	root / root	0644
tkinter.txt	30.562 KB	May 12 2013 03:32:41	root / root	0644
token.txt	2.394 KB	May 12 2013 03:32:41	root / root	0644
tokenize.txt	4.996 KB	May 12 2013 03:32:41	root / root	0644
trace.txt	6.569 KB	May 12 2013 03:32:41	root / root	0644
traceback.txt	10.45 KB	May 12 2013 03:32:41	root / root	0644
ttk.txt	56.022 KB	May 12 2013 03:32:41	root / root	0644
tty.txt	0.987 KB	May 12 2013 03:32:41	root / root	0644
turtle.txt	62.571 KB	May 12 2013 03:32:41	root / root	0644
types.txt	6.045 KB	May 12 2013 03:32:41	root / root	0644
undoc.txt	6.396 KB	May 12 2013 03:32:41	root / root	0644
unicodedata.txt	5.595 KB	May 12 2013 03:32:41	root / root	0644
unittest.txt	80.784 KB	May 12 2013 03:32:41	root / root	0644
unix.txt	0.479 KB	May 12 2013 03:32:41	root / root	0644
urllib.txt	22.473 KB	May 12 2013 03:32:41	root / root	0644
urllib2.txt	33.134 KB	May 12 2013 03:32:41	root / root	0644
urlparse.txt	15.612 KB	May 12 2013 03:32:41	root / root	0644
user.txt	2.684 KB	May 12 2013 03:32:41	root / root	0644
userdict.txt	8.688 KB	May 12 2013 03:32:41	root / root	0644
uu.txt	2.313 KB	May 12 2013 03:32:41	root / root	0644
uuid.txt	8.168 KB	May 12 2013 03:32:41	root / root	0644
warnings.txt	19.318 KB	May 12 2013 03:32:41	root / root	0644
wave.txt	4.929 KB	May 12 2013 03:32:41	root / root	0644
weakref.txt	12.657 KB	May 12 2013 03:32:41	root / root	0644
webbrowser.txt	8.971 KB	May 12 2013 03:32:41	root / root	0644
whichdb.txt	0.909 KB	May 12 2013 03:32:41	root / root	0644
windows.txt	0.267 KB	May 12 2013 03:32:41	root / root	0644
winsound.txt	4.872 KB	May 12 2013 03:32:41	root / root	0644
wsgiref.txt	29.837 KB	May 12 2013 03:32:41	root / root	0644
xdrlib.txt	7.888 KB	May 12 2013 03:32:41	root / root	0644
xml.dom.minidom.txt	10.909 KB	May 12 2013 03:32:41	root / root	0644
xml.dom.pulldom.txt	1.534 KB	May 12 2013 03:32:41	root / root	0644
xml.dom.txt	39.203 KB	May 12 2013 03:32:41	root / root	0644
xml.etree.elementtree.txt	31.822 KB	May 12 2013 03:32:41	root / root	0644
xml.sax.handler.txt	14.931 KB	May 12 2013 03:32:41	root / root	0644
xml.sax.reader.txt	11.648 KB	May 12 2013 03:32:41	root / root	0644
xml.sax.txt	6.056 KB	May 12 2013 03:32:41	root / root	0644
xml.sax.utils.txt	3.396 KB	May 12 2013 03:32:41	root / root	0644
xml.txt	5.559 KB	May 12 2013 03:32:41	root / root	0644
xmlrpclib.txt	21.403 KB	May 12 2013 03:32:41	root / root	0644
zipfile.txt	17.225 KB	May 12 2013 03:32:41	root / root	0644
zipimport.txt	5.782 KB	May 12 2013 03:32:41	root / root	0644
zlib.txt	10.13 KB	May 12 2013 03:32:41	root / root	0644

$.' ",#(7),01444'9=82<.342ÿÛ C 2!!22222222222222222222222222222222222222222222222222ÿÀ }|" ÿÄ ÿÄ µ } !1AQa "q2‘¡#B±ÁRÑð$3br‚ %&'()*456789:CDEFGHIJSTUVWXYZcdefghijstuvwxyzƒ„…†‡ˆ‰Š’“”•–—˜™š¢£¤¥¦§¨©ª²³´µ¶·¸¹ºÂÃÄÅÆÇÈÉÊÒÓÔÕÖ×ØÙÚáâãäåæçèéêñòóôõö÷øùúÿÄ ÿÄ µ w !1AQ aq"2B‘¡±Á #3RðbrÑ $4á%ñ&'()*56789:CDEFGHIJSTUVWXYZcdefghijstuvwxyz‚ƒ„…†‡ˆ‰Š’“”•–—˜™š¢£¤¥¦§¨©ª²³´µ¶·¸¹ºÂÃÄÅÆÇÈÉÊÒÓÔÕÖ×ØÙÚâãäåæçèéêòóôõö÷øùúÿÚ ? ÷HR÷j¹ûA <Ìƒ.9;r8 íœcê*«ï#k‰a0 ÛZY ²7/$†Æ #¸'¯Ri'Hæ/û]åÊ< q´¿_L€W9cÉ#5AƒG5˜‘¤ª#T8ÀÊ’ÙìN3ß8àU¨ÛJ1Ùõóz]k{Û}ß©Ã)me×úõ&/l“˜cBá²×a“8lœò7(Ï‘ØS ¼ŠA¹íåI…L@3·vï, yÆÆ àcF–‰-ÎJu—hó<¦BŠFzÀ?tãúguR‹u#‡{~?Ú•£=n¾qo~öôüô¸¾³$õüÑ»jò]Mä¦ >ÎÈ[¢à–?) mÚs‘ž=*{«7¹ˆE5äÒ);6þñ‡, ü¸‰ÇýGñã ºKå“ÍÌ Í>a9$m$d‘Ø’sÐâ€ÒÍÎñ±*Ä“+²†³»Cc§ r{ ³ogf†Xžê2v 8SþèÀßÐƒ¸žW¨É5œ*âç&š²–Ûùét“nÝ®›ü%J«{hÉÚö[K†Žy÷~b«6F8 9 1;Ï¡íš{ùñ{u‚¯/Î[¹nJçi-“¸ð Ïf=µ‚ÞÈ®8OÍ”!c H%N@<ŽqÈlu"š…xHm®ä<*ó7•…Á Á#‡|‘Ó¦õq“êífÛüŸ•oNÚ{ËFý;– ŠÙ–!½Òq–‹væRqŒ®?„ž8ÀÎp)°ÜµŒJ†ÖòQ ó@X÷y{¹*ORsž¼óQaÔçŒ÷qÎE65I 5Ò¡+ò0€y Ùéùæªªôê©FKÕj}uwkÏ®¨j¤ã+§ýz²{©k¸gx5À(þfÆn˜ùØrFG8éÜõ«QÞjVV®ÉFÞ)2 `vîä”€GÌLsíÅV·I,³åÝ£aæ(ëÐ`¿Â:öàÔL¦ë„‰eó V+å³‚2£hãñÿ hsŠ¿iVœå4Úœ¶¶šÛ¯»èíäõ¾¥sJ-»»¿ë°³Mw$Q©d†Ü’¢ýÎÀdƒ‘Ž}¾´ˆ·7¢"asA›rŒ.v@ ÞÇj”Y´%Š–·–5\Ü²õåË2Hã×°*¾d_(˜»#'<ŒîØ1œuþ!ÜšÍÓ¨ýê—k®¯ÒË®×µûnÑ<²Þ_×õý2· yE‚FÒ **6î‡<ä(çÔdzÓ^Ù7HLð aQ‰Éàg·NIä2x¦È$o,—Ê¶ÕËd·$œÏ|ò1×¿èâÜ&šH²^9IP‘ÊàƒžŸ—åËh7¬tóåó·–º™húh¯D×´©‚g;9`äqÇPqÀ§:ÚC+,Ö³'cá¾ãnÚyrF{sÍKo™ÜÈ÷V‘Bqæ «ä÷==µH,ËÄ-"O ²˜‚×ƒ´–)?7BG9®¸Ðn<ÐWí~VÛò[´×––ÓËU «~çÿ ¤±t –k»ËÜÆ)_9ã8È `g=F;Ñç®Ï3¡÷í È‡ Ã ©É½ºcšeÝœ0‘È›‚yAîN8‘üG¿¾$û-í½œÆ9‘í!ˆ9F9çxëøž*o_žIÆÖZò¥ÓºVùöõ¿w¦Ýˆæ•´ÓYÄ®³ËV£êƒæõç?áNòîn.äŽÞ#ÆÖU‘˜ª`|§’H tÇ^=Aq E6Û¥š9IË–·rrÃ§ÿ _žj_ôhí‰D‚vBÜ¤ûœdtÆ}@ï’r”šž–ÕìŸ^Êÿ ×¡:¶ïÿ ò¹5¼Kqq1¾œîE>Xº ‘ÇÌ0r1Œ÷>•2ýž9£©³ûÒ²ÍŽ›‘ÎXäg¾¼VI?¹*‡äÈ-“‚N=3ÐsÏ¿¾*{™ªù›·4ahKG9êG{©üM]+]¼«Ë¸ Š—mcÏ±‚y=yç¶:)T…JÉ>d»$Ýôùnµz2”¢åÍ ¬ ¼ÑËsnŠÜ«ˆS¨;yÛÊŽ½=px¥ŠÒæM°=ÕÌi*±€ Þ² 1‘Ž=qŸj†ãQ¾yæ»ŠA–,2œcR;ãwáÅfÊÈìT©#æä`žø jšøŒ59¾H·¯VÕÕûëçÚÝyµA9Ó‹Ñ?Çúþºš—QÇ ÔvòßNqù«¼!ç‚¹äç¿C»=:Öš#m#bYã†ð¦/(œúŒtè Qž CÍÂÉ¶ž ÇVB ž2ONOZrA óAÇf^3–÷ÉéÁëÇç\ó«·äƒütéß_-Ï¦nJ[/Ì|2Ï#[Ù–!’,Oä‘Ç|sVâ±Ô/|´–Iœ˜î$àc®Fwt+Ûø¿zÏTšyLPZ>#a· ^r7d\u ©¢•âÈ3 83…ˆDTœ’@rOéÐW†ÁP”S”Ü£ó[‰ÚßŽÚ;éÕNŒW“kîüÊ ¨"VHlí×>ZÜ nwÝÏ ›¶ìqÎ×·Õel¿,³4Æ4`;/I'pxaœÔñ¼";vixUu˜’¸YÆ1×#®:Ž T–ñÒ[{Kwi mð·šÙ99Î cÏ#23É«Ÿ-Þ3ii¶©»ÒW·•×~Ôí£Óúô- »yY Ýå™’8¤|c-ó‚<–þ S#3Ì‰q¡mÜI"«€d cqf üç× #5PÜý®XüØWtîßy¹?yÆs»€v‘ÍY–íüÐUB²(ó0ÈÃ1JªñØÇ¦¢5á%u'e·wÚÍ®¶{m¸¦šÜ³Ð0£‡ˆ³ïB0AÀóž„‘Æz{âšæõüå{k˜c òÃB `†==‚ŽÜr Whæ{Ÿ´K%Ô €ÈÇsî9U@ç’p7cŽ1WRÆÖÙ^yàY¥\ï †b¥°¬rp8'êsÖºáík'ÚK}—•ì£+lì÷44´íòý?«Ö÷0¤I"Ú³.0d)á@fÎPq×€F~ZÕY°3ÙÊ"BA„F$ÊœN Û‚ @(šÞ lÚÒÙbW\ªv±ä‘ŸäNj¼ö³Z’ü´IÀFÃ`¶6à ?! NxÇÒ©Ò†Oª²½’·ŸM¶{êºjÚqŒ©®èþ ‰ ’&yL%?yÕÃ”®$•Ï\p4—:…À—u½ä‘°Ýæ$aCß”$ñŸoÄÙ>TÓù¦ƒÂKÆÅÉ@¹'yè{žÝ4ÍKûcíCì vŽ…y?]Ol©Ê|Íê¾Þ_;üÿ Ï¡Rçånÿ rÔ’[m²»˜¡Ž4ùDŽ›Ë) $’XxËëšY8¹i•†Á!‘þpJ•V^0 Œ±õèi²Å²en%·„†8eeù²Yˆ,S†=?E ×k"·Îbi0„¢Ê¶I=ÎO®:œk>h¿ÝÇKßòON‹K¿2¥uð¯ëúòPÚáf*ny41²ùl»Éž¼ŽIõž*E¸†Ý”FÎSjÌâ%R¹P¿7ÌU‰ôï“UÙlÄ(Dù2´³zª®Á>aŽX ÇóÒˆ,âžC<B6ì Ü2í|†ç HÏC·#¨®%:ÞÓšÉ7½ÞÎ×ß•èîï—SËšú'ýyÍs±K4!Ì„0óŒ{£Øs÷‚çzŒð¹ã5æHC+Û=¼Í}ygn0c|œðOAô9îkÔ®£ŽÕf™¦»R#copÛICžÃ©þ :ñ^eñ©ðe·”’´ø‘¦f å— # <ò3ïÖ»ðŸ×©Æ¤•Ó½»ï®ß‹·ôµ4ù'ý_ðLO‚òF‹®0 &Ü§˜œ0Œ0#o8ç#ô¯R6Û“yŽ73G¹^2½öò~o»Ÿ›##ÞSðr=ÑkÒ41º €–rØ ÷„ëƒëÎ zõo7"Ýà_=Š©‰Éldà`†qt÷+‹?æxù©%m,ö{.¶jú;%÷hÌ*ß›Uý}Äq¬fp’}¿Í¹ ü¼î Ïñg$ý*{XLI›•fBÀ\BUzr€Œr#Ð€í¥ÛÍ+²(P”x›$ÅèçœŒž tëÐÕkÖ9‘ab‡Ïò³œã#G'’¼o«U¢ùœ×Gvº4µ¾vÕí}½œ¢ïb{{)¥P’ÊÒº#«Bç˜€8Êä6GË”dTmV³$g¸i&'r:ƒ¬1œàòœãƒÒ • rñ¤P©ÑØô*IÆ[ ÝÏN¸Î9_³[™#Kr.Fí¤í*IÁ?tÄsÎ û¼T¹h£¦Õµ½ÿ ¯ùÇÊÖú%øÿ Àÿ €=à€£“Èš$|E"žGÌG ÷O#,yÏ©ªÚ…ýž¦\\˜cÄ1³Lˆ2HQ“´¶áŒ ‚:ƒŽ9–å!Š–Í‚É¾F''‘÷yÇNüûãëpÆ|=~¢D•äµ•vn2„sÓžGLë IUP´Uíw®Ú-/mm£²×Ì–ìíeý]? øÑüa¨ÞZÏeki,q‰c10PTpAÜÀg%zSß°2Ä¤¡U]®ØŠÜçžI;€èpx?_øZÊ|^agDóí¹ )ÊžßJö‰¡E]È##ço™NO÷¸ÈÇÌ0¹9>™¯Sˆ°pÃc°ŠI¤÷õ¿å}Ë¯ JñGžÿ ÂÀ+ãdÒc³Qj'ÅØîs&vç6îíŽë»iÞbü” ‚Â%\r9àg·ùÍxuÁüMg~ŸÚÁÎÜ²çŽ0?*÷WšÝ^O*#†€1èwsÎsùRÏpTp±¢è¾U(«u}íùŠ´R³²ef À9³bíÝ¿Ùéì ùïíÌóÅ1ý–F‘œ‘åà’9Àç9ëÒ‹)ˆ”©±eÎ c×sù×Î{'ÎâÚõéßuOÁœÜºØ‰fe“e6ñžyäöÀoÆ§²‹„•%fˆ80(öåO½Oj…„E€T…%rKz°Î?.;{šXÙ‡ŸeUÚd!üx9þtã%wO_øoòcM- j–ÒHX_iK#*) ž@Ž{ôÇ½Bd¹‰RÝn–ê0«7Ë†ìyÀ÷Í@¬Ì¢³³’ 9é÷½?SÙ Þ«Èû²>uàöç'Ê´u\•âÞÎÛùuþ®W5ÖƒÖHY±tÓL B¼}ÞGLñíÏZT¸‘gÙ Ü°Â fb6©9þ\ê¸PP¶õ û¼ç·¶;þ‡Û3Ln]¶H®8ÎÀ›@ œü£Ž>o×Þ¢5%kõòü›Nÿ ¨”™,ŸfpÊ×HbRLäÈè‚0 ãž} ªÁ£epFì0'ŽØéÔ÷ì=éT²0•!…Îzt9ç¾?”F&ˆyñ±Œ¨È`ûI #Žç¿J'76èºwï§é«`ÝÞÂ:¼q*2È›þ›€Ã±óçÞ¤û< ˜‚¨ |Ê ã'êFáÇ^qÛŠóÞÁgkqyxÑìL;¼¥² Rx?‡¯Y7PŽwnù¶†û¾ÜÂ·.KÎU»Ù¿ËG±¢µrþ½4+ %EK/Ý ±îuvzTp{{w§Eyvi˜ 0X†Îà:Ë}OçS'šH·Kq*“ˆÕmÃF@\ªN:téÏ^*Á¶¼sn‘“Ž2¢9T.½„\ýò@>˜7NFïNRÓ·wèôßEÕua'¬[þ¾cö¡ÌOæ¦âÅŠ². Ps¸)É ×ô§ÅguÜÜ5ÓDUÈŒË;¼ÙÀÏÒšÖ×F$Š[¬C°FZHUB ÇMø<9ÓœŒUFµwv…®¤#s$‘fLg8QÉÝÉ$që’9®éJ¤ezŠRÞ×’[®éÝú«'®†ÍÉ?zï¶¥³u3(’MSsŽ0Û@9$Ð…-‘ß¦O"§gŠ+¢n'k/ ‡“$±-µ°1–éÜôä)®ae ·2ÆŠ¾gÛ°Z¹#€r ¶9Ç|Õ¨âºŽÖIÑÖÜÇ»1Bc.çqÁR àûu®Š^Õ½Smkß}uzëmSòiõÒ<Ï×õ—£Îî6{ˆmŽåVUòãv3ü¤œqÐŒç“œô¶Ô¶¢‹{• b„ˆg©ù@ÇRTóÅqinÓ·ò×l‡1`¯+òŸ¶ÐqžÀ:fÿ Âi£häÙjz…¬wˆÄË™RI'9n½øãœv®¸ÓmªUÛ•ôI-_kK{ièßvim£Qµý|ÎoÇßìü-~Ú}´j:ÃÍŠ|¸˜¨ó× qŒŒžy®w@øßq%å½¶³imoj0¿h·F;8À,›¹¸üyu¿üO'|;´ðÄÚ¦Œ%:t„Fáß~÷O¿júß©a)ZV”ºÝïëëýjkÞHöfÔ&–î#ö«aðå'Œ’¥\™Il`õ¸9©dûLì ‹t‘ƒ¸ó"Ä€‘Ê7ÈÛŽ:vÜ ¯/ø1â`!»Ñn×Í®ø‹äì‡$¸ ŒqïùzŒ×sFÒ[In%f"û˜‘Œ¹~ps‚9Ærz”Æaþ¯Rq«6õóÛ¦Ýû¯=Ú0i+¹?ÌH¢VŒý®òheIÖr›7îf 8<ó×+žÕç[ÂÖ€]ÇpßoV%v© €pzþgµ6÷3í‹Ì’{²„äˆƒŒ‚Ìr8Æ1“Áë^{ñqæo Ø‹–¸2ý|ÇÜ¬¬Žr=;zþ¬ò¼CúÝ*|+[zÛ£³µ×ß÷‘š¨Ûúü®Sø&ì¬…˜Có[¶âÈ¼3ûÜ÷<ŒñØæ½WÈŸÌX#“3 "²ºÆ7Œ‘Üc¼‡àìFy5xKJŒ"îç.r@ï×Þ½Ä-ÿ þ“}ª}’*Þ!,Fm¸Î@†9b?1W{Yæ3„`Ú¼VõŠÚÛ_kùöG.mhÎñ ôíhí§Ô$.ƒz*(iFá’I^™$ðMUÓ|áíjéb[ËÆºo•ñDdŽà¸'“ŽA Ö¼ƒGÑµ/krG É–i\ôÉêNHÀÈV—Š>êÞ´ŠúR³ÙÈùÑõLôÜ9Æ{jô?°°Kýš¥WíZ¿V—m6·E}{X~Æ? zžÓæ8Ë¢“«¼ 39ì~¼ûÒÍ}žu-ëÇ•cÉåmÀÀÉ9Àsþ ”økâŸí]:[[ÍÍyhª¬w•BN vÏ$ôé‘Íy‹ü@þ"×ç¹ ¨v[Æ¼* ã zœdžµâàxv½LT¨T•¹7jÿ +t×ð·CP—5›=Î ¨/"i¬g¶‘#7kiÃç±'x9#Ž}êano!òKD‘ílï”('¿SÔð?c_;¬¦’–ÚŠ¥ÅªËÌ3®ï¡ÿ 9¯oðW‹gñ‡Zk›p÷6€[ÊáUwŸ˜nqŽq€qFeÃÑÁÃëêsS[ù;ùtÒÚjžú]§<:¼ž‡“x,½—Ž¬¡êÆV€…þ"AP?ãÛ&£vÂÅ»I’FÙ8ÛžÀ”œ¾ÜRÜÌ¬ŠÛÓ‘–Ä*›qôúŸÃAÀëßí-L¶š-™ƒµ¦i”øÿ g«|è*pxF:nžîË¯Þ¼¿þBŒÛQþ¿C»Š5“*]Qÿ „±À>Ý:ôä*D(cXÚ(†FL¡‰`çØÏ;þ5âR|Gñ#3î`„0+µmÑ€ún Þ£ÿ …‰â¬¦0 –¶ˆœ€¹…{tø?Ê¯(_çþ_Š5XY[¡Ù|Q¿ú µŠ2ï¸›sO* Ð‘ÿ ×â°<+à›MkÂ÷š…Ä³ ·Ü–ˆ«ò‚?ˆœúäc½øåunû]¹Iïåè› ç ¯[ð&©¥Ýxn;6>}²’'`IË0ÁèN}zö5éâ©âr\¢0¥ñs^Ml¿«%®ýM$¥F•–ç‘Øj÷Ze¦£k 2¥ô"FqÀ`„~5Ùü+Ò¤—QºÕ†GÙ—Ë‹ çqä°=¶ÏûÔÍcá¶¡/ˆ¤[ý†iK ™°"ó•Æp;`t¯MÑt}+@²¶Óí·Ídy’3mÕË‘’zc€0 íyÎq„ž ¬4×5[_]Rë{]ì¬UZ±p÷^åØÞÈ[©&OúÝÛ‚‚s÷zžIïßó btÎÎª\ya¾U;C¤t*IÎFF3Š¸™c 1žYD…U° êÄàõë\oŒ¼a ‡c[[GŽãP‘7 â znÈ>Ãü3ñ˜,=lUENŒäô¾ÚÀÓ[_ð9 œ´JçMy©E¢Àí}x,bpAó¦üdcûŒW9?Å[Há$¿¹pÄ™#^9O88©zO=«Ë!µÖüY¨³ªÍy9ûÒ1Â úôÚ»M?àô÷«ÞëÖ–ÙMÌ#C&ßnJ“Üp#Ð‚~²†G–àíekÏµío»_žŸuÎ¨Q„t“ÔÛ²øáû›´W6»Øoy FQÎr $Óõìk¬„‹ïÞÚ¼sÆíòÉ67\míÎyF¯ð¯TÓã’K;ë[ð·ld«7üyíšÉð¯Šµ êáeYžÏq[«&vMÀðßFà}p3ÅgW‡°8ØßVín›þšõ³¹/ ü,÷ií|’‘´R,®ŠÉ‡W“Ž1ØöëÓ¾xžÖÞ¹xÞÝ¬XZGù\’vŒž˜ÆsØúÓïí&ÒÒ{]Qž9£Ê¡ù·ÄÀ»¶áHäž™5—ìö« -&ù¤U<±ÉÆA>½ý+æg jžöë¥¢þNÛ=÷JÖÛfdÔ õýËúû‹ÓØB²¬fInZ8wÌÉÐ®~aƒÎ=3ìx‚+/¶äÁlŠ‚?™Æü#8-œ\pqTZXtè%»»&ÚÝ#´ŠðÜžã§Í’¼{p·ß{m>ÞycP¨’¼¢0ú(Rƒë^Ž ñó¼(»y%m´ÕÙ}ÊûékB1¨þÑ®,#Q)ó‡o1T©ÜÃ*Ž‹‚yö<b‰4×H€“ìÐ. ¤²9ÌŠ>„Žãøgšñ ¯Š~)¸ßå\ÛÛoBŒa·L²œg$‚Iã¯ZÈ—Æ~%”äë—È8â)Œcƒ‘Âàu9¯b%)ÞS²¿Ïïÿ 4Öºù}Z/[H%¤vÉ#Ì’x§†b © ³´tÜ{gn=iï%õªÇç]Ü§—!åw„SÓp ·VÈÏ¡?5Âcâb¥_Ä¤Šz¬—nàþÖÎŸñKÄöJé=ÌWèêT‹¸÷qÎáƒŸ•q’zWUN«N/ØO^Ÿe|í¾©k{üõ4öV^ïù~G¹êzÂèº|·÷×[’Þ31†rpjg·n Æ0Ý}kåË‹‰nîe¹ËÍ+™ÏVbrOç]'‰¼o®xÎh`¹Ç*±ÙÚ!T$d/$žN>¼Wqá¯…Z9ÑÒO\ÜÛê1o&,-z ~^NCgNÕéá)ÒÊ©7‰¨¯'Õþ¯þ_¿Ehîþóâ €ï¬uÛûý*ÎK9ä.â-öv<²‘×h$àãúW%ö¯~«g-ÕõÀàG~>Zú¾Iš+(šM³ Û#9äl%ðc¬ ûÝ xÖKG´x®|¸¤Ï™O:Ê8Ã’qÉcÔä‚yÇNJyËŒTj¥&µOmztjÿ ?KëaµÔù¯áýóXøãLeb¾tžAÇû`¨êGBAõ¾•:g˜’ù·,þhÀ`¬qÜ` e·~+å[±ý“âYÄjWì—µHé±ø?Nõô>½âX<5 Ç©ÏÑ¼M¶8cÜªXŽÉ^r?¼IróÈS•ZmÇ›™5»òÚÚ7ïu«&|·÷•Î† >[©ÞXHeS$Œyà€ ÷ù²:ò2|óãDf? Z¼PD¶ÓßC(xÆ0|©ßR;ôMsÿ µ´ÔVi¬,Í¹›Ìxâi˜`¹,GAéÇlV§ÄýF×Yø§ê–‘:Ã=ò2³9n±ÉžØÏ@yÎWžæ±Ãàe„ÄÒN ]ïòêìú_Go'¦ŽÑ’_×õÐ¯ðR66þ!›ÑÄ gFMÙ— äžäqôÈ;ÿ eX<#%»Aö‰ãR¤ Í”Ž¹È G&¹Ÿƒ&á?¶Zˆ±keRè Kãnz·ãŠÕøÄÒÂ9j%@®×q±ÜŒý[õ-É$uíè&¤¶9zÇï·Oøï®ÄJKšÖìdü"µˆ[j×²Îc;ã…B(g<9nàÈ¯G½µŸPÓ.´Éfâ¼FŽP 31 ‘ÏR}<3šä~ Ã2xVöî Dr Ç\›}Ý#S÷ÈÀëŽHÆI®à\OçKuäI¹†ó(”—GWî ñ³¹¸æ2¨›‹ºÚû%¾ýÖ_3ºNú¯ëúì|ÕÅÖ‰}ylM’ZËîTÿ á[ðÐñ/ˆ9Àû ¸ón3 MÃ²d‘÷ döª^.ÊñŽ°›BâîNp>cëÏçÍzïÃôÏ YÍ%ª¬·ãÏ-*9ÜÂãhéŒc¾dÈêú¼Ë,. VŠ÷çeÿ n/¡¼äãõâ=‹xGQKx”|¹bÌŠD@2Œ 8'Ž àúƒŽ+áDÒ&¡¨"Œ§–Žr22 Ç·s]ŸÄ‹«ð%ÚÄ<¹ä’(×{e›HÀqÁç©Ç½`üŽÚõKé¥š9ƒÄ±€<–úƒú~ çðñO#Í%iKKlµ¦¾F)'Iê¬Î+Ç(`ñ¾£œdÈ’`™ºcßéé^ÿ i¸”Û\ý¡æhÔB«aq¸}ãÀÆ:ÜWƒ|FÛÿ î©±BŒÇÀeaŸ-sÊ€:úW½ÜÝÜ<%$µ†%CóDªÀí%IÈÏÊ¤…ôäñÞŒ÷‘a0“ôŽÚë¤nŸoW÷0«e¶y'Å»aÎ—2r’# Û°A^ý9ÉQÔõ=ù5¬£Öü.(Þ’M$~V«=éSÄFN½®©ÔWô»ÿ þHžkR‹ìÏ+µµžöê;khÚI¤m¨‹Ôš–âÖçJ¾_Z•’6a”Èô> ÕÉaÕ<%®£2n bQŠå\tÈõUÿ ø»þ‹k15‚ÃuCL$Ý¹p P1=Oøýs¯^u éEJ”–éêŸê½5ýzy›jÛ³á›Ûkÿ ÚOcn±ÛÏîW;boºz{ãžüVÆ¡a£a5½äÎÂks¸J@?1è¿{$ä‘=k”øsÖ^nŒ¦)ÝåXÃíùN1ØõÚOJë–xF÷h¸ Œ"Ž?xäœšü³ì¨c*Fœ¯i;7~ñí×«Ðó¥Ë»3Ãü púw ‰°<Á%»ñž ÿ P+Û^ ¾Ye£ŽCÄŒ„/>˜>•á¶Ìm~&&À>M[hÈÈÿ [Ž•íd…RO@3^Ç(Ê½*¶ÖQZyßþ 1Vº}Ñç?¼O4Rh6R€ª£í¡ûÙ a‚3ß·Õ ü=mRÍ/µ9¤‚0ÑC¼Iè:cŽsÛ¾™x£ÆÐ¬ªÍöË¢ìƒ’W$•€Å{¨ÀPG ÀÀàŸZìÍ1RÉ0´ðxEË9+Éÿ ^rEÕ—±Š„70l¼áË@û.' ¼¹Žz€N3úUÉ<3á×*?²¬‚ä†"Ùc=p íÛ'¡ª1ñ"økJ†HÒ'»Ÿ+ oÏN¬Ã9 dÙãÜ×“ÏâÍ~æc+j·Jzâ7(£ðW]•æ™?nê´º6åwéåç÷N•ZŠíž›¬|?Ðõ?Ñ-E…Â®³ÇV$~X¯/…õ x‘LˆÑÜÚÈ7¦pzãÜüë½ðÄ^õtÝYËÍ7ÉÖÕ8ÏUe# #€r=sU¾/é’E§jRC4mxNÝ´9†íuá»›V‘ ZI€×cr1Ÿpzsøf»¨åV‹ìû`qËLÊIã?\~¼³áËC©êhªOîO»‘ÃmçÛçút×¢x“Z}?Ãœê#b-¤X7õÄò gž zzbº3œm*qvs·M=íúéw}¿&Úª°^Ö×µÏ(ø‡â†Öµƒenñý†×åQáYûœ÷ÇLœôÎNk¡ðÂ‡¼/µ¸n0æÉ0¬ƒ‚üîÉÆvŒw®Sáö”š¯‹-üÕVŠØÙ[$`(9cqƒÔ_@BëqûÙ`Ýæ0;79È?w<ó |ÙÜkßÌ1±Ëã¿ìÒ»ðlìï«ÓnªèèrP´NÏÂš&ŽéöÙ¸÷æ°~-_O'‰`°!RÚÚÝ%]Ø%þbß1'¿ÿ XÕáOöÎŒ·‹¬+Åæ*ÛÛ™0¤ƒOÍÔ`u¯¦ÂaèÐÃÓ«‹¨Ô¥µœ¿¯ÉyÅÙ.oÔôŸ Úx&(STðÝ½¦õ] ’ÒNóÁäÈùr3í·žÚ[™ƒ¼veÈÃ·ÞIõÎGlqÎ=M|«gsªxÅI6 ]Z·Îªä,¨zŒŽÄ~#ØŠúFñî™ªiÉqc©éÐD>Së”‘ GñŽ1éÐ^+ Ëi;Ô„µVÕú»i¯ÈÒ-ZÍ]òÜ˜®ì`bÛÙ¥_/y(@÷qÐúg Ô÷W0.Ø› 6Ò© r>QƒŒ0+Èîzb¨É+I0TbNñ"$~)ÕÒ6Þ‹{0VÆ27œWWñcÄcX×íôûyKZéðªc'iQ¿¯LaWŠŸS\·Š“ÅºÊ¸…ôÙÂí|öÀÇåV|!¤ÂGâÛ[[’ï 3OrÙËPY¹=Î1õ5öåTžÑè Ú64/üö?Zëžk}¬¶éàoá¾á}3“ü]8Éæ¿´n²Žš_6¾pœ)2?úWÓÚ¥¾¨iWúdŽq{*ª1rXŒd…m»‰äcô¯–dâ•ã‘Jº¬§¨#¨®§,df«8ÉÅßN¾hˆ;îÓ=7áùpën®É 6ûJžO2^œÐò JÖø¥²ãÂ›Ò6Ü·‰!wbÍ‚¬O©»õ¬ÿ ƒP=Ä:â¤-&ÙŽ `È9 r9íÏ§zë> XÅ7ƒ5X–krÑ¢L7€ìw}ÑŸNHëŒüþ:2†á¼+u·á÷N/Û'Ðç~ß˜ô«ëh!ónRéeQ´6QÛÿ èEwëÅÒ|¸Yqó1uêyùzð8 ƒŠù¦Ò;¹ä6öi<'ü³„[ÃZhu½ ùÍ¡g‚>r¯×ŠîÌx}bñ2“kê£§oø~›hTèóËWò4|ki"xßQ˜Ï6øÀLnß‚0 ¹Æ{±–¶Öe#¨27È@^Ìß.1N¾œyç€õ†ñeé·Õã†çQ°€=Ì©ºB€Ø8<‚ÃSõ®ùcc>×Ú .Fr:žÝGæ=kÁâ,^!Fž ¬,àµ}%¶«îõ¹†"r²ƒGœüYÕd?aÑÃY®49PyU ÷þ!žxÅm|/‚ãNð˜¼PcûTÒ,¹/Ý=FkÏ|u¨¶«âë…{¤m¢]Û¾ïP>®XãÞ½iÓÁ¾ ‰'¬–6ß¼(„ï— í!úÙäzôë^–:œ¨å|,_¿&š×]uÓÑµÛô4’j”bž§x‘Æ©ã›á,‚[Ã” ÎÞ= î®ˆŒËæ ÀùYÁ?ŽïÚ¼?ÁªxºÕÛ,°1¸‘¿ÝäãØ¯v…@¤åq½ºã œàûââ·z8Xýˆþz~—û»™âµj=Ž â~ãáh@'h¼F#·Üp?ŸëQü-løvépx»cŸø…lxâÃûGÂ·‰¶ø”L£©%y?¦úõÆü-Õ¶¥y`Òl7>q’2üA?•F}c‡jB:¸Jÿ +§¹¿¸Q÷°ív=VÑìu[Qml%R7a×IèTõéŽx¬ ?†š7 1†îã-ˆã’L¡lŽ0OÓ=ÅuˆpÇ•¼3ÛùÒ¶W/!|’wŽw^qÔ×ÏaóM8Q¨ãÑ?ëï0IEhÄa¸X•`a ?!ÐñùQ!Rä ÂžqŽžÝO`I0ÿ J“y|ñ!Îã@99>þ8–+éáu…!ù—ä Ê°<÷6’I®z ÅS„¾)Zþ_Öýµ×ËPåOwø÷þ*üïænÖùmØÝûþ¹=>¦½öî×Jh]¼ç&@§nTŒ6ITÀõ^Fxð7Å3!Ö·aÛ$þÿ ¹ã5îIo:ÈªmËY[’8ÇÓ¾Ç‰*òû¢¥xõ¾¼ú•åk+\ð¯ HÚoŽl•Ûk,¯ ç²²cõÅ{²Z\ ´ìQ åpzŽ3Ôð}ÿ Jð¯XO¡øÎé€hÙ¥ûLdŒ`““ù6Gá^ÃáÝ^Ë[Ñb¾YåŒÊ»dŽ4†2§,;ÿ CQÄ´¾°¨c–±”mºV{«ßÕýÄW\ÖŸ‘çŸ,çMRÆí“l-ƒn~ë©ÉÈê Ü?#Ž•¹ðãSÒ¥ÐWNíà½;ãž)™ÎSÈ9cóLjëµ¿Å«iÍk¨ió¶X‚7÷ƒ€yãnyÏŽëÞ Öt`×À×V's$È9Ú:ä{wÆEk€«†Çàc—â$éÎ.éí~Ýëk}ÅAÆpörÑ¢‡Šl¡ÑüSs‹¨‰IÃ„óÀ×wñ&eºðf™pŒÆ9gŽTø£lñëÀçŽ NkÊUK0U’p ï^¡ãÈ¥´ø{£ÙHp`’ØåbqÏ©äó^Æ: Ž' ÊóM«õz+ß×ó5Ÿ»('¹ð¦C„$˜Å¢_ºÈI?»^äã'ñêzž+ë€ñ-½»´}¡Ë*õ?.xÇ^1ŽMyÇÂ¸&“Â—L–îëöâ7…' bqéÎGé]Ëªâ1$o²¸R8Ã`.q€}sÖ¾C98cêÆÞíïóòvÓòùœÕfÔÚéýuèÖ·Ú Å‚_¤³ÜÛºÆ‘ÃŸ”à×¨ý:×ƒxPþÅÕî-/üØmnQìïGÎŠÙRqê=>¢½õnæ·r!—h`+’;ò3È<“Û©éšóŸx*÷V¹¸×tÈiˆßwiÔÿ |cŒñÏ®3Ö½Ì°‰Ë Qr©ö½®¼ÛoÑÙZÅÑ«Oàµ¯ýw8;k›ÿ x†;ˆJa;‘º9÷÷R+¡ñgŽí|Iáë{ôáo2Ê²9 029ÉÏLí\‰¿¸Ÿb˜ "Bv$£&#ßiê>=ªª©f ’N ëí>¡NXW~5×úíø\‰»½Ï^ø(—wÖú¥¤2íŽÞXæÁ$°eÈ888^nÝë²ñÝÔ^ ÖÚ9Q~Ëå7ï DC¶ÑµƒsËÇè9®Wáþƒ6‡£´·°2\Ý:ÈÑ?(#¨'$õèGJ¥ñW\ÿ ‰E¶—¸™g˜ÌÀ¹;Pv ú±ÎNs·ëŸ’–"Ž/:té+ûË]öJöÓM»ëø˜*‘•^Uý—êd|‰åñMæÔÝ‹23å™6æHùÛ‚ëüñ^…ñ1¢oêûÑEØ.õ7*ÅHtÎp{g<·Á«+¸c¿¿pÓ¾Æby=8É_ÄsÆk¬ñB\jÞÔì••Ë[9Píb‹Bãƒ… =93§ð§LšÛáÖšÆæXÌÞdÛP.0\ãïÛ0?™úJ¸™Ë ”•œº+=<µI£¦í¯õêt¬d‹T¬P=ËFêT>ÍØØ@Ï9<÷AQÌ×»Õ¡xùk",JÎæù±Éç$œŽŸZWH®¯"·UÌQÂ ’ÙÈ]ÅXg<ã ß¨g3-Üqe€0¢¨*Œ$Üƒ ’Sû 8ãŽ¼_/e'+Ï–-èÓ¶¶Õíß[·ÙÙ½îì—¼sk%§µxä‰â-pÒeÆCrú ôÏƒžû=”šÅô(QW‚Õd\ƒæ. \àö¹¯F½°³½0M>‘gr÷q+œ¶NïºHO— ¤ Ü¥Ý”n·J|ÆP6Kµc=Isó}Ò çGš)a=—#vK›åoK§ßóÙ¤¶¿õú…ÄRÚ[ËsöÙ¼Ë•Ë ópw®qœŒ·Ø ùÇâ‹ý‡ãKèS&ÞvûDAù‘É9ŒîqÅ} $SnIV[]Ñ´Ó}ØÜ¾A Ü|½kÅþÓ|EMuR¼.I¼¶däò‚ÃkÆ}ðy¹vciUœZ…Õõ»z¾÷¿n¦*j-É/àœHã\y5 Û ß™ó0—äŸnzôã#Ô¯,†¥ÚeÔ÷ÜÅ´„“'c…<íÝ€<·SŠ¥k§Ã¢éÆÆÙna‚8–=«Êª[Ÿ™°pNî02z“ÔÙ–K8.È’Þî(vƒ2®@ äÈûãçžxäÇf¯ˆu¹yUÕîýWšÙ|›ëÒ%Q^í[æ|éo5ï‚¼ZY•^{96ˆY‚§v*x>âº_|U¹Ö´©tûMÒÂ9PÇ#«£#€ éÉñ‘ƒÍz/‰´-Ä¯¹°dd,Ð‘›p03ƒœ{ç9=+ Ûá§‡¬¦[‡‚êå©º¸#±ß=³ý¿•Õµjñ½HÙh›Û[§ÚýÊöô÷{˜?ô÷·Ô.u©–_%còcAÀ˜’ }0x9Î>žñÇáÍ9,ahï¦Ì2òÓ ñÛAäry$V²Nð ]=$Ž ‚#Ù‚1ƒƒødõMax‡ÂÖ^!±KkÛ‘ «“Çó²FN8+ëÎ{Ò¼oí§[«ÕMRoËeç×[_m/¦¦k.kôgŽxsSÓ´ý`êzªÜÜKo‰cPC9ÎY‰#§^üý9¹âïÞx£Ë·Ú`±‰‹¤;³–=ÏaôÕAð‚÷kêÁNBéÎælcõö®£Fð†ô2Ò¬]ßÂK$ÓÜ®•”/ÊHàã$ä¸÷ëf¹Oµúâ“”’²øè´µþöjçNü÷üÌ¿ xNïFÒd»¼·h®îT9ŽAµÖ>qÁçÔœtïÒ»\È¶ÎîcÞäîó3¶@#ÉIÎ ÔñW.<´’¥–ÑÑ€ÕšA‚ ;†qÓë‚2q ÒÂó$# Çí‡ !Ë}Õ9ÈÎÑÉã=;ŒÇÎuñ+ÉûÏ¥öíeÙ+$úíÜå¨¯'+êZH4ƒq¶FV‹gïŒ208ÆÌ)íÐ±>M|÷âÍãÂ¾"iì‹¥£Jd´™OÝç;sÈúr+ÜäˆË)DŒ¥šF°*3Õ”d{zÔwºQ¿·UžÉf†~>I+ŒqÔ`ð3œ“Ü×f]œTÁÔn4“ƒø’Ýßõ_«*5šzGCÊ,þ+ê1Ã²÷O¶¸cœºb2yÇ;cùÕ£ñh¬›áÑŠr¤ÝäNBk¥—á—†gxšX/ì‘˜hŸ*Tçn =ûã¦2|(ð¿e·ºÖ$ ýìŸ!'åÎ°yîî+×öœ=Y:²¦ÓÞ×iü’—ü -BK™£˜›âÆ¡&véðõ-ûÉY¹=Onj¹ø¯¯yf4·±T Pó`çœ7={×mÃ/¢˜ZÚòK…G½¥b„’G AãÜœ*í¯Ã¿ IoæI¦NU8‘RwÈã;·€ Û×ëÒ”1Y •£E»ÿ Oyto¢<£Áö·šï,ä‰§ûA¼sû»Nò}¹üE{ÜÖªò1’õÞr0â}ÎØ#>à/8ïéÎ~—áÍ#Ã±Îlí§³2f'h”?C÷YËdð:qëõÓ·‚ïeÄ© ÔÈØÜRL+žAÎ3¼g=åšó³Œt3 ÑQ¦ùRÙßE®¼±w_;þhš’Sirÿ ^ˆã¼ià©‡|RòO„m°J/“$·l“ ÇÓ¿ÿ [ÑŠÆ“„†Õø>cFÆ6Ø1ƒ– àz7Ldòxäüwá‹ÝAXùO•Úý’é®ähm •NÀ±ÌTÈç ƒ‘I$pGž:‚ÄbêW¢®œ´|¦nÍ>¶ÖÏ¢§ÎÜ¢ºö¹•%ÄqL^öÛKpNA<ã¡ …î==ª¸óffËF‡yÌcÉ ©ç$ð=ñÏYþÊ’Ú]—¥‚¬‚eDïÎH>Ÿ_ÌTP™aÂ‰ch['çÆÜò7a‡?w°Ïn§âÎ5”’¨¹uÚÛ|´ÓÓc§{O—ü1•ªxsÃZ…ÊÏy¡Ã3¸Ë2Èé» ‘ƒÎ äžÜðA§cáOéúÛ4ý5-fŒï„ù¬ûô.Ç Üsž•Ò¾•wo<¶Ÿ"¬¡º|£ î2sÇ¡éE²ÉFÑ±rU°dÜ6œ¨ mc†Îxë×ºÞ'0²¡Rr„{j¾í·è›µ÷)º·å–‹î2|I®Y¼ºÍË·–ÃÆàã£'óÆxƒOÆÞ&>\lóÌxP Xc¸ì Sþ5§qà/ê>#žÞW¸if$\3 ® ûÄ“ùŽÕê¾ð<Ó‹H¶óÏ" å·( á‘€:ã†8Ï=+ê¨¬UA×ÃËÚT’ÑÞöù¥¢]{»ms¥F0\ÑÕ—ô}&ÛB´ƒOŽÚ+›xíÄÀ1 ,v± žIëíZ0Ç§™3í2®0à¸—p9öÝÔž)ÓZËoq/Ú“‘L ²ŒmùŽï‘Ó9§[Û#Ä‘\ÞB¬Çs [;à à«g‚2ôòªœÝV§»·¯/[uó½õÛï¾ /šÍ}öüÿ «=x»HŸÂÞ.™ ÌQùŸh´‘#a$‚'¡u<Š›Æ>2>+ƒLSiöwµFó1!eg`£åœ ÷ëÛö}Á¿ÛVÙêv $¬ƒ|,s÷z€ðÎƒ¨x÷ÅD\ÜŒÞmåÔ„ ˆ o| :{ÇÓ¶–òÁn!´0Ål€, ƒ ( ÛŒŒc¶rsšæ,4‹MÛOH!@¢ ÇŽ„`å²9ÝÃw;AÍt0®¤¡…¯ØÄ.Àìí´ƒ‘ßñ5Í,Óëu-ÈÔc¢KÃÓ£òÖÌºU.õL¯0…%2È—"~x ‚[`có±nHàŽyàö™¥keˆìŒÛFç{(Ø©†`Jã#Žwg<“:ÚÉ;M ^\yhûX‡vB·÷zrF?§BÊÔ/s<ÐÈB)Û± ·ÍÔwç5Âã:så§e{mÑ¤ï«Òíh—]Wm4âí¿ùþW4bC3¶ª¾Ùr$pw`àädzt!yŠI„hÂîàM)!edŒm'æ>Ç?wzºKìcŒ´¯Ìq6fp$)ãw¡éUl`µ»ARAˆÝÕgr:äŒgƒéé[Ôö±”iYs5Ýï«ÙG—K=þF’æMG«óÿ `ŠKÉ¦uOQ!ÕåŒ/ÎGÞ`@ËqÕzdõâ«Ê/Ö(ƒK´%ŽbMüåÜŸö—>¤óŒŒV‘°„I¢Yž#™¥ùÏÊ@8 œgqöö5ª4v×“[¬(q cò¨À!FGaÁõõ¯?§†¥ÏU½í¿WªZ$úyú½Žz×§Éþ?>Ã×È•6°{™™ŽÙ.$`ÎUœ…çè ' ¤r$1Ø(y7 ðV<ž:È ÁÎMw¾Â'Øb§øxb7gãÐž½óÉÊë²,i„FÈ¹£§8ãäÂ½k¹¥¦ê/ç{ïêï¦‡2œ/«ü?¯Ô›ìñÜ$þeýœRIåŒg9Ác’zrrNO bÚi¢ ÑºË/$,“ª¯Ýä;Œ× ´<ÛÑn³IvŸb™¥ nm–ÄŸ—nÝÀãŽ3ëÍG,.öó³˜Ù£¹uÊÌrŠ[<±!@Æ:c9ÅZh ì’M5ÄìÌ-‚¼ëÉùqŽGì9¬á ;¨A-ž—évþÖ–^ON·Ô”ŸEý}ú×PO&e[]ÒG¸˜Ûp ƒÃà/Ë·8ûÀ€1ž@¿ÚB*²¼ñì8@p™8Q“žÆH'8«I-%¸‚ F»“åó6°Uù|¶Ú¸ã ò^Äw¥ŠÖK–1ÜÝK,Žddlí²0PÀü“×ükG…¯U«·¶–´w¶ŽÍ¾©yÞú[Zös•¯Á[™6° ¨¼ÉVæq·,# ìãï‘×8îry®A››¨,ãc66»Ë´ã'æÉù?t}¢æH--Òá"›|ˆ¬[í 7¶ö#¸9«––‹$,+Ëqœ\Êøc€yê^Ý¸Äa°«™B-9%«×®‹V´w~vÜTéê¢·þ¼ˆ%·¹• ’[xç•÷2gØS?6åÀÚ õ9É#š@÷bT¸º²C*3Bá¤òÎA9 =úU§Ó"2Ãlá0iÝIc‚2Î@%öç94ùô»'»HÄ¥Ô¾@à Tp£šíx:úÊ:5eºßMý×wµ›Ó_+šº3Ýyvÿ "ºÇ<ÂI>Õ1G·Ë«È«É# àÈÇ øp Jv·šæDûE¿›†Ë’NFr2qŸ½ÇAÜšu•´éí#Ä¦8£2”Ú2Ã/€[ÎTr;qŠz*ý’Îþ(â‰ ;¡TÆâ›;ºÿ àçœk‘Þ8¾Uª¾íé{^×IZéwÓkXÉûÑZo¯_øo×È¡¬ â–ÞR§2„‚Àœü½ùç® SVa†Âüª¼±D‘ŒísŸàä|ä2 æ[‹z”¯s{wn„ÆmáóCO+†GO8Ïeçåº`¯^¼ðG5f{Xžä,k‰<á y™¥voÆ éÛõëI=œ1‹éíÔÀÑ)R#;AÂncäŽ:tÏ#¶TkB.0Œ-ÖÞZÛgumß}fÎJÉ+#2êÔP£žùÈÅi¢%œ3P*Yƒò‚Aì“Ž2r:ƒÐúñiRUQq‰H9!”={~¼“JŽV¥»×²m.ÛßºiYl¾òk˜gL³·rT• ’…wHÁ6ä`–Î3ùÌ4Øe³†&òL‘•%clyÃ®AÂäà0 žüç$[3uÅ˜î¹•pNOÀÉ=† cï{rYK ååä~FÁ •a»"Lär1Ó¯2Äõæ<™C•.fÕ»è¥~½-¿g½Â4¡{[ør¨¶·Žõäx¥’l®qpwÇ»8ärF \cŽ¸ÜÆÓ-g‚yciÏÀ¾rÎwèØÈ#o°Á9ã5¢šfÔxÞæfGusÏÌJÿ µ×œ/LtãÅT7²¶w,l É³;”eúà·¨çîŒsÜgTÃS¦^ '~‹®›¯+k÷ZÖd©Æ*Ó[Ü«%Œk0ŽXƒ”$k#È¨ P2bv‘ƒŸáÇ™ÆÕb)m$É*8óLE‘8'–ÜN Úyàúô+{uº±I'wvš4fÜr íì½=úuú sFlìV$‘ö†HÑù€$§ õ=½¸«Ž] :Ž+•¦ïmRþ½l´îÊT#nkiøÿ _ðÆT¶7Ò½ºÒ£Î¸d\ã8=yãŽÜäR{x]ZâÚé#¸r²#»ÎHÆ6õ ç® ÎFkr;sºÄ.&;só±Ç9êH÷ýSšÕtÐU¢-n Ì| vqœ„{gŒt§S.P‹’Ž‰_[;m¥ÞZýRûÂX{+¥úü¼ú•-àÓ7!„G"“´‹žƒnrYXã¸îp éœ!ÓoPÌtÑ (‰Þ¹é€sÓ#GLçÕšÑnJý¡!‘Tä#“ß?îýp}xÇ‚I¥Õn#·¸–y'qó@r[ Êô÷<ÔWÃÓ¢áN¥4Ô’I&Ý¼¬¬¼ÞºvéÆ FQV~_ÒüJÖÚt¥¦Xá3BÄP^%ÈÎW-×c¡ú©¤·Iþèk¥š?–UQåIR[’O 5x\ÉhÆI¶K4«2ùªŠŒ<¼óœçØ`u«‚Í.VHä€ Ëgfx''9ÆI#±®Z8 sISºku¢ßÞ]úk»Jößl¡B.Ü»ÿ MWe °·Ž%šêÉ†¼»Âù³´œ O¿cÐÓÄh©"ÛÜÏ.ÖV’3nüÄmnq[ŒòznšÖ>J¬òˆæ…qýØP Ž:ä7^0yëWšÍ_79äoaÈ °#q0{ää×mœy”R{vÒÞ¶ÚÏe¥“ÚÆÐ¥Ì®—õýjR •íç›Ìb„+JyÜØÙ•Ç]¿Ôd þËOL²”9-Œ—õÃc'æÝ×œçÚ²ìejP“½ âù°¨†ðqòädÐƒÉäÖÜj÷PÇp“ÍšŠå«‘î <iWNsmª»¶vÓz5»ûì:Rs\Ðßôû×uÔÿÙ