Ž ͘gw4O$ãH@€$ H fF(ÏVccc²^ æá`#H×NNNþ;r_ Ù¹3rs?þGÜÅøècÇ;GË8v ²Ÿ™ùÏ&É%o‰Ô5’/Ö@ZÈÄ H@€$ "0::ú1 ™WRäÅ3mKÎt¹ ÷V/›˜˜È3u®m !€±6šEŸy‰i Í’úW)•˜ò€$ H@µ!ÀÐGoL,Ð
‰òyÅóôÕýPl^Ú3ñv˜¦Ñ% H@€$P GHU”ét=1ÐM)µr
×@* ¢IH@€$ T“ ÆÎ&94C¯XY¯ý Á R
¤AªmË* H@€$0Ÿ@òB¼ƒÔ ã-ÕØñý£ùµ›ã¿RhF‘€$ H@¨
©Ô’°”vO $ôZ•¢Sò4R€5‘Õ@jÆ` H@€$ ú`”&Ï¢×ö‚ †Xªn©ò½(FåòÐ@ª\•©°$ H@@QXF{ybZ·!ß«‘š;uë•^‰jUK\©Zõ¥¶€$ H@Ÿ&1¹Kå;_–™Ñ0
¤`Md5š€1X€$ H þ0*þšXÊß%Êw"~+‘W$$à»XÍD5š‘1\€$ H ö&&&þ@!³.Ô0Å
v_é%^¸,!?G`5Õ@jFÆp H@€$ A p=FÈG)hËÑd.@æ¹,œpf/¡0Âõ?ä7ž1O
¤Œ Z‰
µ:è1 H@€$ ôƒÀÈÈÈ1äû¼”¼1bÞC¼ 7‰£DS81e-Þí¹jž\ l=66v/ÒYÊþ~Õøøø-l¯Äߎï—Û˜r=½¶E{áïÆ߉ñt þšð”+Þ¥º?ýí$ʱ+û™¾ñDÜ(_ê»XDY´½>Ë&x…>w²èEša¨…¿+Âbÿ»í¥øÑo ¶mÝL¹B?$ H@€—@Hø©.úHûº ¾6+;¦
¾£— Èï’Ý>ØKÝ"/§Øõš¸ùI@€$ ”@ŒÄ| ¿q”Q‡òÐ@*O]¨‰$ H@@o ¬5::º[o³4·²Ð@*{
©Ÿ$ H@@×ð^OŒ$é$°š€ÒjîH@€$ u°Ì¹
¤p<$ H@€$P{ö‡k_Åiô„H㥴$ H@@½øÙ›zÕgÇ¥Ñ@ê¡ H@€$ H@u! T—š´ €$ H@@Ç4:Fh€$ H@@]h Õ¥&-‡$ H@€$Ð1
¤Žš€$ H@€$P£u)ˆå€$ H@¨>àz9¥ùS·K444tS·ó0ýjÐ@ªV}©$ H@“““ï¤ áuè)§Øõ·™I@€$ H@e& TæÚQ7 H@€$ H §4zŠÛÌ$ H@€$ 2Ð@*sí¨›$ H@€$ÐSH=Åmf€$ H@@™ h •¹vÔM€$ H@è)
¤žâ63 H@€$ H Ì4Ê\;ê& H@€$ ô”€ROq›™$ H@€$PfHe® u“€$ H@€zJ@©§¸ÍL€$ H@(3Ñ2+§n€$ H@@:¡ECMMMÝ%æÐÐÐõ3rd;–%NN™Èçzòû3ºÈ˜Æuå
*,%’€$ H@€*K`xxøJŒ—-ºU Œ¢ÿšœœ|g·Ò/*]§ØEÒt$ H@€$ ÊÐ@ª|Z H@€$ H (HE‘4 H@€$ H ò4*_…@€$ H@(Š€RQ$MG€$ H@¨<
¤ÊW¡€$ H@€Š" TIÓ‘€$ H@€*O@©òUh$ H@€$ ¢h EÒt$ H@€$ ÊÐ@ª|Z H@€$ H (HE‘4 H@€$ H òF+_ H@€$ tL`hhèÒ©©©å 'Ô<š *Ï‘ÿdkÓ+×(Ù IEND®B`‚ click-6.2/docs/_templates/ 0000755 0000765 0000024 00000000000 12626113045 016672 5 ustar mitsuhiko staff 0000000 0000000 click-6.2/docs/_templates/sidebarintro.html 0000644 0000765 0000024 00000001043 12370501774 022251 0 ustar mitsuhiko staff 0000000 0000000 About
Click is a Python package for creating beautiful command line interfaces in a
composable way with as little amount of code as necessary. It’s the “Command
Line Interface Creation Kitâ€.
Useful Links
click-6.2/docs/_templates/sidebarlogo.html 0000644 0000765 0000024 00000000251 12370501774 022056 0 ustar mitsuhiko staff 0000000 0000000
click-6.2/docs/advanced.rst 0000644 0000765 0000024 00000033575 12551460163 017054 0 ustar mitsuhiko staff 0000000 0000000 Advanced Patterns
=================
.. currentmodule:: click
In addition to common functionality that is implemented in the library
itself, there are countless patterns that can be implemented by extending
Click. This page should give some insight into what can be accomplished.
.. _aliases:
Command Aliases
---------------
Many tools support aliases for commands. For instance, you can configure
``git`` to accept ``git ci`` as alias for ``git commit``. Other tools
also support auto-discovery for aliases by automatically shortening them.
Click does not support this out of the box, but it's very easy to customize
the :class:`Group` or any other :class:`MultiCommand` to provide this
functionality.
As explained in :ref:`custom-multi-commands`, a multi command can provide
two methods: :meth:`~MultiCommand.list_commands` and
:meth:`~MultiCommand.get_command`. In this particular case, you only need
to override the latter as you generally don't want to enumerate the
aliases on the help page in order to avoid confusion.
This following example implements a subclass of :class:`Group` that
accepts a prefix for a command. If there were a command called ``push``,
it would accept ``pus`` as an alias (so long as it was unique):
.. click:example::
class AliasedGroup(click.Group):
def get_command(self, ctx, cmd_name):
rv = click.Group.get_command(self, ctx, cmd_name)
if rv is not None:
return rv
matches = [x for x in self.list_commands(ctx)
if x.startswith(cmd_name)]
if not matches:
return None
elif len(matches) == 1:
return click.Group.get_command(self, ctx, matches[0])
ctx.fail('Too many matches: %s' % ', '.join(sorted(matches)))
And it can then be used like this:
.. click:example::
@click.command(cls=AliasedGroup)
def cli():
pass
@cli.command()
def push():
pass
@cli.command()
def pop():
pass
Parameter Modifications
-----------------------
Parameters (options and arguments) are forwarded to the command callbacks
as you have seen. One common way to prevent a parameter from being passed
to the callback is the `expose_value` argument to a parameter which hides
the parameter entirely. The way this works is that the :class:`Context`
object has a :attr:`~Context.params` attribute which is a dictionary of
all parameters. Whatever is in that dictionary is being passed to the
callbacks.
This can be used to make up addition parameters. Generally this pattern
is not recommended but in some cases it can be useful. At the very least
it's good to know that the system works this way.
.. click:example::
import urllib
def open_url(ctx, param, value):
if value is not None:
ctx.params['fp'] = urllib.urlopen(value)
return value
@click.command()
@click.option('--url', callback=open_url)
def cli(url, fp=None):
if fp is not None:
click.echo('%s: %s' % (url, fp.code))
In this case the callback returns the URL unchanged but also passes a
second ``fp`` value to the callback. What's more recommended is to pass
the information in a wrapper however:
.. click:example::
import urllib
class URL(object):
def __init__(self, url, fp):
self.url = url
self.fp = fp
def open_url(ctx, param, value):
if value is not None:
return URL(value, urllib.urlopen(value))
@click.command()
@click.option('--url', callback=open_url)
def cli(url):
if url is not None:
click.echo('%s: %s' % (url.url, url.fp.code))
Token Normalization
-------------------
.. versionadded:: 2.0
Starting with Click 2.0, it's possible to provide a function that is used
for normalizing tokens. Tokens are option names, choice values, or command
values. This can be used to implement case insensitive options, for
instance.
In order to use this feature, the context needs to be passed a function that
performs the normalization of the token. For instance, you could have a
function that converts the token to lowercase:
.. click:example::
CONTEXT_SETTINGS = dict(token_normalize_func=lambda x: x.lower())
@click.command(context_settings=CONTEXT_SETTINGS)
@click.option('--name', default='Pete')
def cli(name):
click.echo('Name: %s' % name)
And how it works on the command line:
.. click:run::
invoke(cli, prog_name='cli', args=['--NAME=Pete'])
Invoking Other Commands
-----------------------
Sometimes, it might be interesting to invoke one command from another
command. This is a pattern that is generally discouraged with Click, but
possible nonetheless. For this, you can use the :func:`Context.invoke`
or :func:`Context.forward` methods.
They work similarly, but the difference is that :func:`Context.invoke` merely
invokes another command with the arguments you provide as a caller,
whereas :func:`Context.forward` fills in the arguments from the current
command. Both accept the command as the first argument and everything else
is passed onwards as you would expect.
Example:
.. click:example::
cli = click.Group()
@cli.command()
@click.option('--count', default=1)
def test(count):
click.echo('Count: %d' % count)
@cli.command()
@click.option('--count', default=1)
@click.pass_context
def dist(ctx, count):
ctx.forward(test)
ctx.invoke(test, count=42)
And what it looks like:
.. click:run::
invoke(cli, prog_name='cli', args=['dist'])
.. _callback-evaluation-order:
Callback Evaluation Order
-------------------------
Click works a bit differently than some other command line parsers in that
it attempts to reconcile the order of arguments as defined by the
programmer with the order of arguments as defined by the user before
invoking any callbacks.
This is an important concept to understand when porting complex
patterns to Click from optparse or other systems. A parameter
callback invocation in optparse happens as part of the parsing step,
whereas a callback invocation in Click happens after the parsing.
The main difference is that in optparse, callbacks are invoked with the raw
value as it happens, whereas a callback in Click is invoked after the
value has been fully converted.
Generally, the order of invocation is driven by the order in which the user
provides the arguments to the script; if there is an option called ``--foo``
and an option called ``--bar`` and the user calls it as ``--bar
--foo``, then the callback for ``bar`` will fire before the one for ``foo``.
There are three exceptions to this rule which are important to know:
Eagerness:
An option can be set to be "eager". All eager parameters are
evaluated before all non-eager parameters, but again in the order as
they were provided on the command line by the user.
This is important for parameters that execute and exit like ``--help``
and ``--version``. Both are eager parameters, but whatever parameter
comes first on the command line will win and exit the program.
Repeated parameters:
If an option or argument is split up on the command line into multiple
places because it is repeated -- for instance, ``--exclude foo --include
baz --exclude bar`` -- the callback will fire based on the position of
the first option. In this case, the callback will fire for
``exclude`` and it will be passed both options (``foo`` and
``bar``), then the callback for ``include`` will fire with ``baz``
only.
Note that even if a parameter does not allow multiple versions, Click
will still accept the position of the first, but it will ignore every
value except the last. The reason for this is to allow composability
through shell aliases that set defaults.
Missing parameters:
If a parameter is not defined on the command line, the callback will
still fire. This is different from how it works in optparse where
undefined values do not fire the callback. Missing parameters fire
their callbacks at the very end which makes it possible for them to
default to values from a parameter that came before.
Most of the time you do not need to be concerned about any of this,
but it is important to know how it works for some advanced cases.
.. _forwarding-unknown-options:
Forwarding Unknown Options
--------------------------
In some situations it is interesting to be able to accept all unknown
options for further manual processing. Click can generally do that as of
Click 4.0, but it has some limitations that lie in the nature of the
problem. The support for this is provided through a parser flag called
``ignore_unknown_options`` which will instruct the parser to collect all
unknown options and to put them to the leftover argument instead of
triggering a parsing error.
This can generally be activated in two different ways:
1. It can be enabled on custom :class:`Command` subclasses by changing
the :attr:`~BaseCommand.ignore_unknown_options` attribute.
2. It can be enabled by changing the attribute of the same name on the
context class (:attr:`Context.ignore_unknown_options`). This is best
changed through the ``context_settings`` dictionary on the command.
For most situations the easiest solution is the second. Once the behavior
is changed something needs to pick up those leftover options (which at
this point are considered arguments). For this again you have two
options:
1. You can use :func:`pass_context` to get the context passed. This will
only work if in addition to :attr:`~Context.ignore_unknown_options`
you also set :attr:`~Context.allow_extra_args` as otherwise the
command will abort with an error that there are leftover arguments.
If you go with this solution, the extra arguments will be collected in
:attr:`Context.args`.
2. You can attach a :func:`argument` with ``nargs`` set to `-1` which
will eat up all leftover arguments. In this case it's recommeded to
set the `type` to :data:`UNPROCESSED` to avoid any string processing
on those arguments as otherwise they are forced into unicode strings
automatically which is often not what you want.
In the end you end up with something like this:
.. click:example::
import sys
from subprocess import call
@click.command(context_settings=dict(
ignore_unknown_options=True,
))
@click.option('-v', '--verbose', is_flag=True, help='Enables verbose mode')
@click.argument('timeit_args', nargs=-1, type=click.UNPROCESSED)
def cli(verbose, timeit_args):
"""A wrapper around Python's timeit."""
cmdline = ['python', '-mtimeit'] + list(timeit_args)
if verbose:
click.echo('Invoking: %s' % ' '.join(cmdline))
call(cmdline)
And what it looks like:
.. click:run::
invoke(cli, prog_name='cli', args=['--help'])
println()
invoke(cli, prog_name='cli', args=['-n', '100', 'a = 1; b = 2; a * b'])
println()
invoke(cli, prog_name='cli', args=['-v', 'a = 1; b = 2; a * b'])
As you can see the verbosity flag is handled by Click, everything else
ends up in the `timeit_args` variable for further processing which then
for instance, allows invoking a subprocess. There are a few things that
are important to know about how this ignoring of unhandled flag happens:
* Unknown long options are generally ignored and not processed at all.
So for instance if ``--foo=bar`` or ``--foo bar`` are passed they
generally end up like that. Note that because the parser cannot know
if an option will accept an argument or not, the ``bar`` part might be
handled as an argument.
* Unknown short options might be partially handled and reassmebled if
necessary. For instance in the above example there is an option
called ``-v`` which enables verbose mode. If the command would be
ignored with ``-va`` then the ``-v`` part would be handled by Click
(as it is known) and ``-a`` would end up in the leftover parameters
for further processing.
* Depending on what you plan on doing you might have some success by
disabling interspersed arguments
(:attr:`~Context.allow_interspersed_args`) which instructs the parser
to not allow arguments and options to be mixed. Depending on your
situation this might improve your results.
Generally though the combinated handling of options and arguments from
your own commands and commands from another application are discouraged
and if you can avoid it, you should. It's a much better idea to have
everything below a subcommand be forwarded to another application than to
handle some arguments yourself.
Global Context Access
---------------------
.. versionadded:: 5.0
Starting with Click 5.0 it is possible to access the current context from
anywhere within the same through through the use of the
:func:`get_current_context` function which returns it. This is primarily
useful for accessing the context bound object as well as some flags that
are stored on it to customize the runtime behavior. For instance the
:func:`echo` function does this to infer the default value of the `color`
flag.
Example usage::
def get_current_command_name():
return click.get_current_context().info_name
It should be noted that this only works within the current thread. If you
spawn additional threads then those threads will not have the ability to
refer to the current context. If you want to give another thread the
ability to refer to this context you need to use the context within the
thread as a context manager::
def spawn_thread(ctx, func):
def wrapper():
with ctx:
func()
t = threading.Thread(target=wrapper)
t.start()
return t
Now the thread function can access the context like the main thread would
do. However if you do use this for threading you need to be very careful
as the vast majority of the context is not thread safe! You are only
allowed to read from the context, but not to perform any modifications on
it.
click-6.2/docs/api.rst 0000644 0000765 0000024 00000004447 12625117354 016057 0 ustar mitsuhiko staff 0000000 0000000 API
===
.. module:: click
This part of the documentation lists the full API reference of all public
classes and functions.
Decorators
----------
.. autofunction:: command
.. autofunction:: group
.. autofunction:: argument
.. autofunction:: option
.. autofunction:: password_option
.. autofunction:: confirmation_option
.. autofunction:: version_option
.. autofunction:: help_option
.. autofunction:: pass_context
.. autofunction:: pass_obj
.. autofunction:: make_pass_decorator
Utilities
---------
.. autofunction:: echo
.. autofunction:: echo_via_pager
.. autofunction:: prompt
.. autofunction:: confirm
.. autofunction:: progressbar
.. autofunction:: clear
.. autofunction:: style
.. autofunction:: unstyle
.. autofunction:: secho
.. autofunction:: edit
.. autofunction:: launch
.. autofunction:: getchar
.. autofunction:: pause
.. autofunction:: get_terminal_size
.. autofunction:: get_binary_stream
.. autofunction:: get_text_stream
.. autofunction:: open_file
.. autofunction:: get_app_dir
.. autofunction:: format_filename
Commands
--------
.. autoclass:: BaseCommand
:members:
.. autoclass:: Command
:members:
.. autoclass:: MultiCommand
:members:
.. autoclass:: Group
:members:
.. autoclass:: CommandCollection
:members:
Parameters
----------
.. autoclass:: Parameter
:members:
.. autoclass:: Option
.. autoclass:: Argument
Context
-------
.. autoclass:: Context
:members:
.. autofunction:: get_current_context
Types
-----
.. autodata:: STRING
.. autodata:: INT
.. autodata:: FLOAT
.. autodata:: BOOL
.. autodata:: UUID
.. autodata:: UNPROCESSED
.. autoclass:: File
.. autoclass:: Path
.. autoclass:: Choice
.. autoclass:: IntRange
.. autoclass:: Tuple
.. autoclass:: ParamType
:members:
Exceptions
----------
.. autoexception:: ClickException
.. autoexception:: Abort
.. autoexception:: UsageError
.. autoexception:: BadParameter
.. autoexception:: FileError
.. autoexception:: NoSuchOption
.. autoexception:: BadOptionUsage
.. autoexception:: BadArgumentUsage
Formatting
----------
.. autoclass:: HelpFormatter
:members:
.. autofunction:: wrap_text
Parsing
-------
.. autoclass:: OptionParser
:members:
Testing
-------
.. currentmodule:: click.testing
.. autoclass:: CliRunner
:members:
.. autoclass:: Result
:members:
click-6.2/docs/arguments.rst 0000644 0000765 0000024 00000017300 12466134301 017275 0 ustar mitsuhiko staff 0000000 0000000 .. _arguments:
Arguments
=========
.. currentmodule:: click
Arguments work similarly to :ref:`options ` but are positional.
They also only support a subset of the features of options due to their
syntactical nature. Click will also not attempt to document arguments for
you and wants you to document them manually in order to avoid ugly help
pages.
Basic Arguments
---------------
The most basic option is a simple string argument of one value. If no
type is provided, the type of the default value is used, and if no default
value is provided, the type is assumed to be :data:`STRING`.
Example:
.. click:example::
@click.command()
@click.argument('filename')
def touch(filename):
click.echo(filename)
And what it looks like:
.. click:run::
invoke(touch, args=['foo.txt'])
Variadic Arguments
------------------
The second most common version is variadic arguments where a specific (or
unlimited) number of arguments is accepted. This can be controlled with
the ``nargs`` parameter. If it is set to ``-1``, then an unlimited number
of arguments is accepted.
The value is then passed as a tuple. Note that only one argument can be
set to ``nargs=-1``, as it will eat up all arguments.
Example:
.. click:example::
@click.command()
@click.argument('src', nargs=-1)
@click.argument('dst', nargs=1)
def copy(src, dst):
for fn in src:
click.echo('move %s to folder %s' % (fn, dst))
And what it looks like:
.. click:run::
invoke(copy, args=['foo.txt', 'bar.txt', 'my_folder'])
Note that this is not how you would write this application. The reason
for this is that in this particular example the arguments are defined as
strings. Filenames, however, are not strings! They might be on certain
operating systems, but not necessarily on all. For better ways to write
this, see the next sections.
.. admonition:: Note on Non-Empty Variadic Arguments
If you come from ``argparse``, you might be missing support for setting
``nargs`` to ``+`` to indicate that at least one argument is required.
This is supported by setting ``required=True``. However, this should
not be used if you can avoid it as we believe scripts should gracefully
degrade into becoming noops if a variadic argument is empty. The
reason for this is that very often, scripts are invoked with wildcard
inputs from the command line and they should not error out if the
wildcard is empty.
.. _file-args:
File Arguments
--------------
Since all the examples have already worked with filenames, it makes sense
to explain how to deal with files properly. Command line tools are more
fun if they work with files the Unix way, which is to accept ``-`` as a
special file that refers to stdin/stdout.
Click supports this through the :class:`click.File` type which
intelligently handles files for you. It also deals with Unicode and bytes
correctly for all versions of Python so your script stays very portable.
Example:
.. click:example::
@click.command()
@click.argument('input', type=click.File('rb'))
@click.argument('output', type=click.File('wb'))
def inout(input, output):
while True:
chunk = input.read(1024)
if not chunk:
break
output.write(chunk)
And what it does:
.. click:run::
with isolated_filesystem():
invoke(inout, args=['-', 'hello.txt'], input=['hello'],
terminate_input=True)
invoke(inout, args=['hello.txt', '-'])
File Path Arguments
-------------------
In the previous example, the files were opened immediately. But what if
we just want the filename? The naïve way is to use the default string
argument type. However, remember that Click is Unicode-based, so the string
will always be a Unicode value. Unfortunately, filenames can be Unicode or
bytes depending on which operating system is being used. As such, the type
is insufficient.
Instead, you should be using the :class:`Path` type, which automatically
handles this ambiguity. Not only will it return either bytes or Unicode
depending on what makes more sense, but it will also be able to do some
basic checks for you such as existence checks.
Example:
.. click:example::
@click.command()
@click.argument('f', type=click.Path(exists=True))
def touch(f):
click.echo(click.format_filename(f))
And what it does:
.. click:run::
with isolated_filesystem():
with open('hello.txt', 'w') as f:
f.write('Hello World!\n')
invoke(touch, args=['hello.txt'])
println()
invoke(touch, args=['missing.txt'])
File Opening Safety
-------------------
The :class:`FileType` type has one problem it needs to deal with, and that
is to decide when to open a file. The default behavior is to be
"intelligent" about it. What this means is that it will open stdin/stdout
and files opened for reading immediately. This will give the user direct
feedback when a file cannot be opened, but it will only open files
for writing the first time an IO operation is performed by automatically
wrapping the file in a special wrapper.
This behavior can be forced by passing ``lazy=True`` or ``lazy=False`` to
the constructor. If the file is opened lazily, it will fail its first IO
operation by raising an :exc:`FileError`.
Since files opened for writing will typically immediately empty the file,
the lazy mode should only be disabled if the developer is absolutely sure
that this is intended behavior.
Forcing lazy mode is also very useful to avoid resource handling
confusion. If a file is opened in lazy mode, it will receive a
``close_intelligently`` method that can help figure out if the file
needs closing or not. This is not needed for parameters, but is
necessary for manually prompting with the :func:`prompt` function as you
do not know if a stream like stdout was opened (which was already open
before) or a real file that needs closing.
Starting with Click 2.0, it is also possible to open files in atomic mode by
passing ``atomic=True``. In atomic mode, all writes go into a separate
file in the same folder, and upon completion, the file will be moved over to
the original location. This is useful if a file regularly read by other
users is modified.
Environment Variables
---------------------
Like options, arguments can also grab values from an environment variable.
Unlike options, however, this is only supported for explicitly named
environment variables.
Example usage:
.. click:example::
@click.command()
@click.argument('src', envvar='SRC', type=click.File('r'))
def echo(src):
click.echo(src.read())
And from the command line:
.. click:run::
with isolated_filesystem():
with open('hello.txt', 'w') as f:
f.write('Hello World!')
invoke(echo, env={'SRC': 'hello.txt'})
In that case, it can also be a list of different environment variables
where the first one is picked.
Generally, this feature is not recommended because it can cause the user
a lot of confusion.
Option-Like Arguments
---------------------
Sometimes, you want to process arguments that look like options. For
instance, imagine you have a file named ``-foo.txt``. If you pass this as
an argument in this manner, Click will treat it as an option.
To solve this, Click does what any POSIX style command line script does,
and that is to accept the string ``--`` as a separator for options and
arguments. After the ``--`` marker, all further parameters are accepted as
arguments.
Example usage:
.. click:example::
@click.command()
@click.argument('files', nargs=-1, type=click.Path())
def touch(files):
for filename in files:
click.echo(filename)
And from the command line:
.. click:run::
invoke(touch, ['--', '-foo.txt', 'bar.txt'])
click-6.2/docs/bashcomplete.rst 0000644 0000765 0000024 00000004561 12372607550 017752 0 ustar mitsuhiko staff 0000000 0000000 Bash Complete
=============
.. versionadded:: 2.0
As of Click 2.0, there is built-in support for Bash completion for
any Click script. There are certain restrictions on when this completion
is available, but for the most part it should just work.
Limitations
-----------
Bash completion is only available if a script has been installed properly,
and not executed through the ``python`` command. For information about
how to do that, see :ref:`setuptools-integration`. Also, Click currently
only supports completion for Bash.
Currently, Bash completion is an internal feature that is not customizable.
This might be relaxed in future versions.
What it Completes
-----------------
Generally, the Bash completion support will complete subcommands and
parameters. Subcommands are always listed whereas parameters only if at
least a dash has been provided. Example::
$ repo
clone commit copy delete setuser
$ repo clone -
--deep --help --rev --shallow -r
Activation
----------
In order to activate Bash completion, you need to inform Bash that
completion is available for your script, and how. Any Click application
automatically provides support for that. The general way this works is
through a magic environment variable called ``__COMPLETE``,
where ```` is your application executable name in uppercase
with dashes replaced by underscores.
If your tool is called ``foo-bar``, then the magic variable is called
``_FOO_BAR_COMPLETE``. By exporting it with the ``source`` value it will
spit out the activation script which can be trivally activated.
For instance, to enable Bash completion for your ``foo-bar`` script, this
is what you would need to put into your ``.bashrc``::
eval "$(_FOO_BAR_COMPLETE=source foo-bar)"
From this point onwards, your script will have Bash completion enabled.
Activation Script
-----------------
The above activation example will always invoke your application on
startup. This might be slowing down the shell activation time
significantly if you have many applications. Alternatively, you could also
ship a file with the contents of that, which is what Git and other systems
are doing.
This can be easily accomplished::
_FOO_BAR_COMPLETE=source foo-bar > foo-bar-complete.sh
And then you would put this into your bashrc instead::
. /path/to/foo-bar-complete.sh
click-6.2/docs/changelog.rst 0000644 0000765 0000024 00000000062 12370501774 017222 0 ustar mitsuhiko staff 0000000 0000000 .. currentmodule:: click
.. include:: ../CHANGES
click-6.2/docs/clickdoctools.py 0000644 0000765 0000024 00000016741 12466134274 017765 0 ustar mitsuhiko staff 0000000 0000000 import os
import sys
import click
import shutil
import tempfile
import contextlib
import subprocess
try:
from StringIO import StringIO
except ImportError:
from io import StringIO
from docutils import nodes
from docutils.statemachine import ViewList
from sphinx.domains import Domain
from sphinx.util.compat import Directive
class EchoingStdin(object):
def __init__(self, input, output):
self._input = input
self._output = output
def __getattr__(self, x):
return getattr(self._input, x)
def _echo(self, rv):
mark = False
if rv.endswith('\xff'):
rv = rv[:-1]
mark = True
self._output.write(rv)
if mark:
self._output.write('^D\n')
return rv
def read(self, n=-1):
return self._echo(self._input.read(n))
def readline(self, n=-1):
return self._echo(self._input.readline(n))
def readlines(self):
return [self._echo(x) for x in self._input.readlines()]
def __iter__(self):
return iter(self._echo(x) for x in self._input)
@contextlib.contextmanager
def fake_modules():
old_call = subprocess.call
def dummy_call(*args, **kwargs):
with tempfile.TemporaryFile('wb+') as f:
kwargs['stdout'] = f
kwargs['stderr'] = f
rv = subprocess.Popen(*args, **kwargs).wait()
f.seek(0)
click.echo(f.read().decode('utf-8', 'replace').rstrip())
return rv
subprocess.call = dummy_call
try:
yield
finally:
subprocess.call = old_call
@contextlib.contextmanager
def isolation(input=None, env=None):
if isinstance(input, unicode):
input = input.encode('utf-8')
input = StringIO(input or '')
output = StringIO()
sys.stdin = EchoingStdin(input, output)
sys.stdin.encoding = 'utf-8'
def visible_input(prompt=None):
sys.stdout.write(prompt or '')
val = input.readline().rstrip('\r\n')
sys.stdout.write(val + '\n')
sys.stdout.flush()
return val
def hidden_input(prompt=None):
sys.stdout.write((prompt or '') + '\n')
sys.stdout.flush()
return input.readline().rstrip('\r\n')
sys.stdout = output
sys.stderr = output
old_visible_prompt_func = click.termui.visible_prompt_func
old_hidden_prompt_func = click.termui.hidden_prompt_func
click.termui.visible_prompt_func = visible_input
click.termui.hidden_prompt_func = hidden_input
old_env = {}
try:
if env:
for key, value in env.iteritems():
old_env[key] = os.environ.get(value)
os.environ[key] = value
yield output
finally:
for key, value in old_env.iteritems():
if value is None:
try:
del os.environ[key]
except Exception:
pass
else:
os.environ[key] = value
sys.stdout = sys.__stdout__
sys.stderr = sys.__stderr__
click.termui.visible_prompt_func = old_visible_prompt_func
click.termui.hidden_prompt_func = old_hidden_prompt_func
@contextlib.contextmanager
def isolated_filesystem():
cwd = os.getcwd()
t = tempfile.mkdtemp()
os.chdir(t)
try:
yield
finally:
os.chdir(cwd)
try:
shutil.rmtree(t)
except (OSError, IOError):
pass
class ExampleRunner(object):
def __init__(self):
self.namespace = {
'click': click,
'__file__': 'dummy.py',
}
def declare(self, source):
with fake_modules():
code = compile(source, '', 'exec')
eval(code, self.namespace)
def run(self, source):
code = compile(source, '', 'exec')
buffer = []
def invoke(cmd, args=None, prog_name=None,
input=None, terminate_input=False, env=None,
**extra):
if env:
for key, value in sorted(env.items()):
if ' ' in value:
value = '"%s"' % value
buffer.append('$ export %s=%s' % (key, value))
args = args or []
if prog_name is None:
prog_name = cmd.name.replace('_', '-')
buffer.append(('$ %s %s' % (
prog_name,
' '.join(('"%s"' % x) if ' ' in x else x for x in args)
)).rstrip())
if isinstance(input, (tuple, list)):
input = '\n'.join(input) + '\n'
if terminate_input:
input += '\xff'
with isolation(input=input, env=env) as output:
try:
cmd.main(args=args, prog_name=prog_name.split()[-1],
**extra)
except SystemExit:
pass
buffer.extend(output.getvalue().splitlines())
def println(text=''):
buffer.append(text)
eval(code, self.namespace, {
'invoke': invoke,
'println': println,
'isolated_filesystem': isolated_filesystem,
})
return buffer
def close(self):
pass
def parse_rst(state, content_offset, doc):
node = nodes.section()
# hack around title style bookkeeping
surrounding_title_styles = state.memo.title_styles
surrounding_section_level = state.memo.section_level
state.memo.title_styles = []
state.memo.section_level = 0
state.nested_parse(doc, content_offset, node, match_titles=1)
state.memo.title_styles = surrounding_title_styles
state.memo.section_level = surrounding_section_level
return node.children
def get_example_runner(document):
runner = getattr(document, 'click_example_runner', None)
if runner is None:
runner = document.click_example_runner = ExampleRunner()
return runner
class ExampleDirective(Directive):
has_content = True
required_arguments = 0
optional_arguments = 0
final_argument_whitespace = False
def run(self):
doc = ViewList()
runner = get_example_runner(self.state.document)
try:
runner.declare('\n'.join(self.content))
except:
runner.close()
raise
doc.append('.. sourcecode:: python', '')
doc.append('', '')
for line in self.content:
doc.append(' ' + line, '')
return parse_rst(self.state, self.content_offset, doc)
class RunExampleDirective(Directive):
has_content = True
required_arguments = 0
optional_arguments = 0
final_argument_whitespace = False
def run(self):
doc = ViewList()
runner = get_example_runner(self.state.document)
try:
rv = runner.run('\n'.join(self.content))
except:
runner.close()
raise
doc.append('.. sourcecode:: text', '')
doc.append('', '')
for line in rv:
doc.append(' ' + line, '')
return parse_rst(self.state, self.content_offset, doc)
class ClickDomain(Domain):
name = 'click'
label = 'Click'
directives = {
'example': ExampleDirective,
'run': RunExampleDirective,
}
def delete_example_runner_state(app, doctree):
runner = getattr(doctree, 'click_example_runner', None)
if runner is not None:
runner.close()
del doctree.click_example_runner
def setup(app):
app.add_domain(ClickDomain)
app.connect('doctree-read', delete_example_runner_state)
click-6.2/docs/commands.rst 0000644 0000765 0000024 00000044003 12626037411 017073 0 ustar mitsuhiko staff 0000000 0000000 Commands and Groups
===================
.. currentmodule:: click
The most important feature of Click is the concept of arbitrarily nesting
command line utilities. This is implemented through the :class:`Command`
and :class:`Group` (actually :class:`MultiCommand`).
Callback Invocation
-------------------
For a regular command, the callback is executed whenever the command runs.
If the script is the only command, it will always fire (unless a parameter
callback prevents it. This for instance happens if someone passes
``--help`` to the script).
For groups and multi commands, the situation looks different. In this case,
the callback fires whenever a subcommand fires (unless this behavior is
changed). What this means in practice is that an outer command runs
when an inner command runs:
.. click:example::
@click.group()
@click.option('--debug/--no-debug', default=False)
def cli(debug):
click.echo('Debug mode is %s' % ('on' if debug else 'off'))
@cli.command()
def sync():
click.echo('Synching')
Here is what this looks like:
.. click:run::
invoke(cli, prog_name='tool.py')
println()
invoke(cli, prog_name='tool.py', args=['--debug', 'sync'])
Passing Parameters
------------------
Click strictly separates parameters between commands and subcommands. What this
means is that options and arguments for a specific command have to be specified
*after* the command name itself, but *before* any other command names.
This behavior is already observable with the predefined ``--help`` option.
Suppose we have a program called ``tool.py``, containing a subcommand called
``sub``.
- ``tool.py --help`` will return the help for the whole program (listing
subcommands).
- ``tool.py sub --help`` will return the help for the ``sub`` subcommand.
- But ``tool.py --help sub`` will treat ``--help`` as an argument for the main
program. Click then invokes the callback for ``--help``, which prints the
help and aborts the program before click can process the subcommand.
Nested Handling and Contexts
----------------------------
As you can see from the earlier example, the basic command group accepts a
debug argument which is passed to its callback, but not to the sync
command itself. The sync command only accepts its own arguments.
This allows tools to act completely independent of each other, but how
does one command talk to a nested one? The answer to this is the
:class:`Context`.
Each time a command is invoked, a new context is created and linked with the
parent context. Normally, you can't see these contexts, but they are
there. Contexts are passed to parameter callbacks together with the
value automatically. Commands can also ask for the context to be passed
by marking themselves with the :func:`pass_context` decorator. In that
case, the context is passed as first argument.
The context can also carry a program specified object that can be
used for the program's purposes. What this means is that you can build a
script like this:
.. click:example::
@click.group()
@click.option('--debug/--no-debug', default=False)
@click.pass_context
def cli(ctx, debug):
ctx.obj['DEBUG'] = debug
@cli.command()
@click.pass_context
def sync(ctx):
click.echo('Debug is %s' % (ctx.obj['DEBUG'] and 'on' or 'off'))
if __name__ == '__main__':
cli(obj={})
If the object is provided, each context will pass the object onwards to
its children, but at any level a context's object can be overridden. To
reach to a parent, ``context.parent`` can be used.
In addition to that, instead of passing an object down, nothing stops the
application from modifying global state. For instance, you could just flip
a global ``DEBUG`` variable and be done with it.
Decorating Commands
-------------------
As you have seen in the earlier example, a decorator can change how a
command is invoked. What actually happens behind the scenes is that
callbacks are always invoked through the :meth:`Context.invoke` method
which automatically invokes a command correctly (by either passing the
context or not).
This is very useful when you want to write custom decorators. For
instance, a common pattern would be to configure an object representing
state and then storing it on the context and then to use a custom
decorator to find the most recent object of this sort and pass it as first
argument.
For instance, the :func:`pass_obj` decorator can be implemented like this:
.. click:example::
from functools import update_wrapper
def pass_obj(f):
@click.pass_context
def new_func(ctx, *args, **kwargs):
return ctx.invoke(f, ctx.obj, *args, **kwargs)
return update_wrapper(new_func, f)
The :meth:`Context.invoke` command will automatically invoke the function
in the correct way, so the function will either be called with ``f(ctx,
obj)`` or ``f(obj)`` depending on whether or not it itself is decorated with
:func:`pass_context`.
This is a very powerful concept that can be used to build very complex
nested applications; see :ref:`complex-guide` for more information.
Group Invocation Without Command
--------------------------------
By default, a group or multi command is not invoked unless a subcommand is
passed. In fact, not providing a command automatically passes ``--help``
by default. This behavior can be changed by passing
``invoke_without_command=True`` to a group. In that case, the callback is
always invoked instead of showing the help page. The context object also
includes information about whether or not the invocation would go to a
subcommand.
Example:
.. click:example::
@click.group(invoke_without_command=True)
@click.pass_context
def cli(ctx):
if ctx.invoked_subcommand is None:
click.echo('I was invoked without subcommand')
else:
click.echo('I am about to invoke %s' % ctx.invoked_subcommand)
@cli.command()
def sync():
click.echo('The subcommand')
And how it works in practice:
.. click:run::
invoke(cli, prog_name='tool', args=[])
invoke(cli, prog_name='tool', args=['sync'])
.. _custom-multi-commands:
Custom Multi Commands
---------------------
In addition to using :func:`click.group`, you can also build your own
custom multi commands. This is useful when you want to support commands
being loaded lazily from plugins.
A custom multi command just needs to implement a list and load method:
.. click:example::
import click
import os
plugin_folder = os.path.join(os.path.dirname(__file__), 'commands')
class MyCLI(click.MultiCommand):
def list_commands(self, ctx):
rv = []
for filename in os.listdir(plugin_folder):
if filename.endswith('.py'):
rv.append(filename[:-3])
rv.sort()
return rv
def get_command(self, ctx, name):
ns = {}
fn = os.path.join(plugin_folder, name + '.py')
with open(fn) as f:
code = compile(f.read(), fn, 'exec')
eval(code, ns, ns)
return ns['cli']
cli = MyCLI(help='This tool\'s subcommands are loaded from a '
'plugin folder dynamically.')
if __name__ == '__main__':
cli()
These custom classes can also be used with decorators:
.. click:example::
@click.command(cls=MyCLI)
def cli():
pass
Merging Multi Commands
----------------------
In addition to implementing custom multi commands, it can also be
interesting to merge multiple together into one script. While this is
generally not as recommended as it nests one below the other, the merging
approach can be useful in some circumstances for a nicer shell experience.
The default implementation for such a merging system is the
:class:`CommandCollection` class. It accepts a list of other multi
commands and makes the commands available on the same level.
Example usage:
.. click:example::
import click
@click.group()
def cli1():
pass
@cli1.command()
def cmd1():
"""Command on cli1"""
@click.group()
def cli2():
pass
@cli2.command()
def cmd2():
"""Command on cli2"""
cli = click.CommandCollection(sources=[cli1, cli2])
if __name__ == '__main__':
cli()
And what it looks like:
.. click:run::
invoke(cli, prog_name='cli', args=['--help'])
In case a command exists in more than one source, the first source wins.
.. _multi-command-chaining:
Multi Command Chaining
----------------------
.. versionadded:: 3.0
Sometimes it is useful to be allowed to invoke more than one subcommand in
one go. For instance if you have installed a setuptools package before
you might be familiar with the ``setup.py sdist bdist_wheel upload``
command chain which invokes ``dist`` before ``bdist_wheel`` before
``upload``. Starting with Click 3.0 this is very simple to implement.
All you have to do is to pass ``chain=True`` to your multicommand:
.. click:example::
@click.group(chain=True)
def cli():
pass
@cli.command('sdist')
def sdist():
click.echo('sdist called')
@cli.command('bdist_wheel')
def bdist_wheel():
click.echo('bdist_wheel called')
Now you can invoke it like this:
.. click:run::
invoke(cli, prog_name='setup.py', args=['sdist', 'bdist_wheel'])
When using multi command chaining you can only have one command (the last)
use ``nargs=-1`` on an argument. It is also not possible to nest multi
commands below chained multicommands. Other than that there are no
restrictions on how they work. They can accept options and arguments as
normal.
Another note: the :attr:`Context.invoked_subcommand` attribute is a bit
useless for multi commands as it will give ``'*'`` as value if more than
one command is invoked. This is necessary because the handling of
subcommands happens one after another so the exact subcommands that will
be handled are not yet available when the callback fires.
.. note::
It is currently not possible for chain commands to be nested. This
will be fixed in future versions of Click.
Multi Command Pipelines
-----------------------
.. versionadded:: 3.0
A very common usecase of multi command chaining is to have one command
process the result of the previous command. There are various ways in
which this can be facilitated. The most obvious way is to store a value
on the context object and process it from function to function. This
works by decorating a function with :func:`pass_context` after which the
context object is provided and a subcommand can store its data there.
Another way to accomplish this is to setup pipelines by returning
processing functions. Think of it like this: when a subcommand gets
invoked it processes all of its parameters and comes up with a plan of
how to do its processing. At that point it then returns a processing
function and returns.
Where do the returned functions go? The chained multicommand can register
a callback with :meth:`MultiCommand.resultcallback` that goes over all
these functions and then invoke them.
To make this a bit more concrete consider this example:
.. click:example::
@click.group(chain=True, invoke_without_command=True)
@click.option('-i', '--input', type=click.File('r'))
def cli(input):
pass
@cli.resultcallback()
def process_pipeline(processors, input):
iterator = (x.rstrip('\r\n') for x in input)
for processor in processors:
iterator = processor(iterator)
for item in iterator:
click.echo(item)
@cli.command('uppercase')
def make_uppercase():
def processor(iterator):
for line in iterator:
yield line.upper()
return processor
@cli.command('lowercase')
def make_lowercase():
def processor(iterator):
for line in iterator:
yield line.lower()
return processor
@cli.command('strip')
def make_strip():
def processor(iterator):
for line in iterator:
yield line.strip()
return processor
That's a lot in one go, so let's go through it step by step.
1. The first thing is to make a :func:`group` that is chainable. In
addition to that we also instruct Click to invoke even if no
subcommand is defined. If this would not be done, then invoking an
empty pipeline would produce the help page instead of running the
result callbacks.
2. The next thing we do is to register a result callback on our group.
This callback will be invoked with an argument which is the list of
all return values of all subcommands and then the same keyword
parameters as our group itself. This means we can access the input
file easily there without having to use the context object.
3. In this result callback we create an iterator of all the lines in the
input file and then pass this iterator through all the returned
callbacks from all subcommands and finally we print all lines to
stdout.
After that point we can register as many subcommands as we want and each
subcommand can return a processor function to modify the stream of lines.
One important thing of note is that Click shuts down the context after
each callback has been run. This means that for instance file types
cannot be accessed in the `processor` functions as the files will already
be closed there. This limitation is unlikely to change because it would
make resource handling much more complicated. For such it's recommended
to not use the file type and manually open the file through
:func:`open_file`.
For a more complex example that also improves upon handling of the
pipelines have a look at the `imagepipe multi command chaining demo
`__ in
the Click repository. It implements a pipeline based image editing tool
that has a nice internal structure for the pipelines.
Overriding Defaults
-------------------
By default, the default value for a parameter is pulled from the
``default`` flag that is provided when it's defined, but that's not the
only place defaults can be loaded from. The other place is the
:attr:`Context.default_map` (a dictionary) on the context. This allows
defaults to be loaded from a configuration file to override the regular
defaults.
This is useful if you plug in some commands from another package but
you're not satisfied with the defaults.
The default map can be nested arbitrarily for each subcommand and
provided when the script is invoked. Alternatively, it can also be
overriden at any point by commands. For instance, a top-level command could
load the defaults from a configuration file.
Example usage:
.. click:example::
import click
@click.group()
def cli():
pass
@cli.command()
@click.option('--port', default=8000)
def runserver(port):
click.echo('Serving on http://127.0.0.1:%d/' % port)
if __name__ == '__main__':
cli(default_map={
'runserver': {
'port': 5000
}
})
And in action:
.. click:run::
invoke(cli, prog_name='cli', args=['runserver'], default_map={
'runserver': {
'port': 5000
}
})
Context Defaults
----------------
.. versionadded:: 2.0
Starting with Click 2.0 you can override defaults for contexts not just
when calling your script, but also in the decorator that declares a
command. For instance given the previous example which defines a custom
``default_map`` this can also be accomplished in the decorator now.
This example does the same as the previous example:
.. click:example::
import click
CONTEXT_SETTINGS = dict(
default_map={'runserver': {'port': 5000}}
)
@click.group(context_settings=CONTEXT_SETTINGS)
def cli():
pass
@cli.command()
@click.option('--port', default=8000)
def runserver(port):
click.echo('Serving on http://127.0.0.1:%d/' % port)
if __name__ == '__main__':
cli()
And again the example in action:
.. click:run::
invoke(cli, prog_name='cli', args=['runserver'])
Command Return Values
---------------------
.. versionadded:: 3.0
One of the new introductions in Click 3.0 is the full support for return
values from command callbacks. This enables a whole range of features
that were previously hard to implement.
In essence any command callback can now return a value. This return value
is bubbled to certain receivers. One usecase for this has already been
show in the example of :ref:`multi-command-chaining` where it has been
demonstrated that chained multi commands can have callbacks that process
all return values.
When working with command return values in Click, this is what you need to
know:
- The return value of a command callback is generally returned from the
:meth:`BaseCommand.invoke` method. The exception to this rule has to
do with :class:`Group`\s:
* In a group the return value is generally the return value of the
subcommand invoked. The only exception to this rule is that the
return value is the return value of the group callback if it's
invoked without arguments and `invoke_without_command` is enabled.
* If a group is set up for chaining then the return value is a list
of all subcommands' results.
* Return values of groups can be processed through a
:attr:`MultiCommand.result_callback`. This is invoked with the
list of all return values in chain mode, or the single return
value in case of non chained commands.
- The return value is bubbled through from the :meth:`Context.invoke`
and :meth:`Context.forward` methods. This is useful in situations
where you internally want to call into another command.
- Click does not have any hard requirements for the return values and
does not use them itself. This allows return values to be used for
custom decorators or workflows (like in the multi command chaining
example).
- When a Click script is invoked as command line application (through
:meth:`BaseCommand.main`) the return value is ignored unless the
`standalone_mode` is disabled in which case it's bubbled through.
click-6.2/docs/complex.rst 0000644 0000765 0000024 00000017147 12372607550 016757 0 ustar mitsuhiko staff 0000000 0000000 .. _complex-guide:
Complex Applications
====================
.. currentmodule:: click
Click is designed to assist with the creation of complex and simple CLI tools
alike. However, the power of its design is the ability to arbitrarily nest
systems together. For instance, if you have ever used Django, you will
have realized that it provides a command line utility, but so does Celery.
When using Celery with Django, there are two tools that need to interact with
each other and be cross-configured.
In a theoretical world of two separate Click command line utilities, they
could solve this problem by nesting one inside the other. For instance, the
web framework could also load the commands for the message queue framework.
Basic Concepts
--------------
To understand how this works, you need to understand two concepts: contexts
and the calling convention.
Contexts
````````
Whenever a Click command is executed, a :class:`Context` object is created
which holds state for this particular invocation. It remembers parsed
parameters, what command created it, which resources need to be cleaned up
at the end of the function, and so forth. It can also optionally hold an
application-defined object.
Context objects build a linked list until they hit the top one. Each context
is linked to a parent context. This allows a command to work below
another command and store its own information there without having to be
afraid of altering up the state of the parent command.
Because the parent data is available, however, it is possible to navigate to
it if needed.
Most of the time, you do not see the context object, but when writing more
complex applications it comes in handy. This brings us to the next point.
Calling Convention
``````````````````
When a Click command callback is executed, it's passed all the non-hidden
parameters as keyword arguments. Notably absent is the context. However,
a callback can opt into being passed to the context object by marking itself
with :func:`pass_context`.
So how do you invoke a command callback if you don't know if it should
receive the context or not? The answer is that the context itself
provides a helper function (:meth:`Context.invoke`) which can do this for
you. It accepts the callback as first argument and then invokes the
function correctly.
Building a Git Clone
--------------------
In this example, we want to build a command line tool that resembles a
version control system. Systems like Git usually provide one
over-arching command that already accepts some parameters and
configuration, and then have extra subcommands that do other things.
The Root Command
````````````````
At the top level, we need a group that can hold all our commands. In this
case, we use the basic :func:`click.group` which allows us to register
other Click commands below it.
For this command, we also want to accept some parameters that configure the
state of our tool:
.. click:example::
import os
import click
class Repo(object):
def __init__(self, home=None, debug=False):
self.home = os.path.abspath(home or '.')
self.debug = debug
@click.group()
@click.option('--repo-home', envvar='REPO_HOME', default='.repo')
@click.option('--debug/--no-debug', default=False,
envvar='REPO_DEBUG')
@click.pass_context
def cli(ctx, repo_home, debug):
ctx.obj = Repo(repo_home, debug)
Let's understand what this does. We create a group command which can
have subcommands. When it is invoked, it will create an instance of a
``Repo`` class. This holds the state for our command line tool. In this
case, it just remembers some parameters, but at this point it could also
start loading configuration files and so on.
This state object is then remembered by the context as :attr:`~Context.obj`.
This is a special attribute where commands are supposed to remember what
they need to pass on to their children.
In order for this to work, we need to mark our function with
:func:`pass_context`, because otherwise, the context object would be
entirely hidden from us.
The First Child Command
```````````````````````
Let's add our first child command to it, the clone command:
.. click:example::
@cli.command()
@click.argument('src')
@click.argument('dest', required=False)
def clone(src, dest):
pass
So now we have a clone command, but how do we get access to the repo? As
you can imagine, one way is to use the :func:`pass_context` function which
again will make our callback also get the context passed on which we
memorized the repo. However, there is a second version of this decorator
called :func:`pass_obj` which will just pass the stored object, (in our case
the repo):
.. click:example::
@cli.command()
@click.argument('src')
@click.argument('dest', required=False)
@click.pass_obj
def clone(repo, src, dest):
pass
Interleaved Commands
````````````````````
While not relevant for the particular program we want to build, there is
also quite good support for interleaving systems. Imagine for instance that
there was a super cool plugin for our version control system that needed a
lot of configuration and wanted to store its own configuration as
:attr:`~Context.obj`. If we would then attach another command below that,
we would all of a sudden get the plugin configuration instead of our repo
object.
One obvious way to remedy this is to store a reference to the repo in the
plugin, but then a command needs to be aware that it's attached below such a
plugin.
There is a much better system that can built by taking advantage of the linked
nature of contexts. We know that the plugin context is linked to the context
that created our repo. Because of that, we can start a search for the last
level where the object stored by the context was a repo.
Built-in support for this is provided by the :func:`make_pass_decorator`
factory, which will create decorators for us that find objects (it
internally calls into :meth:`Context.find_object`). In our case, we
know that we want to find the closest ``Repo`` object, so let's make a
decorator for this:
.. click:example::
pass_repo = click.make_pass_decorator(Repo)
If we now use ``pass_repo`` instead of ``pass_obj``, we will always get a
repo instead of something else:
.. click:example::
@cli.command()
@click.argument('src')
@click.argument('dest', required=False)
@pass_repo
def clone(repo, src, dest):
pass
Ensuring Object Creation
````````````````````````
The above example only works if there was an outer command that created a
``Repo`` object and stored it in the context. For some more advanced use
cases, this might become a problem. The default behavior of
:func:`make_pass_decorator` is to call :meth:`Context.find_object`
which will find the object. If it can't find the object, it will raise an
error. The alternative behavior is to use :meth:`Context.ensure_object`
which will find the object, and if it cannot find it, will create one and
store it in the innermost context. This behavior can also be enabled for
:func:`make_pass_decorator` by passing ``ensure=True``:
.. click:example::
pass_repo = click.make_pass_decorator(Repo, ensure=True)
In this case, the innermost context gets an object created if it is
missing. This might replace objects being placed there earlier. In this
case, the command stays executable, even if the outer command does not run.
For this to work, the object type needs to have a constructor that accepts
no arguments.
As such it runs standalone:
.. click:example::
@click.command()
@pass_repo
def cp(repo):
click.echo(repo)
As you can see:
.. click:run::
invoke(cp, [])
click-6.2/docs/conf.py 0000644 0000765 0000024 00000016024 12561167361 016047 0 ustar mitsuhiko staff 0000000 0000000 # -*- coding: utf-8 -*-
#
# click documentation build configuration file, created by
# sphinx-quickstart on Mon Apr 26 19:53:01 2010.
#
# This file is execfile()d with the current directory set to its containing dir.
#
# Note that not all possible configuration values are present in this
# autogenerated file.
#
# All configuration values have a default; values that are commented out
# serve to show the default.
import sys, os
import datetime
# If extensions (or modules to document with autodoc) are in another directory,
# add these directories to sys.path here. If the directory is relative to the
# documentation root, use os.path.abspath to make it absolute, like shown here.
sys.path.append(os.path.abspath('..'))
sys.path.append(os.path.abspath('.'))
# -- General configuration -----------------------------------------------------
# If your documentation needs a minimal Sphinx version, state it here.
#needs_sphinx = '1.0'
# Add any Sphinx extension module names here, as strings. They can be extensions
# coming with Sphinx (named 'sphinx.ext.*') or your custom ones.
extensions = ['sphinx.ext.autodoc', 'sphinx.ext.intersphinx',
'clickdoctools']
# Add any paths that contain templates here, relative to this directory.
templates_path = ['_templates']
# The suffix of source filenames.
source_suffix = '.rst'
# The encoding of source files.
#source_encoding = 'utf-8-sig'
# The master toctree document.
master_doc = 'index'
# General information about the project.
project = u'click'
copyright = u'%d, Armin Ronacher' % datetime.datetime.utcnow().year
# The version info for the project you're documenting, acts as replacement for
# |version| and |release|, also used in various other places throughout the
# built documents.
#
# The short X.Y version.
version = '1.0'
# The full version, including alpha/beta/rc tags.
release = '1.0'
# The language for content autogenerated by Sphinx. Refer to documentation
# for a list of supported languages.
#language = None
# There are two options for replacing |today|: either, you set today to some
# non-false value, then it is used:
#today = ''
# Else, today_fmt is used as the format for a strftime call.
#today_fmt = '%B %d, %Y'
# List of patterns, relative to source directory, that match files and
# directories to ignore when looking for source files.
exclude_patterns = ['_build']
# The reST default role (used for this markup: `text`) to use for all documents.
#default_role = None
# If true, '()' will be appended to :func: etc. cross-reference text.
#add_function_parentheses = True
# If true, the current module name will be prepended to all description
# unit titles (such as .. function::).
#add_module_names = True
# If true, sectionauthor and moduleauthor directives will be shown in the
# output. They are ignored by default.
#show_authors = False
# A list of ignored prefixes for module index sorting.
#modindex_common_prefix = []
# -- Options for HTML output ---------------------------------------------------
# The theme to use for HTML and HTML Help pages. Major themes that come with
# Sphinx are currently 'default' and 'sphinxdoc'.
#html_theme = 'default'
# Theme options are theme-specific and customize the look and feel of a theme
# further. For a list of options available for each theme, see the
# documentation.
html_theme_options = {
}
# Add any paths that contain custom themes here, relative to this directory.
#html_theme_path = ['_themes']
# The name for this set of Sphinx documents. If None, it defaults to
# " v documentation".
html_title = 'click'
# A shorter title for the navigation bar. Default is the same as html_title.
#html_short_title = None
# The name of an image file (relative to this directory) to place at the top
# of the sidebar.
#html_logo = None
# The name of an image file (within the static path) to use as favicon of the
# docs. This file should be a Windows icon file (.ico) being 16x16 or 32x32
# pixels large.
#html_favicon = None
# Add any paths that contain custom static files (such as style sheets) here,
# relative to this directory. They are copied after the builtin static files,
# so a file named "default.css" will overwrite the builtin "default.css".
html_static_path = ['_static']
# If not '', a 'Last updated on:' timestamp is inserted at every page bottom,
# using the given strftime format.
#html_last_updated_fmt = '%b %d, %Y'
# If true, SmartyPants will be used to convert quotes and dashes to
# typographically correct entities.
#html_use_smartypants = True
# Custom sidebar templates, maps document names to template names.
html_sidebars = {
'index': ['sidebarintro.html', 'sourcelink.html', 'searchbox.html'],
'**': ['sidebarlogo.html', 'localtoc.html', 'relations.html',
'sourcelink.html', 'searchbox.html']
}
# Additional templates that should be rendered to pages, maps page names to
# template names.
#html_additional_pages = {}
# If false, no module index is generated.
#html_domain_indices = True
# If false, no index is generated.
#html_use_index = True
# If true, the index is split into individual pages for each letter.
#html_split_index = False
# If true, links to the reST sources are added to the pages.
#html_show_sourcelink = True
# If true, "Created using Sphinx" is shown in the HTML footer. Default is True.
#html_show_sphinx = True
# If true, "(C) Copyright ..." is shown in the HTML footer. Default is True.
#html_show_copyright = True
# If true, an OpenSearch description file will be output, and all pages will
# contain a ')
@click.option('--count', default=1, help='number of greetings',
metavar='')
@click.argument('name', metavar='')
def hello(count, name):
"""This script prints hello times."""
for x in range(count):
click.echo('Hello %s!' % name)
Example:
.. click:run::
invoke(hello, args=['--help'])
Command Short Help
------------------
For commands, a short help snippet is generated. By default, it's the first
sentence of the help message of the command, unless it's too long. This can
also be overridden:
.. click:example::
@click.group()
def cli():
"""A simple command line tool."""
@cli.command('init', short_help='init the repo')
def init():
"""Initializes the repository."""
@cli.command('delete', short_help='delete the repo')
def delete():
"""Deletes the repository."""
And what it looks like:
.. click:run::
invoke(cli, prog_name='repo.py')
Help Parameter Customization
----------------------------
.. versionadded:: 2.0
The help parameter is implemented in Click in a very special manner.
Unlike regular parameters it's automatically added by Click for any
command and it performs automatic conflict resolution. By default it's
called ``--help``, but this can be changed. If a command itself implements
a parameter with the same name, the default help parameter stops accepting
it. There is a context setting that can be used to override the names of
the help parameters called :attr:`~Context.help_option_names`.
This example changes the default parameters to ``-h`` and ``--help``
instead of just ``--help``:
.. click:example::
CONTEXT_SETTINGS = dict(help_option_names=['-h', '--help'])
@click.command(context_settings=CONTEXT_SETTINGS)
def cli():
pass
And what it looks like:
.. click:run::
invoke(cli, ['-h'])
click-6.2/docs/exceptions.rst 0000644 0000765 0000024 00000005554 12372607550 017470 0 ustar mitsuhiko staff 0000000 0000000 Exception Handling
==================
.. currentmodule:: click
Click internally uses exceptions to signal various error conditions that
the user of the application might have caused. Primarily this is things
like incorrect usage.
Where are Errors Handled?
-------------------------
Click's main error handling is happening in :meth:`BaseCommand.main`. In
there it handles all subclasses of :exc:`ClickException` as well as the
standard :exc:`EOFError` and :exc:`KeyboardInterrupt` exceptions. The
latter are internally translated into a :exc:`Abort`.
The logic applied is the following:
1. If an :exc:`EOFError` or :exc:`KeyboardInterrupt` happens, reraise it
as :exc:`Abort`.
2. If an :exc:`ClickException` is raised, invoke the
:meth:`ClickException.show` method on it to display it and then exit
the program with :attr:`ClickException.exit_code`.
3. If an :exc:`Abort` exception is raised print the string ``Aborted!``
to standard error and exit the program with exit code ``1``.
4. if it goes through well, exit the program with exit code ``0``.
What if I don't want that?
--------------------------
Generally you always have the option to invoke the :meth:`invoke` method
yourself. For instance if you have a :class:`Command` you can invoke it
manually like this::
ctx = command.make_context('command-name', ['args', 'go', 'here'])
with ctx:
result = command.invoke(ctx)
In this case exceptions will not be handled at all and bubbled up as you
would expect.
Starting with Click 3.0 you can also use the :meth:`Command.main` method
but disable the standalone mode which will do two things: disable
exception handling and disable the implicit :meth:`sys.exit` at the end.
So you can do something like this::
command.main(['command-name', 'args', 'go', 'here'],
standalone_mode=False)
Which Exceptions Exist?
-----------------------
Click has two exception bases: :exc:`ClickException` which is raised for
all exceptions that Click wants to signal to the user and :exc:`Abort`
which is used to instruct Click to abort the execution.
A :exc:`ClickException` has a :meth:`~ClickException.show` method which
can render an error message to stderr or the given file object. If you
want to use the exception yourself for doing something check the API docs
about what else they provide.
The following common subclasses exist:
* :exc:`UsageError` to inform the user that something went wrong.
* :exc:`BadParameter` to inform the user that something went wrong with
a specific parameter. These are often handled internally in Click and
augmented with extra information if possible. For instance if those
are raised from a callback Click will automatically augment it with
the parameter name if possible.
* :exc:`FileError` this is an error that is raised by the
:exc:`FileType` if Click encounters issues opening the file.
click-6.2/docs/index.rst 0000644 0000765 0000024 00000004171 12617103140 016374 0 ustar mitsuhiko staff 0000000 0000000 Welcome to the Click Documentation
==================================
Click is a Python package for creating beautiful command line interfaces
in a composable way with as little code as necessary. It's the "Command
Line Interface Creation Kit". It's highly configurable but comes with
sensible defaults out of the box.
It aims to make the process of writing command line tools quick and fun
while also preventing any frustration caused by the inability to implement
an intended CLI API.
Click in three points:
- arbitrary nesting of commands
- automatic help page generation
- supports lazy loading of subcommands at runtime
What does it look like? Here is an example of a simple Click program:
.. click:example::
import click
@click.command()
@click.option('--count', default=1, help='Number of greetings.')
@click.option('--name', prompt='Your name',
help='The person to greet.')
def hello(count, name):
"""Simple program that greets NAME for a total of COUNT times."""
for x in range(count):
click.echo('Hello %s!' % name)
if __name__ == '__main__':
hello()
And what it looks like when run:
.. click:run::
invoke(hello, ['--count=3'], prog_name='python hello.py', input='John\n')
It automatically generates nicely formatted help pages:
.. click:run::
invoke(hello, ['--help'], prog_name='python hello.py')
You can get the library directly from PyPI::
pip install click
Documentation Contents
----------------------
This part of the documentation guides you through all of the library's
usage patterns.
.. toctree::
:maxdepth: 2
why
quickstart
setuptools
parameters
options
arguments
commands
prompts
documentation
complex
advanced
testing
utils
bashcomplete
exceptions
python3
wincmd
API Reference
-------------
If you are looking for information on a specific function, class, or
method, this part of the documentation is for you.
.. toctree::
:maxdepth: 2
api
Miscellaneous Pages
-------------------
.. toctree::
:maxdepth: 2
contrib
changelog
upgrading
license
click-6.2/docs/license.rst 0000644 0000765 0000024 00000000622 12372607550 016720 0 ustar mitsuhiko staff 0000000 0000000 License
=======
Click is licensed under a three-clause BSD License. It basically means:
do whatever you want with it as long as the copyright in Click sticks
around, the conditions are not modified and the disclaimer is present.
Furthermore, you must not use the names of the authors to promote derivatives
of the software without written consent.
License Text
------------
.. include:: ../LICENSE
click-6.2/docs/make.bat 0000644 0000765 0000024 00000010012 12370501774 016142 0 ustar mitsuhiko staff 0000000 0000000 @ECHO OFF
REM Command file for Sphinx documentation
if "%SPHINXBUILD%" == "" (
set SPHINXBUILD=sphinx-build
)
set BUILDDIR=_build
set ALLSPHINXOPTS=-d %BUILDDIR%/doctrees %SPHINXOPTS% .
if NOT "%PAPER%" == "" (
set ALLSPHINXOPTS=-D latex_paper_size=%PAPER% %ALLSPHINXOPTS%
)
if "%1" == "" goto help
if "%1" == "help" (
:help
echo.Please use `make ^` where ^ is one of
echo. html to make standalone HTML files
echo. dirhtml to make HTML files named index.html in directories
echo. singlehtml to make a single large HTML file
echo. pickle to make pickle files
echo. json to make JSON files
echo. htmlhelp to make HTML files and a HTML help project
echo. qthelp to make HTML files and a qthelp project
echo. devhelp to make HTML files and a Devhelp project
echo. epub to make an epub
echo. latex to make LaTeX files, you can set PAPER=a4 or PAPER=letter
echo. text to make text files
echo. man to make manual pages
echo. changes to make an overview over all changed/added/deprecated items
echo. linkcheck to check all external links for integrity
echo. doctest to run all doctests embedded in the documentation if enabled
goto end
)
if "%1" == "clean" (
for /d %%i in (%BUILDDIR%\*) do rmdir /q /s %%i
del /q /s %BUILDDIR%\*
goto end
)
if "%1" == "html" (
%SPHINXBUILD% -b html %ALLSPHINXOPTS% %BUILDDIR%/html
echo.
echo.Build finished. The HTML pages are in %BUILDDIR%/html.
goto end
)
if "%1" == "dirhtml" (
%SPHINXBUILD% -b dirhtml %ALLSPHINXOPTS% %BUILDDIR%/dirhtml
echo.
echo.Build finished. The HTML pages are in %BUILDDIR%/dirhtml.
goto end
)
if "%1" == "singlehtml" (
%SPHINXBUILD% -b singlehtml %ALLSPHINXOPTS% %BUILDDIR%/singlehtml
echo.
echo.Build finished. The HTML pages are in %BUILDDIR%/singlehtml.
goto end
)
if "%1" == "pickle" (
%SPHINXBUILD% -b pickle %ALLSPHINXOPTS% %BUILDDIR%/pickle
echo.
echo.Build finished; now you can process the pickle files.
goto end
)
if "%1" == "json" (
%SPHINXBUILD% -b json %ALLSPHINXOPTS% %BUILDDIR%/json
echo.
echo.Build finished; now you can process the JSON files.
goto end
)
if "%1" == "htmlhelp" (
%SPHINXBUILD% -b htmlhelp %ALLSPHINXOPTS% %BUILDDIR%/htmlhelp
echo.
echo.Build finished; now you can run HTML Help Workshop with the ^
.hhp project file in %BUILDDIR%/htmlhelp.
goto end
)
if "%1" == "qthelp" (
%SPHINXBUILD% -b qthelp %ALLSPHINXOPTS% %BUILDDIR%/qthelp
echo.
echo.Build finished; now you can run "qcollectiongenerator" with the ^
.qhcp project file in %BUILDDIR%/qthelp, like this:
echo.^> qcollectiongenerator %BUILDDIR%\qthelp\Classy.qhcp
echo.To view the help file:
echo.^> assistant -collectionFile %BUILDDIR%\qthelp\Classy.ghc
goto end
)
if "%1" == "devhelp" (
%SPHINXBUILD% -b devhelp %ALLSPHINXOPTS% %BUILDDIR%/devhelp
echo.
echo.Build finished.
goto end
)
if "%1" == "epub" (
%SPHINXBUILD% -b epub %ALLSPHINXOPTS% %BUILDDIR%/epub
echo.
echo.Build finished. The epub file is in %BUILDDIR%/epub.
goto end
)
if "%1" == "latex" (
%SPHINXBUILD% -b latex %ALLSPHINXOPTS% %BUILDDIR%/latex
echo.
echo.Build finished; the LaTeX files are in %BUILDDIR%/latex.
goto end
)
if "%1" == "text" (
%SPHINXBUILD% -b text %ALLSPHINXOPTS% %BUILDDIR%/text
echo.
echo.Build finished. The text files are in %BUILDDIR%/text.
goto end
)
if "%1" == "man" (
%SPHINXBUILD% -b man %ALLSPHINXOPTS% %BUILDDIR%/man
echo.
echo.Build finished. The manual pages are in %BUILDDIR%/man.
goto end
)
if "%1" == "changes" (
%SPHINXBUILD% -b changes %ALLSPHINXOPTS% %BUILDDIR%/changes
echo.
echo.The overview file is in %BUILDDIR%/changes.
goto end
)
if "%1" == "linkcheck" (
%SPHINXBUILD% -b linkcheck %ALLSPHINXOPTS% %BUILDDIR%/linkcheck
echo.
echo.Link check complete; look for any errors in the above output ^
or in %BUILDDIR%/linkcheck/output.txt.
goto end
)
if "%1" == "doctest" (
%SPHINXBUILD% -b doctest %ALLSPHINXOPTS% %BUILDDIR%/doctest
echo.
echo.Testing of doctests in the sources finished, look at the ^
results in %BUILDDIR%/doctest/output.txt.
goto end
)
:end
click-6.2/docs/Makefile 0000644 0000765 0000024 00000010731 12370501774 016205 0 ustar mitsuhiko staff 0000000 0000000 # Makefile for Sphinx documentation
#
# You can set these variables from the command line.
SPHINXOPTS =
SPHINXBUILD = sphinx-build
PAPER =
BUILDDIR = _build
# Internal variables.
PAPEROPT_a4 = -D latex_paper_size=a4
PAPEROPT_letter = -D latex_paper_size=letter
ALLSPHINXOPTS = -d $(BUILDDIR)/doctrees $(PAPEROPT_$(PAPER)) $(SPHINXOPTS) .
.PHONY: help clean html dirhtml singlehtml pickle json htmlhelp qthelp devhelp epub latex latexpdf text man changes linkcheck doctest
help:
@echo "Please use \`make ' where is one of"
@echo " html to make standalone HTML files"
@echo " dirhtml to make HTML files named index.html in directories"
@echo " singlehtml to make a single large HTML file"
@echo " pickle to make pickle files"
@echo " json to make JSON files"
@echo " htmlhelp to make HTML files and a HTML help project"
@echo " qthelp to make HTML files and a qthelp project"
@echo " devhelp to make HTML files and a Devhelp project"
@echo " epub to make an epub"
@echo " latex to make LaTeX files, you can set PAPER=a4 or PAPER=letter"
@echo " latexpdf to make LaTeX files and run them through pdflatex"
@echo " text to make text files"
@echo " man to make manual pages"
@echo " changes to make an overview of all changed/added/deprecated items"
@echo " linkcheck to check all external links for integrity"
@echo " doctest to run all doctests embedded in the documentation (if enabled)"
clean:
-rm -rf $(BUILDDIR)/*
html:
$(SPHINXBUILD) -b html $(ALLSPHINXOPTS) $(BUILDDIR)/html
@echo
@echo "Build finished. The HTML pages are in $(BUILDDIR)/html."
dirhtml:
$(SPHINXBUILD) -b dirhtml $(ALLSPHINXOPTS) $(BUILDDIR)/dirhtml
@echo
@echo "Build finished. The HTML pages are in $(BUILDDIR)/dirhtml."
singlehtml:
$(SPHINXBUILD) -b singlehtml $(ALLSPHINXOPTS) $(BUILDDIR)/singlehtml
@echo
@echo "Build finished. The HTML page is in $(BUILDDIR)/singlehtml."
pickle:
$(SPHINXBUILD) -b pickle $(ALLSPHINXOPTS) $(BUILDDIR)/pickle
@echo
@echo "Build finished; now you can process the pickle files."
json:
$(SPHINXBUILD) -b json $(ALLSPHINXOPTS) $(BUILDDIR)/json
@echo
@echo "Build finished; now you can process the JSON files."
htmlhelp:
$(SPHINXBUILD) -b htmlhelp $(ALLSPHINXOPTS) $(BUILDDIR)/htmlhelp
@echo
@echo "Build finished; now you can run HTML Help Workshop with the" \
".hhp project file in $(BUILDDIR)/htmlhelp."
qthelp:
$(SPHINXBUILD) -b qthelp $(ALLSPHINXOPTS) $(BUILDDIR)/qthelp
@echo
@echo "Build finished; now you can run "qcollectiongenerator" with the" \
".qhcp project file in $(BUILDDIR)/qthelp, like this:"
@echo "# qcollectiongenerator $(BUILDDIR)/qthelp/Classy.qhcp"
@echo "To view the help file:"
@echo "# assistant -collectionFile $(BUILDDIR)/qthelp/Classy.qhc"
devhelp:
$(SPHINXBUILD) -b devhelp $(ALLSPHINXOPTS) $(BUILDDIR)/devhelp
@echo
@echo "Build finished."
@echo "To view the help file:"
@echo "# mkdir -p $$HOME/.local/share/devhelp/Classy"
@echo "# ln -s $(BUILDDIR)/devhelp $$HOME/.local/share/devhelp/Classy"
@echo "# devhelp"
epub:
$(SPHINXBUILD) -b epub $(ALLSPHINXOPTS) $(BUILDDIR)/epub
@echo
@echo "Build finished. The epub file is in $(BUILDDIR)/epub."
latex:
$(SPHINXBUILD) -b latex $(ALLSPHINXOPTS) $(BUILDDIR)/latex
@echo
@echo "Build finished; the LaTeX files are in $(BUILDDIR)/latex."
@echo "Run \`make all-pdf' or \`make all-ps' in that directory to" \
"run these through (pdf)latex."
latexpdf: latex
$(SPHINXBUILD) -b latex $(ALLSPHINXOPTS) $(BUILDDIR)/latex
@echo "Running LaTeX files through pdflatex..."
make -C $(BUILDDIR)/latex all-pdf
@echo "pdflatex finished; the PDF files are in $(BUILDDIR)/latex."
text:
$(SPHINXBUILD) -b text $(ALLSPHINXOPTS) $(BUILDDIR)/text
@echo
@echo "Build finished. The text files are in $(BUILDDIR)/text."
man:
$(SPHINXBUILD) -b man $(ALLSPHINXOPTS) $(BUILDDIR)/man
@echo
@echo "Build finished. The manual pages are in $(BUILDDIR)/man."
changes:
$(SPHINXBUILD) -b changes $(ALLSPHINXOPTS) $(BUILDDIR)/changes
@echo
@echo "The overview file is in $(BUILDDIR)/changes."
linkcheck:
$(SPHINXBUILD) -b linkcheck $(ALLSPHINXOPTS) $(BUILDDIR)/linkcheck
@echo
@echo "Link check complete; look for any errors in the above output " \
"or in $(BUILDDIR)/linkcheck/output.txt."
doctest:
$(SPHINXBUILD) -b doctest $(ALLSPHINXOPTS) $(BUILDDIR)/doctest
@echo "Testing of doctests in the sources finished, look at the " \
"results in $(BUILDDIR)/doctest/output.txt."
click-6.2/docs/options.rst 0000644 0000765 0000024 00000046020 12616630351 016767 0 ustar mitsuhiko staff 0000000 0000000 .. _options:
Options
=======
.. currentmodule:: click
Adding options to commands can be accomplished by the :func:`option`
decorator. Since options can come in various different versions, there
are a ton of parameters to configure their behavior. Options in click are
distinct from :ref:`positional arguments `.
Basic Value Options
-------------------
The most basic option is a value option. These options accept one
argument which is a value. If no type is provided, the type of the default
value is used. If no default value is provided, the type is assumed to be
:data:`STRING`. By default, the name of the parameter is the first long
option defined; otherwise the first short one is used.
.. click:example::
@click.command()
@click.option('--n', default=1)
def dots(n):
click.echo('.' * n)
And on the command line:
.. click:run::
invoke(dots, args=['--n=2'])
In this case the option is of type :data:`INT` because the default value
is an integer.
Multi Value Options
-------------------
Sometimes, you have options that take more than one argument. For options,
only a fixed number of arguments is supported. This can be configured by
the ``nargs`` parameter. The values are then stored as a tuple.
.. click:example::
@click.command()
@click.option('--pos', nargs=2, type=float)
def findme(pos):
click.echo('%s / %s' % pos)
And on the command line:
.. click:run::
invoke(findme, args=['--pos', '2.0', '3.0'])
.. _tuple-type:
Tuples as Multi Value Options
-----------------------------
.. versionadded:: 4.0
As you can see that by using `nargs` set to a specific number each item in
the resulting tuple is of the same type. This might not be what you want.
Commonly you might want to use different types for different indexes in
the tuple. For this you can directly specify a tuple as type:
.. click:example::
@click.command()
@click.option('--item', type=(unicode, int))
def putitem(item):
click.echo('name=%s id=%d' % item)
And on the command line:
.. click:run::
invoke(putitem, args=['--item', 'peter', '1338'])
By using a tuple literal as type, `nargs` gets automatically set to the
length of the tuple and the :class:`click.Tuple` type is automatically
used. The above example is thus equivalent to this:
.. click:example::
@click.command()
@click.option('--item', nargs=2, type=click.Tuple([unicode, int]))
def putitem(item):
click.echo('name=%s id=%d' % item)
Multiple Options
----------------
Similarly to ``nargs``, there is also the case of wanting to support a
parameter being provided multiple times to and have all values recorded --
not just the last one. For instance, ``git commit -m foo -m bar`` would
record two lines for the commit message: ``foo`` and ``bar``. This can be
accomplished with the ``multiple`` flag:
Example:
.. click:example::
@click.command()
@click.option('--message', '-m', multiple=True)
def commit(message):
click.echo('\n'.join(message))
And on the command line:
.. click:run::
invoke(commit, args=['-m', 'foo', '-m', 'bar'])
Counting
--------
In some very rare circumstances, it is interesting to use the repetition
of options to count an integer up. This can be used for verbosity flags,
for instance:
.. click:example::
@click.command()
@click.option('-v', '--verbose', count=True)
def log(verbose):
click.echo('Verbosity: %s' % verbose)
And on the command line:
.. click:run::
invoke(log, args=['-vvv'])
Boolean Flags
-------------
Boolean flags are options that can be enabled or disabled. This can be
accomplished by defining two flags in one go separated by a slash (``/``)
for enabling or disabling the option. (If a slash is in an option string,
Click automatically knows that it's a boolean flag and will pass
``is_flag=True`` implicitly.) Click always wants you to provide an enable
and disable flag so that you can change the default later.
Example:
.. click:example::
import sys
@click.command()
@click.option('--shout/--no-shout', default=False)
def info(shout):
rv = sys.platform
if shout:
rv = rv.upper() + '!!!!111'
click.echo(rv)
And on the command line:
.. click:run::
invoke(info, args=['--shout'])
invoke(info, args=['--no-shout'])
If you really don't want an off-switch, you can just define one and
manually inform Click that something is a flag:
.. click:example::
import sys
@click.command()
@click.option('--shout', is_flag=True)
def info(shout):
rv = sys.platform
if shout:
rv = rv.upper() + '!!!!111'
click.echo(rv)
And on the command line:
.. click:run::
invoke(info, args=['--shout'])
Note that if a slash is contained in your option already (for instance, if
you use Windows-style parameters where ``/`` is the prefix character), you
can alternatively split the parameters through ``;`` instead:
.. click:example::
@click.command()
@click.option('/debug;/no-debug')
def log(debug):
click.echo('debug=%s' % debug)
if __name__ == '__main__':
log()
.. versionchanged:: 6.0
If you want to define an alias for the second option only, then you will
need to use leading whitespace to disambiguate the format string:
Example:
.. click:example::
import sys
@click.command()
@click.option('--shout/--no-shout', ' /-S', default=False)
def info(shout):
rv = sys.platform
if shout:
rv = rv.upper() + '!!!!111'
click.echo(rv)
.. click:run::
invoke(info, args=['--help'])
Feature Switches
----------------
In addition to boolean flags, there are also feature switches. These are
implemented by setting multiple options to the same parameter name and
defining a flag value. Note that by providing the ``flag_value`` parameter,
Click will implicitly set ``is_flag=True``.
To set a default flag, assign a value of `True` to the flag that should be
the default.
.. click:example::
import sys
@click.command()
@click.option('--upper', 'transformation', flag_value='upper',
default=True)
@click.option('--lower', 'transformation', flag_value='lower')
def info(transformation):
click.echo(getattr(sys.platform, transformation)())
And on the command line:
.. click:run::
invoke(info, args=['--upper'])
invoke(info, args=['--lower'])
invoke(info)
.. _choice-opts:
Choice Options
--------------
Sometimes, you want to have a parameter be a choice of a list of values.
In that case you can use :class:`Choice` type. It can be instantiated
with a list of valid values.
Example:
.. click:example::
@click.command()
@click.option('--hash-type', type=click.Choice(['md5', 'sha1']))
def digest(hash_type):
click.echo(hash_type)
What it looks like:
.. click:run::
invoke(digest, args=['--hash-type=md5'])
println()
invoke(digest, args=['--hash-type=foo'])
println()
invoke(digest, args=['--help'])
.. _option-prompting:
Prompting
---------
In some cases, you want parameters that can be provided from the command line,
but if not provided, ask for user input instead. This can be implemented with
Click by defining a prompt string.
Example:
.. click:example::
@click.command()
@click.option('--name', prompt=True)
def hello(name):
click.echo('Hello %s!' % name)
And what it looks like:
.. click:run::
invoke(hello, args=['--name=John'])
invoke(hello, input=['John'])
If you are not happy with the default prompt string, you can ask for
a different one:
.. click:example::
@click.command()
@click.option('--name', prompt='Your name please')
def hello(name):
click.echo('Hello %s!' % name)
What it looks like:
.. click:run::
invoke(hello, input=['John'])
Password Prompts
----------------
Click also supports hidden prompts and asking for confirmation. This is
useful for password input:
.. click:example::
@click.command()
@click.option('--password', prompt=True, hide_input=True,
confirmation_prompt=True)
def encrypt(password):
click.echo('Encrypting password to %s' % password.encode('rot13'))
What it looks like:
.. click:run::
invoke(encrypt, input=['secret', 'secret'])
Because this combination of parameters is quite common, this can also be
replaced with the :func:`password_option` decorator:
.. click:example::
@click.command()
@click.password_option()
def encrypt(password):
click.echo('Encrypting password to %s' % password.encode('rot13'))
Dynamic Defaults for Prompts
----------------------------
The ``auto_envvar_prefix`` and ``default_map`` options for the context
allow the program to read option values from the environment or a
configuration file. However, this overrides the prompting mechanism, so
that the user does not get the option to change the value interactively.
If you want to let the user configure the default value, but still be
prompted if the option isn't specified on the command line, you can do so
by supplying a callable as the default value. For example, to get a default
from the environment:
.. click:example::
@click.command()
@click.option('--username', prompt=True,
default=lambda: os.environ.get('USER', ''))
def hello(username):
print("Hello,", username)
Callbacks and Eager Options
---------------------------
Sometimes, you want a parameter to completely change the execution flow.
For instance, this is the case when you want to have a ``--version``
parameter that prints out the version and then exits the application.
Note: an actual implementation of a ``--version`` parameter that is
reusable is available in Click as :func:`click.version_option`. The code
here is merely an example of how to implement such a flag.
In such cases, you need two concepts: eager parameters and a callback. An
eager parameter is a parameter that is handled before others, and a
callback is what executes after the parameter is handled. The eagerness
is necessary so that an earlier required parameter does not produce an
error message. For instance, if ``--version`` was not eager and a
parameter ``--foo`` was required and defined before, you would need to
specify it for ``--version`` to work. For more information, see
:ref:`callback-evaluation-order`.
A callback is a function that is invoked with two parameters: the current
:class:`Context` and the value. The context provides some useful features
such as quitting the application and gives access to other already
processed parameters.
Here an example for a ``--version`` flag:
.. click:example::
def print_version(ctx, param, value):
if not value or ctx.resilient_parsing:
return
click.echo('Version 1.0')
ctx.exit()
@click.command()
@click.option('--version', is_flag=True, callback=print_version,
expose_value=False, is_eager=True)
def hello():
click.echo('Hello World!')
The `expose_value` parameter prevents the pretty pointless ``version``
parameter from being passed to the callback. If that was not specified, a
boolean would be passed to the `hello` script. The `resilient_parsing`
flag is applied to the context if Click wants to parse the command line
without any destructive behavior that would change the execution flow. In
this case, because we would exit the program, we instead do nothing.
What it looks like:
.. click:run::
invoke(hello)
invoke(hello, args=['--version'])
.. admonition:: Callback Signature Changes
In Click 2.0 the signature for callbacks changed. For more
information about these changes see :ref:`upgrade-to-2.0`.
Yes Parameters
--------------
For dangerous operations, it's very useful to be able to ask a user for
confirmation. This can be done by adding a boolean ``--yes`` flag and
asking for confirmation if the user did not provide it and to fail in a
callback:
.. click:example::
def abort_if_false(ctx, param, value):
if not value:
ctx.abort()
@click.command()
@click.option('--yes', is_flag=True, callback=abort_if_false,
expose_value=False,
prompt='Are you sure you want to drop the db?')
def dropdb():
click.echo('Dropped all tables!')
And what it looks like on the command line:
.. click:run::
invoke(dropdb, input=['n'])
invoke(dropdb, args=['--yes'])
Because this combination of parameters is quite common, this can also be
replaced with the :func:`confirmation_option` decorator:
.. click:example::
@click.command()
@click.confirmation_option(prompt='Are you sure you want to drop the db?')
def dropdb():
click.echo('Dropped all tables!')
.. admonition:: Callback Signature Changes
In Click 2.0 the signature for callbacks changed. For more
information about these changes see :ref:`upgrade-to-2.0`.
Values from Environment Variables
---------------------------------
A very useful feature of Click is the ability to accept parameters from
environment variables in addition to regular parameters. This allows
tools to be automated much easier. For instance, you might want to pass
a configuration file with a ``--config`` parameter but also support exporting
a ``TOOL_CONFIG=hello.cfg`` key-value pair for a nicer development
experience.
This is supported by Click in two ways. One is to automatically build
environment variables which is supported for options only. To enable this
feature, the ``auto_envvar_prefix`` parameter needs to be passed to the
script that is invoked. Each command and parameter is then added as an
uppercase underscore-separated variable. If you have a subcommand
called ``foo`` taking an option called ``bar`` and the prefix is
``MY_TOOL``, then the variable is ``MY_TOOL_FOO_BAR``.
Example usage:
.. click:example::
@click.command()
@click.option('--username')
def greet(username):
click.echo('Hello %s!' % username)
if __name__ == '__main__':
greet(auto_envvar_prefix='GREETER')
And from the command line:
.. click:run::
invoke(greet, env={'GREETER_USERNAME': 'john'},
auto_envvar_prefix='GREETER')
The second option is to manually pull values in from specific environment
variables by defining the name of the environment variable on the option.
Example usage:
.. click:example::
@click.command()
@click.option('--username', envvar='USERNAME')
def greet(username):
click.echo('Hello %s!' % username)
if __name__ == '__main__':
greet()
And from the command line:
.. click:run::
invoke(greet, env={'USERNAME': 'john'})
In that case it can also be a list of different environment variables
where the first one is picked.
Multiple Values from Environment Values
---------------------------------------
As options can accept multiple values, pulling in such values from
environment variables (which are strings) is a bit more complex. The way
Click solves this is by leaving it up to the type to customize this
behavior. For both ``multiple`` and ``nargs`` with values other than
``1``, Click will invoke the :meth:`ParamType.split_envvar_value` method to
perform the splitting.
The default implementation for all types is to split on whitespace. The
exceptions to this rule are the :class:`File` and :class:`Path` types
which both split according to the operating system's path splitting rules.
On Unix systems like Linux and OS X, the splitting happens for those on
every colon (``:``), and for Windows, on every semicolon (``;``).
Example usage:
.. click:example::
@click.command()
@click.option('paths', '--path', envvar='PATHS', multiple=True,
type=click.Path())
def perform(paths):
for path in paths:
click.echo(path)
if __name__ == '__main__':
perform()
And from the command line:
.. click:run::
import os
invoke(perform, env={'PATHS': './foo/bar%s./test' % os.path.pathsep})
Other Prefix Characters
-----------------------
Click can deal with alternative prefix characters other than ``-`` for
options. This is for instance useful if you want to handle slashes as
parameters ``/`` or something similar. Note that this is strongly
discouraged in general because Click wants developers to stay close to
POSIX semantics. However in certain situations this can be useful:
.. click:example::
@click.command()
@click.option('+w/-w')
def chmod(w):
click.echo('writable=%s' % w)
if __name__ == '__main__':
chmod()
And from the command line:
.. click:run::
invoke(chmod, args=['+w'])
invoke(chmod, args=['-w'])
Note that if you are using ``/`` as prefix character and you want to use a
boolean flag you need to separate it with ``;`` instead of ``/``:
.. click:example::
@click.command()
@click.option('/debug;/no-debug')
def log(debug):
click.echo('debug=%s' % debug)
if __name__ == '__main__':
log()
.. _ranges:
Range Options
-------------
A special mention should go to the :class:`IntRange` type, which works very
similarly to the :data:`INT` type, but restricts the value to fall into a
specific range (inclusive on both edges). It has two modes:
- the default mode (non-clamping mode) where a value that falls outside
of the range will cause an error.
- an optional clamping mode where a value that falls outside of the
range will be clamped. This means that a range of ``0-5`` would
return ``5`` for the value ``10`` or ``0`` for the value ``-1`` (for
example).
Example:
.. click:example::
@click.command()
@click.option('--count', type=click.IntRange(0, 20, clamp=True))
@click.option('--digit', type=click.IntRange(0, 10))
def repeat(count, digit):
click.echo(str(digit) * count)
if __name__ == '__main__':
repeat()
And from the command line:
.. click:run::
invoke(repeat, args=['--count=1000', '--digit=5'])
invoke(repeat, args=['--count=1000', '--digit=12'])
If you pass ``None`` for any of the edges, it means that the range is open
at that side.
Callbacks for Validation
------------------------
.. versionchanged:: 2.0
If you want to apply custom validation logic, you can do this in the
parameter callbacks. These callbacks can both modify values as well as
raise errors if the validation does not work.
In Click 1.0, you can only raise the :exc:`UsageError` but starting with
Click 2.0, you can also raise the :exc:`BadParameter` error, which has the
added advantage that it will automatically format the error message to
also contain the parameter name.
Example:
.. click:example::
def validate_rolls(ctx, param, value):
try:
rolls, dice = map(int, value.split('d', 2))
return (dice, rolls)
except ValueError:
raise click.BadParameter('rolls need to be in format NdM')
@click.command()
@click.option('--rolls', callback=validate_rolls, default='1d6')
def roll(rolls):
click.echo('Rolling a %d-sided dice %d time(s)' % rolls)
if __name__ == '__main__':
roll()
And what it looks like:
.. click:run::
invoke(roll, args=['--rolls=42'])
println()
invoke(roll, args=['--rolls=2d12'])
click-6.2/docs/parameters.rst 0000644 0000765 0000024 00000010323 12506476043 017440 0 ustar mitsuhiko staff 0000000 0000000 Parameters
==========
.. currentmodule:: click
Click supports two types of parameters for scripts: options and arguments.
There is generally some confusion among authors of command line scripts of
when to use which, so here is a quick overview of the differences. As its
name indicates, an option is optional. While arguments can be optional
within reason, they are much more restricted in how optional they can be.
To help you decide between options and arguments, the recommendation is
to use arguments exclusively for things like going to subcommands or input
filenames / URLs, and have everything else be an option instead.
Differences
-----------
Arguments can do less than options. The following features are only
available for options:
* automatic prompting for missing input
* act as flags (boolean or otherwise)
* option values can be pulled from environment variables, arguments can not
* options are fully documented in the help page, arguments are not
(this is intentional as arguments might be too specific to be
automatically documented)
On the other hand arguments, unlike options, can accept an arbitrary number
of arguments. Options can strictly ever only accept a fixed number of
arguments (defaults to 1).
Parameter Types
---------------
Parameters can be of different types. Types can be implemented with
different behavior and some are supported out of the box:
``str`` / :data:`click.STRING`:
The default parameter type which indicates unicode strings.
``int`` / :data:`click.INT`:
A parameter that only accepts integers.
``float`` / :data:`click.FLOAT`:
A parameter that only accepts floating point values.
``bool`` / :data:`click.BOOL`:
A parameter that accepts boolean values. This is automatically used
for boolean flags. If used with string values ``1``, ``yes``, ``y``
and ``true`` convert to `True` and ``0``, ``no``, ``n`` and ``false``
convert to `False`.
:data:`click.UUID`:
A parameter that accepts UUID values. This is not automatically
guessed but represented as :class:`uuid.UUID`.
.. autoclass:: File
:noindex:
.. autoclass:: Path
:noindex:
.. autoclass:: Choice
:noindex:
.. autoclass:: IntRange
:noindex:
Custom parameter types can be implemented by subclassing
:class:`click.ParamType`. For simple cases, passing a Python function that
fails with a `ValueError` is also supported, though discouraged.
Parameter Names
---------------
Parameters (both options and arguments) accept a number of positional
arguments which are the parameter declarations. Each string with a
single dash is added as short argument; each string starting with a double
dash as long one. If a string is added without any dashes, it becomes the
internal parameter name which is also used as variable name.
If a parameter is not given a name without dashes, a name is generated
automatically by taking the longest argument and converting all dashes to
underscores. For an option with ``('-f', '--foo-bar')``, the parameter
name is `foo_bar`. For an option with ``('-x',)``, the parameter is `x`.
For an option with ``('-f', '--filename', 'dest')``, the parameter is
called `dest`.
Implementing Custom Types
-------------------------
To implement a custom type, you need to subclass the :class:`ParamType`
class. Types can be invoked with or without context and parameter object,
which is why they need to be able to deal with this.
The following code implements an integer type that accepts hex and octal
numbers in addition to normal integers, and converts them into regular
integers::
import click
class BasedIntParamType(click.ParamType):
name = 'integer'
def convert(self, value, param, ctx):
try:
if value[:2].lower() == '0x':
return int(value[2:], 16)
elif value[:1] == '0':
return int(value, 8)
return int(value, 10)
except ValueError:
self.fail('%s is not a valid integer' % value, param, ctx)
BASED_INT = BasedIntParamType()
As you can see, a subclass needs to implement the :meth:`ParamType.convert`
method and optionally provide the :attr:`ParamType.name` attribute. The
latter can be used for documentation purposes.
click-6.2/docs/prompts.rst 0000644 0000765 0000024 00000003163 12370501774 017004 0 ustar mitsuhiko staff 0000000 0000000 User Input Prompts
==================
.. currentmodule:: click
Click supports prompts in two different places. The first is automated
prompts when the parameter handling happens, and the second is to ask for
prompts at a later point independently.
This can be accomplished with the :func:`prompt` function, which asks for
valid input according to a type, or the :func:`confirm` function, which asks
for confirmation (yes/no).
Option Prompts
--------------
Option prompts are integrated into the option interface. See
:ref:`option-prompting` for more information. Internally, it
automatically calls either :func:`prompt` or :func:`confirm` as necessary.
Input Prompts
-------------
To manually ask for user input, you can use the :func:`prompt` function.
By default, it accepts any Unicode string, but you can ask for any other
type. For instance, you can ask for a valid integer::
value = click.prompt('Please enter a valid integer', type=int)
Additionally, the type will be determined automatically if a default value is
provided. For instance, the following will only accept floats::
value = click.prompt('Please enter a number', default=42.0)
Confirmation Prompts
--------------------
To ask if a user wants to continue with an action, the :func:`confirm`
function comes in handy. By default, it returns the result of the prompt
as a boolean value::
if click.confirm('Do you want to continue?'):
click.echo('Well done!')
There is also the option to make the function automatically abort the
execution of the program if it does not return ``True``::
click.confirm('Do you want to continue?', abort=True)
click-6.2/docs/python3.rst 0000644 0000765 0000024 00000016712 12617102654 016706 0 ustar mitsuhiko staff 0000000 0000000 Python 3 Support
================
.. currentmodule:: click
Click supports Python 3, but like all other command line utility libraries,
it suffers from the Unicode text model in Python 3. All examples in the
documentation were written so that they could run on both Python 2.x and
Python 3.3 or higher.
At the moment, it is strongly recommended is to use Python 2 for Click
utilities unless Python 3 is a hard requirement.
.. _python3-limitations:
Python 3 Limitations
--------------------
At the moment, Click suffers from a few problems with Python 3:
* The command line in Unix traditionally is in bytes, not Unicode. While
there are encoding hints for all of this, there are generally some
situations where this can break. The most common one is SSH
connections to machines with different locales.
Misconfigured environments can currently cause a wide range of Unicode
problems in Python 3 due to the lack of support for roundtripping
surrogate escapes. This will not be fixed in Click itself!
For more information see :ref:`python3-surrogates`.
* Standard input and output in Python 3 is opened in Unicode mode by
default. Click has to reopen the stream in binary mode in certain
situations. Because there is no standardized way to do this, this
might not always work. Primarily this can become a problem when
testing command-line applications.
This is not supported::
sys.stdin = io.StringIO('Input here')
sys.stdout = io.StringIO()
Instead you need to do this::
input = 'Input here'
in_stream = io.BytesIO(input.encode('utf-8'))
sys.stdin = io.TextIOWrapper(in_stream, encoding='utf-8')
out_stream = io.BytesIO()
sys.stdout = io.TextIOWrapper(out_stream, encoding='utf-8')
Remember that in that case, you need to use ``out_stream.getvalue()``
and not ``sys.stdout.getvalue()`` if you want to access the buffer
contents as the wrapper will not forward that method.
Python 2 and 3 Differences
--------------------------
Click attempts to minimize the differences between Python 2 and Python 3
by following best practices for both languages.
In Python 2, the following is true:
* ``sys.stdin``, ``sys.stdout``, and ``sys.stderr`` are opened in binary
mode, but under some circumstances they support Unicode output. Click
attempts to not subvert this but provides support for forcing streams
to be Unicode-based.
* ``sys.argv`` is always byte-based. Click will pass bytes to all
input types and convert as necessary. The :class:`STRING` type
automatically will decode properly the input value into a string by
trying the most appropriate encodings.
* When dealing with files, Click will never go through the Unicode APIs
and will instead use the operating system's byte APIs to open the
files.
In Python 3, the following is true:
* ``sys.stdin``, ``sys.stdout`` and ``sys.stderr`` are by default
text-based. When Click needs a binary stream, it attempts to discover
the underlying binary stream. See :ref:`python3-limitations` for how
this works.
* ``sys.argv`` is always Unicode-based. This also means that the native
type for input values to the types in Click is Unicode, and not bytes.
This causes problems if the terminal is incorrectly set and Python
does not figure out the encoding. In that case, the Unicode string
will contain error bytes encoded as surrogate escapes.
* When dealing with files, Click will always use the Unicode file system
API calls by using the operating system's reported or guessed
filesystem encoding. Surrogates are supported for filenames, so it
should be possible to open files through the :class:`File` type even
if the environment is misconfigured.
.. _python3-surrogates:
Python 3 Surrogate Handling
---------------------------
Click in Python 3 does all the Unicode handling in the standard library
and is subject to its behavior. In Python 2, Click does all the Unicode
handling itself, which means there are differences in error behavior.
The most glaring difference is that in Python 2, Unicode will "just work",
while in Python 3, it requires extra care. The reason for this is that in
Python 3, the encoding detection is done in the interpreter, and on Linux
and certain other operating systems, its encoding handling is problematic.
The biggest source of frustration is that Click scripts invoked by
init systems (sysvinit, upstart, systemd, etc.), deployment tools (salt,
puppet), or cron jobs (cron) will refuse to work unless a Unicode locale is
exported.
If Click encounters such an environment it will prevent further execution
to force you to set a locale. This is done because Click cannot know
about the state of the system once it's invoked and restore the values
before Python's Unicode handling kicked in.
If you see something like this error in Python 3::
Traceback (most recent call last):
...
RuntimeError: Click will abort further execution because Python 3 was
configured to use ASCII as encoding for the environment. Either switch
to Python 2 or consult http://click.pocoo.org/python3/ for
mitigation steps.
You are dealing with an environment where Python 3 thinks you are
restricted to ASCII data. The solution to these problems is different
depending on which locale your computer is running in.
For instance, if you have a German Linux machine, you can fix the problem
by exporting the locale to ``de_DE.utf-8``::
export LC_ALL=de_DE.utf-8
export LANG=de_DE.utf-8
If you are on a US machine, ``en_US.utf-8`` is the encoding of choice. On
some newer Linux systems, you could also try ``C.UTF-8`` as the locale::
export LC_ALL=C.UTF-8
export LANG=C.UTF-8
On some systems it was reported that `UTF-8` has to be written as `UTF8`
and vice versa. To see which locales are supported you can invoke
``locale -a``::
locale -a
You need to do this before you invoke your Python script. If you are
curious about the reasons for this, you can join the discussions in the
Python 3 bug tracker:
* `ASCII is a bad filesystem default encoding
`_
* `Use surrogateescape as default error handler
`_
* `Python 3 raises Unicode errors in the C locale
`_
* `LC_CTYPE=C: pydoc leaves terminal in an unusable state
`_ (this is relevant to Click
because the pager support is provided by the stdlib pydoc module)
Unicode Literals
----------------
Starting with Click 5.0 there will be a warning for the use of the
``unicode_literals`` future import in Python 2. This has been done due to
the negative consequences of this import with regards to unintentionally
causing bugs due to introducing Unicode data to APIs that are incapable of
handling them. For some examples of this issue, see the discussion on
this github issue: `python-future#22
`_.
If you use ``unicode_literals`` in any file that defines a Click command
or that invokes a click command you will be given a warning. You are
strongly encouraged to not use ``unicode_literals`` and instead use
explicit ``u`` prefixes for your Unicode strings.
If you do want to ignore the warning and continue using
``unicode_literals`` on your own peril, you can disable the warning as
follows::
import click
click.disable_unicode_literals_warning = True
click-6.2/docs/quickstart.rst 0000644 0000765 0000024 00000021277 12466134274 017503 0 ustar mitsuhiko staff 0000000 0000000 Quickstart
==========
.. currentmodule:: click
You can get the library directly from PyPI::
pip install click
The installation into a :ref:`virtualenv` is heavily recommended.
.. _virtualenv:
virtualenv
----------
Virtualenv is probably what you want to use for developing Click
applications.
What problem does virtualenv solve? Chances are that you want to use it
for other projects besides your Click script. But the more projects you
have, the more likely it is that you will be working with different
versions of Python itself, or at least different versions of Python
libraries. Let's face it: quite often libraries break backwards
compatibility, and it's unlikely that any serious application will have
zero dependencies. So what do you do if two or more of your projects have
conflicting dependencies?
Virtualenv to the rescue! Virtualenv enables multiple side-by-side
installations of Python, one for each project. It doesn't actually
install separate copies of Python, but it does provide a clever way to
keep different project environments isolated. Let's see how virtualenv
works.
If you are on Mac OS X or Linux, chances are that one of the following two
commands will work for you::
$ sudo easy_install virtualenv
or even better::
$ sudo pip install virtualenv
One of these will probably install virtualenv on your system. Maybe it's even
in your package manager. If you use Ubuntu, try::
$ sudo apt-get install python-virtualenv
If you are on Windows (or none of the above methods worked) you must install
``pip`` first. For more information about this, see `installing pip`_.
Once you have it installed, run the ``pip`` command from above, but without
the `sudo` prefix.
.. _installing pip: http://pip.readthedocs.org/en/latest/installing.html
Once you have virtualenv installed, just fire up a shell and create
your own environment. I usually create a project folder and a `venv`
folder within::
$ mkdir myproject
$ cd myproject
$ virtualenv venv
New python executable in venv/bin/python
Installing setuptools, pip............done.
Now, whenever you want to work on a project, you only have to activate the
corresponding environment. On OS X and Linux, do the following::
$ . venv/bin/activate
If you are a Windows user, the following command is for you::
$ venv\scripts\activate
Either way, you should now be using your virtualenv (notice how the prompt of
your shell has changed to show the active environment).
And if you want to go back to the real world, use the following command::
$ deactivate
After doing this, the prompt of your shell should be as familar as before.
Now, let's move on. Enter the following command to get Click activated in your
virtualenv::
$ pip install Click
A few seconds later and you are good to go.
Screencast and Examples
-----------------------
There is a screencast available which shows the basic API of Click and
how to build simple applications with it. It also explores how to build
commands with subcommands.
* `Building Command Line Applications with Click
`_
Examples of Click applications can be found in the documentation as well
as in the GitHub repository together with readme files:
* ``inout``: `File input and output
`_
* ``naval``: `Port of docopt naval example
`_
* ``aliases``: `Command alias example
`_
* ``repo``: `Git-/Mercurial-like command line interface
`_
* ``complex``: `Complex example with plugin loading
`_
* ``validation``: `Custom parameter validation example
`_
* ``colors``: `Colorama ANSI color support
`_
* ``termui``: `Terminal UI functions demo
`_
* ``imagepipe``: `Multi command chaining demo
`_
Basic Concepts
--------------
Click is based on declaring commands through decorators. Internally, there
is a non-decorator interface for advanced use cases, but it's discouraged
for high-level usage.
A function becomes a Click command line tool by decorating it through
:func:`click.command`. At its simplest, just decorating a function
with this decorator will make it into a callable script:
.. click:example::
import click
@click.command()
def hello():
click.echo('Hello World!')
What's happening is that the decorator converts the function into a
:class:`Command` which then can be invoked::
if __name__ == '__main__':
hello()
And what it looks like:
.. click:run::
invoke(hello, args=[], prog_name='python hello.py')
And the corresponding help page:
.. click:run::
invoke(hello, args=['--help'], prog_name='python hello.py')
Echoing
-------
Why does this example use :func:`echo` instead of the regular
:func:`print` function? The answer to this question is that Click
attempts to support both Python 2 and Python 3 the same way and to be very
robust even when the environment is misconfigured. Click wants to be
functional at least on a basic level even if everything is completely
broken.
What this means is that the :func:`echo` function applies some error
correction in case the terminal is misconfigured instead of dying with an
:exc:`UnicodeError`.
As an added benefit, starting with Click 2.0, the echo function also
has good support for ANSI colors. It will automatically strip ANSI codes
if the output stream is a file and if colorama is supported, ANSI colors
will also work on Windows. See :ref:`ansi-colors` for more information.
If you don't need this, you can also use the `print()` construct /
function.
Nesting Commands
----------------
Commands can be attached to other commands of type :class:`Group`. This
allows arbitrary nesting of scripts. As an example here is a script that
implements two commands for managing databases:
.. click:example::
@click.group()
def cli():
pass
@click.command()
def initdb():
click.echo('Initialized the database')
@click.command()
def dropdb():
click.echo('Dropped the database')
cli.add_command(initdb)
cli.add_command(dropdb)
As you can see, the :func:`group` decorator works like the :func:`command`
decorator, but creates a :class:`Group` object instead which can be given
multiple subcommands that can be attached with :meth:`Group.add_command`.
For simple scripts, it's also possible to automatically attach and create a
command by using the :meth:`Group.command` decorator instead. The above
script can instead be written like this:
.. click:example::
@click.group()
def cli():
pass
@cli.command()
def initdb():
click.echo('Initialized the database')
@cli.command()
def dropdb():
click.echo('Dropped the database')
Adding Parameters
-----------------
To add parameters, use the :func:`option` and :func:`argument` decorators:
.. click:example::
@click.command()
@click.option('--count', default=1, help='number of greetings')
@click.argument('name')
def hello(count, name):
for x in range(count):
click.echo('Hello %s!' % name)
What it looks like:
.. click:run::
invoke(hello, args=['--help'], prog_name='python hello.py')
.. _switching-to-setuptools:
Switching to Setuptools
-----------------------
In the code you wrote so far there is a block at the end of the file which
looks like this: ``if __name__ == '__main__':``. This is traditionally
how a standalone Python file looks like. With Click you can continue
doing that, but there are better ways through setuptools.
There are two main (and many more) reasons for this:
The first one is that setuptools automatically generates executable
wrappers for Windows so your command line utilities work on Windows too.
The second reason is that setuptools scripts work with virtualenv on Unix
without the virtualenv having to be activated. This is a very useful
concept which allows you to bundle your scripts with all requirements into
a virtualenv.
Click is perfectly equipped to work with that and in fact the rest of the
documentation will assume that you are writing applications through
setuptools.
I strongly recommend to have a look at the :ref:`setuptools-integration`
chapter before reading the rest as the examples assume that you will
be using setuptools.
click-6.2/docs/setuptools.rst 0000644 0000765 0000024 00000010114 12560614033 017505 0 ustar mitsuhiko staff 0000000 0000000 .. _setuptools-integration:
Setuptools Integration
======================
When writing command line utilities, it's recommended to write them as
modules that are distributed with setuptools instead of using Unix
shebangs.
Why would you want to do that? There are a bunch of reasons:
1. One of the problems with the traditional approach is that the first
module the Python interpreter loads has an incorrect name. This might
sound like a small issue but it has quite significant implications.
The first module is not called by its actual name, but the
interpreter renames it to ``__main__``. While that is a perfectly
valid name it means that if another piece of code wants to import from
that module it will trigger the import a second time under its real
name and all of a sudden your code is imported twice.
2. Not on all platforms are things that easy to execute. On Linux and OS
X you can add a comment to the beginning of the file (``#!/usr/bin/env
python``) and your script works like an executable (assuming it has
the executable bit set). This however does not work on Windows.
While on Windows you can associate interpreters with file extensions
(like having everything ending in ``.py`` execute through the Python
interpreter) you will then run into issues if you want to use the
script in a virtualenv.
In fact running a script in a virtualenv is an issue with OS X and
Linux as well. With the traditional approach you need to have the
whole virtualenv activated so that the correct Python interpreter is
used. Not very user friendly.
3. The main trick only works if the script is a Python module. If your
application grows too large and you want to start using a package you
will run into issues.
Introduction
------------
To bundle your script with setuptools, all you need is the script in a
Python package and a ``setup.py`` file.
Imagine this directory structure::
yourscript.py
setup.py
Contents of ``yourscript.py``:
.. click:example::
import click
@click.command()
def cli():
"""Example script."""
click.echo('Hello World!')
Contents of ``setup.py``::
from setuptools import setup
setup(
name='yourscript',
version='0.1',
py_modules=['yourscript'],
install_requires=[
'Click',
],
entry_points='''
[console_scripts]
yourscript=yourscript:cli
''',
)
The magic is in the ``entry_points`` parameter. Below
``console_scripts``, each line identifies one console script. The first
part before the equals sign (``=``) is the name of the script that should
be generated, the second part is the import path followed by a colon
(``:``) with the Click command.
That's it.
Testing The Script
------------------
To test the script, you can make a new virtualenv and then install your
package::
$ virtualenv venv
$ . venv/bin/activate
$ pip install --editable .
Afterwards, your command should be available:
.. click:run::
invoke(cli, prog_name='yourscript')
Scripts in Packages
-------------------
If your script is growing and you want to switch over to your script being
contained in a Python package the changes necessary are minimal. Let's
assume your directory structure changed to this::
yourpackage/
__init__.py
main.py
utils.py
scripts/
__init__.py
yourscript.py
In this case instead of using ``py_modules`` in your ``setup.py`` file you
can use ``packages`` and the automatic package finding support of
setuptools. In addition to that it's also recommended to include other
package data.
These would be the modified contents of ``setup.py``::
from setuptools import setup, find_packages
setup(
name='yourpackage',
version='0.1',
packages=find_packages(),
include_package_data=True,
install_requires=[
'Click',
],
entry_points='''
[console_scripts]
yourscript=yourpackage.scripts.yourscript:cli
''',
)
click-6.2/docs/testing.rst 0000644 0000765 0000024 00000006560 12551270727 016763 0 ustar mitsuhiko staff 0000000 0000000 Testing Click Applications
==========================
.. currentmodule:: click.testing
For basic testing, Click provides the :mod:`click.testing` module which
provides test functionality that helps you invoke command line
applications and check their behavior.
These tools should really only be used for testing as they change
the entire interpreter state for simplicity and are not in any way
thread-safe!
Basic Testing
-------------
The basic functionality for testing Click applications is the
:class:`CliRunner` which can invoke commands as command line scripts. The
:meth:`CliRunner.invoke` method runs the command line script in isolation
and captures the output as both bytes and binary data.
The return value is a :class:`Result` object, which has the captured output
data, exit code, and optional exception attached.
Example::
import click
from click.testing import CliRunner
def test_hello_world():
@click.command()
@click.argument('name')
def hello(name):
click.echo('Hello %s!' % name)
runner = CliRunner()
result = runner.invoke(hello, ['Peter'])
assert result.exit_code == 0
assert result.output == 'Hello Peter!\n'
For subcommand testing, a subcommand name must be specified in the `args` parameter of :meth:`CliRunner.invoke` method.
Example::
import click
from click.testing import CliRunner
def test_sync():
@click.group()
@click.option('--debug/--no-debug', default=False)
def cli(debug):
click.echo('Debug mode is %s' % ('on' if debug else 'off'))
@cli.command()
def sync():
click.echo('Syncing')
runner = CliRunner()
result = runner.invoke(cli, ['--debug', 'sync'])
assert result.exit_code == 0
assert 'Debug mode is on' in result.output
assert 'Syncing' in result.output
File System Isolation
---------------------
For basic command line tools that want to operate with the file system, the
:meth:`CliRunner.isolated_filesystem` method comes in useful which sets up
an empty folder and changes the current working directory to.
Example::
import click
from click.testing import CliRunner
def test_cat():
@click.command()
@click.argument('f', type=click.File())
def cat(f):
click.echo(f.read())
runner = CliRunner()
with runner.isolated_filesystem():
with open('hello.txt', 'w') as f:
f.write('Hello World!')
result = runner.invoke(cat, ['hello.txt'])
assert result.exit_code == 0
assert result.output == 'Hello World!\n'
Input Streams
-------------
The test wrapper can also be used to provide input data for the input
stream (stdin). This is very useful for testing prompts, for instance::
import click
from click.testing import CliRunner
def test_prompts():
@click.command()
@click.option('--foo', prompt=True)
def test(foo):
click.echo('foo=%s' % foo)
runner = CliRunner()
result = runner.invoke(test, input='wau wau\n')
assert not result.exception
assert result.output == 'Foo: wau wau\nfoo=wau wau\n'
Note that prompts will be emulated so that they write the input data to
the output stream as well. If hidden input is expected then this
obviously does not happen.
click-6.2/docs/upgrading.rst 0000644 0000765 0000024 00000007263 12375566570 017277 0 ustar mitsuhiko staff 0000000 0000000 Upgrading To Newer Releases
===========================
Click attempts the highest level of backwards compatibility but sometimes
this is not entirely possible. In case we need to break backwards
compatibility this document gives you information about how to upgrade or
handle backwards compatibility properly.
.. _upgrade-to-3.2:
Upgrading to 3.2
----------------
Click 3.2 had to perform two changes to multi commands which were
triggered by a change between Click 2 and Click 3 that had bigger
consequences than anticipated.
Context Invokes
```````````````
Click 3.2 contains a fix for the :meth:`Context.invoke` function when used
with other commands. The original intention of this function was to
invoke the other command as as if it came from the command line when it
was passed a context object instead of a function. This use was only
documented in a single place in the documentation before and there was no
proper explanation for the method in the API documentation.
The core issue is that before 3.2 this call worked against intentions::
ctx.invoke(other_command, 'arg1', 'arg2')
This was never intended to work as it does not allow Click to operate on
the parameters. Given that this pattern was never documented and ill
intended the decision was made to change this behavior in a bugfix release
before it spreads by accident and developers depend on it.
The correct invocation for the above command is the following::
ctx.invoke(other_command, name_of_arg1='arg1', name_of_arg2='arg2')
This also allowed us to fix the issue that defaults were not handled
properly by this function.
Multicommand Chaining API
`````````````````````````
Click 3 introduced multicommand chaning. This required a change in how
Click internally dispatches. Unfortunately this change was not correctly
implemented and it appeared that it was possible to provide an API that
can inform the super command about all the subcommands that will be
invoked.
This assumption however does not work with one of the API guarantees that
have been given in the past. As such this functionality has been removed
in 3.2 as it was already broken. Instead the accidentally broken
functionality of the :attr:`Context.invoked_subcommand` attribute was
restored.
If you do require the know which exact commands will be invoked there are
different ways to cope with this. The first one is to let the subcommands
all return functions and then to invoke the functions in a
:meth:`Context.resultcallback`.
.. _upgrade-to-2.0:
Upgrading to 2.0
----------------
Click 2.0 has one breaking change which is the signature for parameter
callbacks. Before 2.0, the callback was invoked with ``(ctx, value)``
whereas now it's ``(ctx, param, value)``. This change was necessary as it
otherwise made reusing callbacks too complicated.
To ease the transition Click will still accept old callbacks. Starting
with Click 3.0 it will start to issue a warning to stderr to encourage you
to upgrade.
In case you want to support both Click 1.0 and Click 2.0, you can make a
simple decorator that adjusts the signatures::
import click
from functools import update_wrapper
def compatcallback(f):
# Click 1.0 does not have a version string stored, so we need to
# use getattr here to be safe.
if getattr(click, '__version__', '0.0') >= '2.0':
return f
return update_wrapper(lambda ctx, value: f(ctx, None, value), f)
With that helper you can then write something like this::
@compatcallback
def callback(ctx, param, value):
return value.upper()
Note that because Click 1.0 did not pass a parameter, the `param` argument
here would be `None`, so a compatibility callback could not use that
argument.
click-6.2/docs/utils.rst 0000644 0000765 0000024 00000030743 12617103130 016430 0 ustar mitsuhiko staff 0000000 0000000 Utilities
=========
.. currentmodule:: click
Besides the functionality that Click provides to interface with argument
parsing and handling, it also provides a bunch of addon functionality that
is useful for writing command line utilities.
Printing to Stdout
------------------
The most obvious helper is the :func:`echo` function, which in many ways
works like the Python ``print`` statement or function. The main difference is
that it works the same in Python 2 and 3, it intelligently detects
misconfigured output streams, and it will never fail (except in Python 3; for
more information see :ref:`python3-limitations`).
Example::
import click
click.echo('Hello World!')
Most importantly, it can print both Unicode and binary data, unlike the
built-in ``print`` function in Python 3, which cannot output any bytes. It
will, however, emit a trailing newline by default, which needs to be
suppressed by passing ``nl=False``::
click.echo(b'\xe2\x98\x83', nl=False)
Last but not least :func:`echo` uses click's intelligent internal output
streams to stdout and stderr which support unicode output on the Windows
console. This means for as long as you are using `click.echo` you can
output unicode character (there are some limitations on the default font
with regards to which characters can be displayed). This functionality is
new in Click 6.0.
.. versionadded:: 6.0
Click now emulates output streams on Windows to support unicode to the
Windows console through separate APIs. For more information see
`wincmd`_.
.. versionadded:: 3.0
Starting with Click 3.0 you can also easily print to standard error by
passing ``err=True``::
click.echo('Hello World!', err=True)
.. _ansi-colors:
ANSI Colors
-----------
.. versionadded:: 2.0
Starting with Click 2.0, the :func:`echo` function gained extra
functionality to deal with ANSI colors and styles. Note that on Windows,
this functionality is only available if `colorama`_ is installed. If it
is installed, then ANSI codes are intelligently handled.
Primarily this means that:
- Click's :func:`echo` function will automatically strip ANSI color codes
if the stream is not connected to a terminal.
- the :func:`echo` function will transparently connect to the terminal on
Windows and translate ANSI codes to terminal API calls. This means
that colors will work on Windows the same way they do on other
operating systems.
Note for `colorama` support: Click will automatically detect when `colorama`
is available and use it. Do *not* call ``colorama.init()``!
To install `colorama`, run this command::
$ pip install colorama
For styling a string, the :func:`style` function can be used::
import click
click.echo(click.style('Hello World!', fg='green'))
click.echo(click.style('Some more text', bg='blue', fg='white'))
click.echo(click.style('ATTENTION', blink=True, bold=True))
The combination of :func:`echo` and :func:`style` is also available in
a single function called :func:`secho`::
click.secho('Hello World!', fg='green')
click.secho('Some more text', bg='blue', fg='white')
click.secho('ATTENTION', blink=True, bold=True)
.. _colorama: https://pypi.python.org/pypi/colorama
Pager Support
-------------
In some situations, you might want to show long texts on the terminal and
let a user scroll through it. This can be achieved by using the
:func:`echo_via_pager` function which works similarly to the :func:`echo`
function, but always writes to stdout and, if possible, through a pager.
Example:
.. click:example::
@click.command()
def less():
click.echo_via_pager('\n'.join('Line %d' % idx
for idx in range(200)))
Screen Clearing
---------------
.. versionadded:: 2.0
To clear the terminal screen, you can use the :func:`clear` function that
is provided starting with Click 2.0. It does what the name suggests: it
clears the entire visible screen in a platform-agnostic way:
::
import click
click.clear()
Getting Characters from Terminal
--------------------------------
.. versionadded:: 2.0
Normally, when reading input from the terminal, you would read from
standard input. However, this is buffered input and will not show up until
the line has been terminated. In certain circumstances, you might not want
to do that and instead read individual characters as they are being written.
For this, Click provides the :func:`getchar` function which reads a single
character from the terminal buffer and returns it as a Unicode character.
Note that this function will always read from the terminal, even if stdin
is instead a pipe.
Example::
import click
click.echo('Continue? [yn] ', nl=False)
c = click.getchar()
click.echo()
if c == 'y':
click.echo('We will go on')
elif c == 'n':
click.echo('Abort!')
else:
click.echo('Invalid input :(')
Note that this reads raw input, which means that things like arrow keys
will show up in the platform's native escape format. The only characters
translated are ``^C`` and ``^D`` which are converted into keyboard
interrupts and end of file exceptions respectively. This is done because
otherwise, it's too easy to forget about that and to create scripts that
cannot be properly exited.
Waiting for Key Press
---------------------
.. versionadded:: 2.0
Sometimes, it's useful to pause until the user presses any key on the
keyboard. This is especially useful on Windows where ``cmd.exe`` will
close the window at the end of the command execution by default, instead
of waiting.
In click, this can be accomplished with the :func:`pause` function. This
function will print a quick message to the terminal (which can be
customized) and wait for the user to press a key. In addition to that,
it will also become a NOP (no operation instruction) if the script is not
run interactively.
Example::
import click
click.pause()
Launching Editors
-----------------
.. versionadded:: 2.0
Click supports launching editors automatically through :func:`edit`. This
is very useful for asking users for multi-line input. It will
automatically open the user's defined editor or fall back to a sensible
default. If the user closes the editor without saving, the return value
will be `None` otherwise the entered text.
Example usage::
import click
def get_commit_message():
MARKER = '# Everything below is ignored\n'
message = click.edit('\n\n' + MARKER)
if message is not None:
return message.split(MARKER, 1)[0].rstrip('\n')
Alternatively, the function can also be used to launch editors for files by
a specific filename. In this case, the return value is always `None`.
Example usage::
import click
click.edit(filename='/etc/passwd')
Launching Applications
----------------------
.. versionadded:: 2.0
Click supports launching applications through :func:`launch`. This can be
used to open the default application assocated with a URL or filetype.
This can be used to launch web browsers or picture viewers, for instance.
In addition to this, it can also launch the file manager and automatically
select the provided file.
Example usage::
click.launch('http://click.pocoo.org/')
click.launch('/my/downloaded/file.txt', locate=True)
Printing Filenames
------------------
Because filenames might not be Unicode, formatting them can be a bit
tricky. Generally, this is easier in Python 2 than on 3, as you can just
write the bytes to stdout with the ``print`` function, but in Python 3, you
will always need to operate in Unicode.
The way this works with click is through the :func:`format_filename`
function. It does a best-effort conversion of the filename to Unicode and
will never fail. This makes it possible to use these filenames in the
context of a full Unicode string.
Example::
click.echo('Path: %s' % click.format_filename(b'foo.txt'))
Standard Streams
----------------
For command line utilities, it's very important to get access to input and
output streams reliably. Python generally provides access to these
streams through ``sys.stdout`` and friends, but unfortunately, there are
API differences between 2.x and 3.x, especially with regards to how these
streams respond to Unicode and binary data.
Because of this, click provides the :func:`get_binary_stream` and
:func:`get_text_stream` functions, which produce consistent results with
different Python versions and for a wide variety pf terminal configurations.
The end result is that these functions will always return a functional
stream object (except in very odd cases in Python 3; see
:ref:`python3-limitations`).
Example::
import click
stdin_text = click.get_text_stream('stdin')
stdout_binary = click.get_binary_stream('stdout')
.. versionadded:: 6.0
Click now emulates output streams on Windows to support unicode to the
Windows console through separate APIs. For more information see
`wincmd`_.
Intelligent File Opening
------------------------
.. versionadded:: 3.0
Starting with Click 3.0 the logic for opening files from the :class:`File`
type is exposed through the :func:`open_file` function. It can
intelligently open stdin/stdout as well as any other file.
Example::
import click
stdout = click.open_file('-', 'w')
test_file = click.open_file('test.txt', 'w')
If stdin or stdout are returned, the return value is wrapped in a special
file where the context manager will prevent the closing of the file. This
makes the handling of standard streams transparent and you can always use
it like this::
with click.open_file(filename, 'w') as f:
f.write('Hello World!\n')
Finding Application Folders
---------------------------
.. versionadded:: 2.0
Very often, you want to open a configuration file that belongs to your
application. However, different operating systems store these configuration
files in different locations depending on their standards. Click provides
a :func:`get_app_dir` function which returns the most appropriate location
for per-user config files for your application depending on the OS.
Example usage::
import os
import click
import ConfigParser
APP_NAME = 'My Application'
def read_config():
cfg = os.path.join(click.get_app_dir(APP_NAME), 'config.ini')
parser = ConfigParser.RawConfigParser()
parser.read([cfg])
rv = {}
for section in parser.sections():
for key, value in parser.items(section):
rv['%s.%s' % (section, key)] = value
return rv
Showing Progress Bars
---------------------
.. versionadded:: 2.0
Sometimes, you have command line scripts that need to process a lot of data,
but you want to quickly show the user some progress about how long that
will take. Click supports simple progress bar rendering for that through
the :func:`progressbar` function.
The basic usage is very simple: the idea is that you have an iterable that
you want to operate on. For each item in the iterable it might take some
time to do processing. So say you have a loop like this::
for user in all_the_users_to_process:
modify_the_user(user)
To hook this up with an automatically updating progress bar, all you need
to do is to change the code to this::
import click
with click.progressbar(all_the_users_to_process) as bar:
for user in bar:
modify_the_user(user)
Click will then automatically print a progress bar to the terminal and
calculate the remaining time for you. The calculation of remaining time
requires that the iterable has a length. If it does not have a length
but you know the length, you can explicitly provide it::
with click.progressbar(all_the_users_to_process,
length=number_of_users) as bar:
for user in bar:
modify_the_user(user)
Another useful feature is to associate a label with the progress bar which
will be shown preceding the progress bar::
with click.progressbar(all_the_users_to_process,
label='Modifying user accounts',
length=number_of_users) as bar:
for user in bar:
modify_the_user(user)
Sometimes, one may need to iterate over an external iterator, and advance the
progress bar irregularly. To do so, you need to specify the length (and no
iterable), and use the update method on the context return value instead of
iterating directly over it::
with click.progressbar(length=total_size,
label='Unzipping archive') as bar:
for archive in zip_file:
archive.extract()
bar.update(archive.size)
click-6.2/docs/why.rst 0000644 0000765 0000024 00000016405 12576124406 016113 0 ustar mitsuhiko staff 0000000 0000000 Why Click?
==========
There are so many libraries out there for writing command line utilities;
why does Click exist?
This question is easy to answer: because there is not a single command
line utility for Python out there which ticks the following boxes:
* is lazily composable without restrictions
* fully follows the Unix command line conventions
* supports loading values from environment variables out of the box
* supports for prompting of custom values
* is fully nestable and composable
* works the same in Python 2 and 3
* supports file handling out of the box
* comes with useful common helpers (getting terminal dimensions,
ANSI colors, fetching direct keyboard input, screen clearing,
finding config paths, launching apps and editors, etc.)
There are many alternatives to Click and you can have a look at them if
you enjoy them better. The obvious ones are ``optparse`` and ``argparse``
from the standard library.
Click is actually implemented as a wrapper around a mild fork of
``optparse`` and does not implement any parsing itself. The reason it's
not based on ``argparse`` is that ``argparse`` does not allow proper
nesting of commands by design and has some deficiencies when it comes to
POSIX compliant argument handling.
Click is designed to be fun to work with and at the same time not stand in
your way. It's not overly flexible either. Currently, for instance, it
does not allow you to customize the help pages too much. This is intentional
because Click is designed to allow you to nest command line utilities. The
idea is that you can have a system that works together with another system by
tacking two Click instances together and they will continue working as they
should.
Too much customizability would break this promise.
Click was written to support the `Flask >`> >à?!?a?¢?â@#@d@¦@çA)AjA¬AîB0BrBµB÷C:C}CÀDDGDŠDÎEEUEšEÞF"FgF«FðG5G{GÀHHKH‘H×I IcI©IðJ7J}JÄK KSKšKâL*LrLºMMJM“MÜN%NnN·O OIO“OÝP'PqP»QQPQ›QæR1R|RÇSS_SªSöTBTTÛU(UuUÂVV\V©V÷WDW’WàX/X}XËYYiY¸ZZVZ¦Zõ[E[•[å\5\†\Ö]']x]É^^l^½__a_³``W`ª`üaOa¢aõbIbœbðcCc—cëd@d”dée=e’eçf=f’fèg=g“géh?h–hìiCišiñjHjŸj÷kOk§kÿlWl¯mm`m¹nnknÄo oxoÑp+p†pàq:q•qðrKr¦ss]s¸ttptÌu(u…uáv>v›vøwVw³xxnxÌy*y‰yçzFz¥{{c{Â|!||á}A}¡~~b~Â#„å€G€¨
kÍ‚0‚’‚ôƒWƒº„ „€„ã…G…«††r†×‡;‡ŸˆˆiˆÎ‰3‰™‰þŠdŠÊ‹0‹–‹üŒcŒÊ1˜ÿŽfŽÎ6žnÖ‘?‘¨’’z’ã“M“¶” ”Š”ô•_•É–4–Ÿ—
—u—à˜L˜¸™$™™üšhšÕ›B›¯œ œ‰œ÷dÒž@ž®Ÿ Ÿ‹Ÿú i Ø¡G¡¶¢&¢–££v£æ¤V¤Ç¥8¥©¦¦‹¦ý§n§à¨R¨Ä©7©©ª ª««u«é¬\¬ÐD¸®-®¡¯¯‹° °u°ê±`±Ö²K²Â³8³®´%´œµµŠ¶¶y¶ð·h·à¸Y¸Ñ¹J¹Âº;ºµ».»§¼!¼›½½¾
¾„¾ÿ¿z¿õÀpÀìÁgÁãÂ_ÂÛÃXÃÔÄQÄÎÅKÅÈÆFÆÃÇAÇ¿È=ȼÉ:ɹÊ8Ê·Ë6˶Ì5̵Í5͵Î6ζÏ7ϸÐ9кÑ<ѾÒ?ÒÁÓDÓÆÔIÔËÕNÕÑÖUÖØ×\×àØdØèÙlÙñÚvÚûÛ€ÜÜŠÝÝ–Þ Þ¢ß)߯à6à½áDáÌâSâÛãcãëäsäüå„æ
æ–ç ç©è2è¼éFéÐê[êåëpëûì†ííœî(î´ï@ïÌðXðåñrñÿòŒóó§ô4ôÂõPõÞömöû÷Šøø¨ù8ùÇúWúçûwüü˜ý)ýºþKþÜÿmÿÿÿá ŒExif MM * J R( ‡i Z ` ` Ð ¸ ÿÛ C
% # , #&')*) -0-(0%()(ÿÛ C
(((((((((((((((((((((((((((((((((((((((((((((((((((ÿÀ ¸Ð" ÿÄ
ÿÄ µ } !1AQa"q2‘¡#B±ÁRÑð$3br‚
%&'()*456789:CDEFGHIJSTUVWXYZcdefghijstuvwxyzƒ„…†‡ˆ‰Š’“”•–—˜™š¢£¤¥¦§¨©ª²³´µ¶·¸¹ºÂÃÄÅÆÇÈÉÊÒÓÔÕÖ×ØÙÚáâãäåæçèéêñòóôõö÷øùúÿÄ
ÿÄ µ w !1AQaq"2B‘¡±Á #3RðbrÑ
$4á%ñ&'()*56789:CDEFGHIJSTUVWXYZcdefghijstuvwxyz‚ƒ„…†‡ˆ‰Š’“”•–—˜™š¢£¤¥¦§¨©ª²³´µ¶·¸¹ºÂÃÄÅÆÇÈÉÊÒÓÔÕÖ×ØÙÚâãäåæçèéêòóôõö÷øùúÿÚ ? õÇÖÇÞ¢Í.êø+ MbMÔ»ª,Ñšbž¯ª.™öygCöG.Iü³'î’=:ÕÝá” ƒÈ õ^úÞ+ËIm§ŽEÁöô?Q\Ž…ª\hú’èz–ß%IX¥'ÏÝöÚyút¥cª•kM¸|KñGj[Þ£f¦ ÑY2°È`rõ¦³U¤f¢8µ0½FíQ–¦‘¬bZ‰ø5 n*’IƒR‡«Hn Þô•1¼à 3Ú«‰)Û<yŽR\KªEcë\ýìÓé«æB|Ën› ’‡Ð JŠ×Åv.qr pXüʹ Ê›¤ítO²m] @cU-o÷ªŸ&o+ÿ Sýi`ž9‘$ÑânC)È#ë\ƒµß7ÅZ»¶c¼•Þ>‰O šÿ *…O™1B—2mt=~~µçßµ'–X,"“÷
¾dNC18 ý1Ò»‘& ÖV¡éšqÝmi|–ÞÃqÉ$’3Ó’k(Ùjm…œhÔö’W±çzOu G÷Ó²…ù2L7HÃÙ{Ëé]®‰à}Je• 7·+È–ç
ƒþÊýÑùWD_§4›ëWZmZæµñ•«]7eÙ T“÷Tdý+æ=~öm[Rº¿¹rò\J_'²îùGà01_I³nsŒ‚3é_7ê¶2é÷·VSs-¼¾[ \ƒø‚ã]¹u“o©Ñ–S‹s¾ö ¡jcG¹‘æ´¶½²”smqq"ž èÃ'ó®·Æ^Ò-ŠÞi0Þiö̾`žLµ»‚3òžqùþƒáí]^wo.VµˆâBŠIc×`Ç·Séõ¯Eѧִ)Øm. ÙŽ^ÚEfþƒøO¸ü«¶¬Ú|ÑߵκÔÕ9sÓjý¯kžUk
ÌR -ËH£¤‘©Ãê*ÛÜ\Èp±Ä§ \‘úW¬jZ ‡ˆ`7vÖ÷Eæs"4XV>ëÐýWÖ¹›Ÿ\©;õ+r=ß?úe e/´ìû2Ꭵ%i¾WØá$ûV9xüš'ŸýøOüŠí$ðª+bK÷ohâùæ«K ÙÅÇÿ yöÿ !Z}jŸCE‰¤ú³ýùéäþFm¨Ég.ÙY&ûÑ ;¾£Þº´»06ùMyüj™ÒìT¶áIî çó§íá%f‰U%dIÀœy–r$ Fv˜5‘ªé–ú‹»FÆÞñ‰fÀõ$ÿ ˆ«¤ZnWŒM'
RR©Ì£Ù;´ÀrÀ ?Q ïf¡Ìµ9M7ÃÚ®¥©
:ÂÂy®óˆ¼rÝ ÷&¾‚øcðÂ×ÃÅ©jí Þ¬Tc¶õÛýæÇñ~@W›xÄZ…o…Ŭ¾m»adÏ ;ïô#¥vüJ×/e…š3© GÌy ºTâªÖ¨¹c¢êy˜ê›´~Ä<[xú—ˆ5KÉ»\ÝHù>›È ?ƒR3â½Ïš8a[Ø^I$mªª¬’~‹Y.¤lR0F>•Þü ðzx¯Äs-Ü“Egi›#D@bÄáWqœ7½z5f©Òmì‡8Æœ 6Ö.ünŸ@Ö5ßíÜ^Q¶ó˜}Ùˆ$pqè+ÏôKû+P‚îÆáí®ßä•A=}‰¯®4øoJ¾Ï¥C#²Ú[ŒÍ#)ê76kçŠ^—ÁúÒßHºÈ·”ó´w÷€éê>†¸pXÊu±WÓkœØjÔßî×âz¦•ð£í-ößksÞoÊÀì2§ždbXþ®?V[%¹“O¶K{%cäžIä“ÔŸzôK_5ÇÂ-&èÉ››»t¶fîX|®%5çÒ¨¸¾Xñû«p ½ÜýÑø*ògZ£›ŒÞˆôòŠs´ªÏ}‘—
©Š"eæWùä#×üñ^ÅàOÂ? ]ßݦÝBæv¬h•Oê}þ•‘ðÿ Ãböíu;´Í¬-û•#‰ wúç]‹õë
/M¸·¹Ÿý*xÙ#…~g$Œg ‡=Me:Òž†9¦/žk K¾¿åþgÏQÄJX“É#$ûìßx†
Ïuuio×”ÊNÔ ’N^£ŒŠ±%°þîáÿ ŽÖn·ù±"8Œ%ˆ9&º}¢ŸºzØô§³ â kZ–ï·_"ÄÝcŽÑOè[õ®ZÓS’Êw{h¼àÊFÖb«žÄ×vKh£ ïÉîò ÒêZlöqÀ×q˜ZxüÔøp˜¯ðƒƒŒòpkº‹…m§n]
;}PëštšuôúeìŸ7” !¦áÉ BÔW$¶—SÉoq Ùc8xÏó¸4è ó ”ŒdüžÃ×ë[QÝ ý¶º›4j 7Œ9QŸ»'ªûöSöZGUùJJ·½/ˆï~üH¸Òž+
zâK%ŽÔ¸–{cþÑ<”õÏ+קOr–ö8À-œG ×ʲY]Ë D‘6ÙBÀûƒß‚¸5ퟵã{§K¢Ý¶÷³Pð3s˜ºmÿ €œ~W“Œ¤Ÿ¿ËÄÑQ÷ÐßßøZÞ»·B^=>ü|üùgÏëUõ«‹»¹7Í'˜Ý·“…ú]©§ÃsñKDÌ(c·Òo AŽ2òB£ù7äk~çDÒü© ìâùTžý…LçeM>ß«0ÃÕ…6Ý+hv3‚qÎS¬Í…BÒÈÙÂŒ’O@?JÔ‰ZfEKHç
ª9$ö§âm*ïà ‡ˆb•ÌúmäW7‘F~Sl~IõÚ¬[ê+ÐæI¨õg«[1»Ü „m¬,$Õ¼Y#Giܶq7Í!=0îNÑøšàuÝQïg’êuX¢A²xÆ v4 Ì÷<×eñ?\:¦ö+fÍ•§ Ž!-øÄמ8óîñÖ(>Œÿ ýjÊŠ“÷¦k…çkÚÔøŸàˆÕ;ww#Γ–>„ðI4aáx»2•ý)×>Rÿ zEý2¥;ø?ZèO©èñÁWæ×Äz á8 lq?ûJÿ !ó ®³âW‚cÒ<ÍWJ– ß½˜/’Ǻgª“Û¨í^}bL%Jãtn\ôÊ°aý*O꺞¿znµ[—•ÿ ‡pÂÇì‰Ñ~¼š™AºŠIØ…F¤«F9ZË_2µBÖ/ü?ý¡¤´bèFÑí•K$Š…€#>£žãXpÞçÄ<˜\³ç;lúÕô*ê6 §Ek%m×QF¬\'ªdz÷üS|®×^"¼¶…û[D"}²¿0üëƒÔõ Ëé‹\Þ\]°é$Ò»ÿ èG5Ù]ÛùR´‘®cüè9ç¹ßÒ¹ÝsMX.ÿ Ô¹ÚTv>ÞÕÛBTÕ’I Ml„y©íäsî $¢vìòjy÷Ú:´meÀ"»–‡—(^WF×…4ÔÕ5ó˜! d¾ã²þ'ú×rém#uþ€UOéßbÐc‘×l·?¾|Ž‹ÑGåÏãNdû}Æóÿ ±œýó\5%Í/#èptý•5Ý”Ò6»q4ãõiþ4ùv«(fUÜB®ãŒ“Ð
¿"ûq]&mŸ¦}²eC!S.üBö Ö*(Ÿ±›8Y²€ñód€cÿ Ö¯Dð&€4Ûqurƒí’Ž3Éõ=OåX^ÓÅåûßÝÜÄžnŒçŸÈu®šïÄpÀ̶¨.u}ØLÿ ZäÅW²å¹ÍŠu*¿eMüDŒ7„fr1M óþøô4Ï
YXEáKk]BجŸé ½9ÁnGÍÔÆÒ¹ýg\»Õ,¥´¹‹iq¹1G9Íeê7×7Þ_ÚæiDcj
=qªéÃT°U5NNÚßÌÛÖ| m>åÈëåȇù‘^- ´W°º0]Ô
Àz×i †dÕô…»°¹’æâ2Vkf*„0î„v# ükwNœ—¾qÕ§Jo÷ˆô+ŠZ>quml¿ßeWðRM'åÓæ€^´õzÏYH㙨Âa½Ó®e‰NU겟QÏ¥7(½
§ §{hgx_\– Û»X€šÚ\F窩e }sÞ±|7›â 9A íö‰ec€‘"d±>œøÕ
VöÂÆhït;Ëáw nXæ…I A—å< „V„¼85{ký½¦Em+,³AfÞeÃ÷U·c @ÁçšìöqQrz&T¦•íÔõ []}žk•4èdÛæºí3¸ì£²Žç¿ ùÚó+7Oµ·Ól¡³´ŒÇ+µTœŸrOrO$ÕõäÎÍû» îô›ê¾ú7ÔØ9GËæË”å§BG,¼ëân‰ ¼jvêJ¾"˜uËTþ=?*ô0õSV´MFŤVdnÙ`¥tS«(½66¡UÑšßØ
'ÃÖV¸Mžd¤wväŸÖ¶CUrøÉ Ÿ@¢ –+‹®$• „õHÌßVíø~t¾'vÌ'ïÉÊOpÔõ«M=ü©æ¹#å·…KÈßðÓñ¬»hõNèÉscm§Ùò£¹i¾§ ¥mYYÛÙ©[hR<òÌÌÞäõ5lU¾[ZÂ猢Ž7WÑ®sIl%N»Ðnÿ ë×)sjÌÊ„vYX~†½…j Û/"+$qnæºgtf\–£Ïˆ ;c†Ï¯?Ö¶ü)â Ï
k±Ë…ˆ}Ù#Ï*¡ì}Q?5ó18FПÿ U.¡jÌ ]²¡à ÇÒ´m?uš{Î-=ns Š(õ»±u·3I${ÆÂIü?
úgà߆_Ã~ˆÝDzþù…Ìêz #Ÿ‚ã>ä׉xa´ùu½"ãZBm®TÌ} ägýœí'Øú˜Ã*A ˆ®\Æ»pTÑáf‘tùiž£ë;Ä:=–¿¤\iº”bKyƪєö`y´Eɯ-ÅóGsȽµ<
-o<;¥`jY?Ùw²ÈÈä2¸ àãë‘Úx_I’öeŽHæeÏ›rСfçøG¡ì>•kÅ÷'Sñ%Û Þ‚aüA8þú¯Pð¦º6“ ´IûÉØwcÛè:~µZŽmÉîϧ‰x<$Ú’ü÷füþ&žÝm4=#û:Õ"´’ p?3Šåfðˆ.%2J`21ÜÅ®9cîpIüë×ÇN”wÏ¥b8¹Óø_×sÀ¥LN‡Ì®Ê~¸"·t¿‡skðŨM©-µ´«òÆî“#9' ¥AâÛOìÿ ßÇŒ.ó2}gùæ½_ÃÐ}—BÓàþä?J¸ÍÇT{¹®%ý^ƒøµüJ_
xsÀÚEÆ°ö¦îêÝs —-½™Ï
ª:O¥xF±5Ƨ4×r.®ÜË4ž¾¿‡EÐW®üoÔY¤Ó4´?
s'×î®6?…y:(;¤?ÅÓŽ‹Ûük²ŒÚÙäá¢Üyäõ‘©à½ë:¥ÔBñAc4Äv ?3úW7žÙú¬‘œþ@×·ø*M'Á ’kSªê—Ø’KXÀyU1ò¡§RN{šò;Øã[Õ0«,>syjØÊ©ÎÐ~ƒ·U ÝÍa'')[N‡Qé]x?@×àä دFpc$#¶;OÒ¡øo{ýã-*@ØŠI ³ÁGÇàBþ”h¾6Ö´ 1tí/É0gÃÛy‡,ry,dê:ååÜËu=…”3DâO2Þ„’A8'<â…JsFÐÂU”v³þ» ï¤7Ú¾!øŠ`ᣳ´´±?uþy[ôt?^ -áÏßqå(÷<,ׄh_õ= ëR¹H •õ µNÒ¡9}¡8 ð0£ŒWG'Ä•Ô¬/µK„p]lH ”þù‚䟛¢xIûE$´V9c–ÖRN×G¢øCDP-ÝÊ¥H¿(?òÍÄÖ§ˆŒ@ÔEâ -ÞÝÑѺ0 Œ~¢¹m/⇇îÈ[Ãq§1ïr™Oûír*çŽ5.¼=°ž9â¹|ñ0`TsÔ~Í5QÔæš9êQíR«®x}¤ iŸšéì¸õ‘ Cü³SÛؼv’yczÀ¡¥o÷Ž2~¦Ÿ`‰&³«(uòín èÌ™¿0ÕJïÅF -BËLH„WARK§;Tç;süGðêrJr´}Or Í{¢]ŒÆde@®'œr:TFòØ)>a'Ùx¬•ä}ØäõfÎOáþ5½àÝ_x‚ÛO…²4’ÈH#\dC’£ñ¥IA^LíJ‹œžÂ[|ó¾ÐUdØãw xÉôª +¿¶³›ìš]âÞH¹ón!O“>‘“ÉûÝjÜÔ-$ÓõW·¹]’Bïo ±ÿ Öä}kе †^ðÿ ‡î¯š ›û˜âÌFêbT»p>UÀïX{ztÚœþG%LW#Œbß½ØñÛK‚Î4~&˜æCžyäþB¯Kiqœ·ÈBîÑ#g«. ô½j›ÍvÂ5.àˆPâc‚\
í| .•á]Ê0¢2¬Œ?ŠG]Ì* -6®wÔª©J–òýùœ] :=þ«q%²Ûiï–9s™ð6ã©Ïnµ€ßb¸eu4Pý |»)'÷]¦zpiÞ0žx4K{dm¶÷3‰døŠ§Ëø
ÄýkŠŠM³œ¢G,p0ÅKƒ3øš=-Á%.L.à0¤ï#ò"ºŸ…v7ºßŠ# eÑÑô•ûdÑ!ß·Ÿ ~ñÜ2=×IºÃâmréek¸¼öÉà™1#‚x! ÆHÞ!Æ|’Ý#Ï£u¦à´Hf¦ ®–P|»—-þÄc€?T¶'lèNGµO©qg$¥!„™â^>G Ï\
«}â;²q$öÐ g ,}ù'ùW«Í»B?3Øö¶wHx²½†x$XmŠ+æD¹“i+á<óÖˆQ4k}8ÌòG
ªoEå‚ôüö¬Hu[™c]&ÀÛüÇÀ.ÃÛQK¬]G;ª0•ñ™L€{z×=Eˆ©¥Ð{®\òÜÛr5Ž8ØF½ üªœÌçû£êsYÖºµËÊét¨XÊåïSý¬0;ÆÓì3\rÃUOUs²”¢ÕÐ’g»~B«H õf?Hó©àþ¡.dgñª…)ö4m:¯e_Æ£H¤™ŠÂŒä £§¹ô«vïn›¸d•z€¯´~4ËíFYÅ-í¿†¸ ‰ï[ò8üFm»$g]*¡Û¼;wÛÈ Q”’ÛA ÿ
žRIÚ§ u>žßZˆ¨òÉè ZÚ*Æl«"ŒŒ Ùx[M>éÔÛ-䄇'¦å<~'‘\cžOÒ´mÕ¾Ë À¨¤g¹®˜Ç™Y™J’«£;?ø@Ôø›Lº¹p· ˆ\} 9ü® õ .~Ê'úO´°üWŠt±1 Êÿ AUd†>Kd×-]©¨laRŸ'»•ÓmRvžHëMÓí~ÑwIæwÌi½†OE^çÐS–/5É *•5²•@ËA9ÁÁúýk£¦‡<—CØ´·‡KðÌöz6ƒ«¬f <‘"31S—rÌ ?˵x;/ÍÐ*÷¿‡ZÛkZ|–Wæ]À»Kž²Føä ¼>îØÛÞI}è£ÿ ¾[ Ò¹p²´¤žæ^Íݦt•–þí“[Ò´‡1*ùš„eÕÁ<… Ž~¾µ Œ<,º*Á=¶¯¦jÖ³ lX/–ýv”É c¡éô©u_ÝØx+Kñ
™<«¦o9ç’“û¦ú0õîEr'å?uA ƒ·¾ï¡¯>dôì}sšPÕyÅ=s_=cŠÄƒÞše.qØÑ`°âÔÂGzkH£‚Ê>¬&wtçèsJÅ(½Î_ÇzWÚ¬>Ù
æ{a–ÇV¸ü:þuæróЌ׸7 ‚2:EyO‹tGÒ.Œ‘leoÝ7÷÷ôõü)rõ=Ì»§²—Èç\†SÅvÞ
ñ3Ï"iº“î”ñÌy~>ã çÐ÷Æ:õá¥ë‘ÔTFR #‰†SÓ Gê+X«Õ©Æ¢³ÜßøòøœÈ§ÛÄÁ”ò-ÐúŽ+µðž³ý¯£Äï,m{Ûp½Áä#߯9ñs¥Æ¬×±s
ô1ܧԮ~Z<«Ë¦kP,q¬‘ݺA #æÁ'ôÁ9ü+w « “§ÍIy ¸Âs÷eEú%Vž+£œÈοìÿ …[Î
8ÅO”ãkCŽÔmä,T,¹=‚ÿ õ«½c-ç.
õó2H?CÞ»ýnòeC »ºŽ„¡äûÚ¹‹mãQºt敾â‰ÿ ¥%FšÞä¯/32¨ÿ ÇEvÿ ´VÒõ‹[€¸ŠòÝ2@ãÍ@Äm?¬¿i'Qñ “hT4q°žlÿ u>oý m{Ä
ëÞ¸Šò ßÛçûà ?Hük*µ¹*F'-lZ¡^œ^Ý~gÏB=³¹ ”|öúâ½ëá>²Ú§…’ ܵ̓ýÉä²ã(Oü€}Åx` Œö<í]ßÁ›Óoâ››BNÛ»bÀµÏòoÒž*<ôÛìošRU0ÍõZÿ ™í Õ vûû;G»»ïd¨õn€~x«€úWñêI…†“l7Oq'˜W× (üÎ
ñO›ÂÑUªÆn¾LŸ‡zA¼Ô›P¸]ÐÛ ”Ÿâ”÷ü3Ÿ©¯NCD°JÓ ³‡‘üÍýæî:¼
cq/YϦËÐu!£4Qcóߊv?¼³½PpêmÜ^«ýk¾…BCÿ uT~•‘ã;1yá»ÅÆ^ &Lz©ÏòÍl—D‹{T1>ئuU®êaéÁý–×äxoÅ– 1º@yX¢‡>€Ì&©ü!ðþë[´kë™M” y£É“ý¬wÓ×é] †¼6}O`=dJìo ˆ5îäœdûUË”k«™7¶êä*÷Ž2}¨fâ 8ü‡ó®ú^ìQëÓ^êB hdòXåd]è}ûŠ|–°ÈI1¨nåx5%ÄFHÇĉó§ÔvüjÆŸöK‹›V¼{ˆìÙÇšÖøóO ‚=0z õ¯7S¦.1‹M\ÏŽ `?¹“rqÿ ¡«Vîð7™Io&s˜Ûiϯ Æ«ßiI©\
5¯žˆäº 9õ$ƒÓ<úÒ!Y20e=Ç4JýQ¤% FËnÆ~¦÷iö©„ƒÊ'ò×ie^›‡¿r:ÖB°$3=íÿ ×®¤ t¬CGL´Ö±ç<´cù¯øVôªÇfqÖ¡ÉïCnÄPÞZG")'ÜKI,¥— €AÇâkgCñmþz·ztöp̨c ¹pqž3ì+
ÂÚ+‰–6šÖØ ùipJ >äŠô áfªÂ·º–…%£p'‚f˜gÓ€(좽óV§Ú³Vó9ÝgÄ·ZÝì—WòY›‰ ѦÌ0 95Ûê_cÖtH¬nlZ¼‘Ì /N¸=qZúoÁȆÕ5™eõ[hæÙ5‡¨hzT a6ˆu8®]^fÉi#8(F}zqÞ¼ÚÕpҎװ©VÂÖ©Ák º[ú±©ðÑ,nu(çšxŒ°å‘ ´Ô\f»? Z‹FÆæÖaëÁý3ZZ5’éºMµ¨(¹sŽ¬y'ó®gÇ )Z]ý>I&–Úâ¹|Â0P~îOCÐûWž©º³µ4y•qR«ŠUcÑéèø„¾^§*Ž’:ãè+†#ËO\t¯@ÖaiZ´1 &©2H#DmŸ6IèáëZ«à[{Û{ H¾´–[X¼Ë›Öp{’3 Ϫå˜÷,¾â½ÜEJŠŒ÷WüÏGZ0©~çOû?ê4~ }>ÚPºÔ’´÷Hü4ƒ8RžªØõ Õ_3izÍÍæž«ö¥ÃÅü;úgÛ?Ïë^[¦hZ§‹ôÝ>ê ›§¸R7e(å™uùAäôÿ êÖö¶Wysuq T©IûÍŸ¡ÀëNxeŽª{™` ¡QÊ:¦r>*Ö®ï-4õ’ÚÞEÌÓ6 1?À1Ø~f’Õ&ÌòHDIpÁͼ@*d(ðã¦q’j͉UóæR †B á÷úÒܳòâ¦#<ôQêýg:Íû§mNNm5+\JÊÂ(fnÿ Ý ¦¢0¬1$KÉ‘Àf=[œ“úT¨–;åq¾G=Hõ?ÈQ/7qî£7ô Ö¥;/¹ÄE•Vs¶%,G8 ×"»wf²v!nʃØ
’úœ`œ1.s×=?*½„±æDWÿ wq Ò¡¾¶so&e‘ŠŒ€p ºaÔãWÌ’ØÂä± œ’1ŠèôÉm-ô©.5 ·2HçÉ„œ±€±>µ‰en“-IJ GçêOAúS"¶åÆY_ƒÇpG®ªqMjsâ*Ê2÷K·VZ›ï¸žÔÙۓ©
ª@9ÍV– ô xÿ žõnÝf[aæHÒnl ,HôéùÒùEFä÷÷õyéRJ òz¾äkfËaöœmͧ N ?¥ÒmDö—Ç <05Âý†ïÐÖþ¥qouá»Híãò´ 4yÎ2¤nÏ|žõoáŒwW·k2n‹ì~[Ü9ä~•œªµ&G,y}§B‡€n^Ãźy $¾CUqþ UKOn|L»Ó>A¾™¦#øbK~|/ü
º—ðuöé÷vá®ôøîb,ê1$k¼rø Èüª} ZÐü3¬xŸWÔ®CÞ]^Ë6ð2]ˆç'  w'
ÉÔnò¦¯¡Ž"q~õ=nY6¶ÓYµœ°DöŽžQ—*SÛLWŒøÎÃáLJîd‰a½½¾^¶v—²3èÏŸ—é’}«Åÿ õ]`Im§gM±n
ÆÙ•ÇûN:eüëÏ–)f‘" v8TEË þTap“‡½9XóUµ“>ž“KÈ ]Ôé· È?—¥RšËZ‰O•7›æ}àŒ}O¯Ò·ÇZ”W˜èEí¡´qgò8Iu=JÜÉ Ë/FQ&ì~>¿CYí«ÞÆr·w‹Ûï“þ5ßÜé67,ZkX‹ ¬ üº× ®xvâ ®Vx¤¶œà« ŸAŸÎ¹§Jq×sÓÃbhT|²I?CŸ¿»7³n¤Ì@Ü =jª»Ds ´gÖ6+ü+¸aÔ ŒŽsUœ!ì?
˜£×åIZÚåÕµòó}tLy(|Ñø÷üjä>+½½¾¤‘j6®6ºJ6± ïê+Ç£7çP>ÿ ïìEtDç(Kt]»´‚}Òé24ˆf¶”4Cù:QÈïX²õܽI#7u Œ‚Gë•qøWDWbUÒ³cäºXGnÀ“ …£oî†ûÊ×4Í¿öÍ€„²Éö˜Â•<˜g †j¬®¹Ê°
èxÍt?l[Pñ2ΪLVcÎc×æ#jæ
ÝmsµÏ\o¼qÓéF]Z]JAû»aåÆOwn§ð θ{»YnµókúÙ.åUï†.T Ãq?…uB§¼×cÐdêJ=='á“åY]jÒ® 弘³ÙòþUè`ñ׊§¦YŧéöÖvãAG°hó*ÍÎMž"«QÍõh?<ӷʧnOÑTtü9¯Høল¸TÖ# p¼Áså´Ý·zÕÛíV‡±W
÷¾Hó¯é‡C¶µ±¹ÁÔ§Quwܧ„ˆ~¬O¯µsp×S¹è¥c ‡'õ5½â{ã©x‡Q¾s•’fÛì‹ò¯áŸÄÖ
ˆ&Õ õr\þ&¶ƒ÷nΚJ1æßqa º ÄÈÔ*7:$¿2û7qøõ©ây“Ñ÷£õóDÑy‘•
ÕO¡ìjÓÖÇB–‹ÈŽÛÃw:åÄñ2AcnžuÕìßêí—¹Çñ1Ç
:“ÔW?,b厜“[ÄNØ··ï Ääq¸õ p3Ò·®ç•ô™Ò7tI
â†(Ä€~„æ¹ý»¥v=å Ö»(¶×¼c(JRr¾äÉ©ÝÆ>òIÆõçófÛY2"™-ðO÷ ¿ãN»ÓM¾‰¦_±æö[…¶Ø™WùšÊ·@ ±‘OcVá kaBrnéèiÝMi124C /#>àt>õsÚƥ¢^ Ýí¡“?1B$ Œ§¨ý}ÅuZ †¿á9ðË\iø "ÓÜ[Ï–
—Q`ÝÏg òî JàúŽ?PÒî4BK[ûYoïG"í'Üv#ÜVWŽ°4£8W“§+]hÓ>€ð?ì‘øa¸ Ó?€+Ï>%jŸð—êšg†ü;ym¡lÓ3ù§!ƒ€zÚŠy;s+#ªœ ¢åsSÃ%Õ¼÷³ÞÍ&3ÛÓØg …\‹æ¼¸oî…Oê?ÃvÛ4 Ý¿ýôI§éñ<É!šIX€lâ”åï;^×" -˃Ñ0úŽô§¼ày(¬Îßt(ÉÏb*ÿ ØàB¯yr¡ÝåÀ<É AW"Õm¬ÓnŸg´ËÈÙfúãüi'}Kç{"}'DG Æ¢¨÷Kó+îIî•s:½ì—×ÌFÙ©ÈÆzûçÖ¯júÝÜÐ<%ãXä]Q0HôÏj¥m·•eW>hƒíRÓ›²5¥x{Ó݉e¤Èÿ =Ò²GŸ¸~ó AZŒ7–rrp*q&XËpû1–Üzc¸5‡o,óJ·ÒK6ƸUDÞ@Úr½?ùVÑÃé¹zÍ4·¹¹ Àæ©Î¡ãuÊŸåRýiâ0#“I%
YZ\æìc?Ùkž³>òþ@Õ¯³´—±ª|ÀWœcœŸlfGl#x`^VòN;žŸÖŸr -¥òɆ8ã8çÛÚ´Œìa(óK™Ž¹ˆ„ó+);r:'ÿ ^©Iràǯp~µ©m7Ùã~†yð¨6¼¹bXãêwu?‡j9ÍeÍP€¦a|ä3ŠÞð¾½gáëY’HZ[™Xó…
`_SøÖSIJ#|Œ©bq¿ZYìáù¢4lòOõ©“N6‘¤"œ}œ‹Þ·m«,ˆËsn¡]Ffþ ~ZçF‹jã÷sÌGû%Oô&¶·Q– õ<
Ö åc_ªš¨Ï•Z,èŽ Ó•[æUÓ´‹[÷VÏ}üók†ƒñÜ¢»˜¼I¡è: ïá½Xê¬kæDþ3 Îà9ã “Šå‚ãëO TÊ|ß•l)ë±î©‘Lžœ W-ŽÅS¨"•‰25
N½ã’Ö8÷Åá#¾Es“ø"ÇÊÔfQèñ+,Wp¡™Ò(žYX$h73 €Vr‰ÕKVž‘‘æóøQ
ˆî$ ‰Ü§òÁ¬»ÿ Åa(S×tËi>X ïù
½â>¡[ibkx æ}Å A鎪? ×Ì02rO©¢)#Ù£íåÔvùwQèvñŸ.ïR½—¦c…aÿ ?…`ÈáFXàSË}ß”zŸð¤‚’cºA(Ý$®3´}©àÖ·ŒM6[•¥f`„zžµØü-³´¼}Sí6é# ‘ÎC(; ‚è+Šäcׯҽá-¬‹§tèBHb ÎlnE\ß, Žzír»xÒ¡UÄßÁÿ \îÜþŒMfjZWˆ#‰ŸGñ( E{ lü Tcò5ÒN \Ñ$Ï=´Ck ‘ÛB“Êf•P”€7¶98 sROŒVm‹˜f( ÓñE æ§âŒP.aSÔPH¢‘-Š¢¦ALQÒ¦QHÆLzÔñ©b 'Œ
‰\‚A
å9”¼z/ÓÞ³“ìsÍö.E vŠRb8QÏåQI!•Ë°¨,Û‰$ž¦¤’…µ{™[¹"Ô‚£Zx¦C$ZÌñTMqáëèQwÉ"EõbFßפ
8R½;4û4
942 D ”ù‡ñ99'ó®ÃzZÿ Âϼܿ-«Í(ÈîO ú z`ÅsÚE¯•ã}z|q$0‘øç?ú
i ÙKÌÚF”ÛÝ£¦¥8Žœ
sœ£Á¬¿èv¾ Ò¥²¼È&9@ËF݈þ£¸5¢)ÀÕ&âœ]ÑCæåt{hoÆ/-×È— —ÃØŒõ@j”¶îob¹‚M„
’¡äHGЃÐú*Þ}è•›º%»»Í(4ÌÒŠIÉ¥ÁNëÅU„)p£$Õ+I"Cå#;ôàUÀ«è3ïN
3åBR`š[œEå…þ¥;IåI#·ˆÚ°Ïj[oM9S{pÆ?‚!¸ÿ €®èRŠÚ)£o¬Í+GC3GÐ4í'æ´· q3?ÌçñíøUncm£_Ì:Ço#ûäÕÑTL}í›GÔñN[b°ªvD1ÇLð?:¹©C¸ZÅŽ$™sô5Öü;ÓaÔµ›ë+µ-mqfé ï÷—ê+«›ÝHúJ•½œ\û ~éµÕýFÖúv?þu»á½8k‹u¤¦Å¿Ún,Y¸À|ð“èÃzRxŸÃ·zó[^)h›ýTøÂʿѽEQÒ®ßIÕlµá&YsþÈ?7þ:MW1RŸµ¦åMúz™Âa¹’9‘£ÞÆ9QÆ
¸ãŸä}ÅaGm"ºAŸpEQÕœœø’+°ñœ©ŒõؤæÚ[ÂTŽvï
Ãðç5Ðü'Ñm/¼k Ýì±—µ‡Ï†#Ï›'MãýÑÎ=H=«¢3t÷6uÕ.¬—K—þ(øHi? ü>‘ ÇHeIÛ |Á‡oûìŠñ›nG£®?_cjú|¶—w§Ý®ë{¨š' ðG_ë_'kº]Α©ÝØ^Œ]YÊU¿ÚÇ;‡³)ñªÃÔmYœy=uV§/‰;ýçuðíüeqkÿ ,î¬Ûþú £öíoFÓu»o³jÖP^EØJ™*}AêÒ¾}øSq—Žì'¸™!·Hæó$vªìêMu>>øŸ%ìRéþi ¾Y/Èøÿ ¦c°ÿ hóéëYÖ¥)TN&xü Z¸ÏÝ.Šï±Ï|KÒ¼1áÛ¦µÑ®¯$¿Î$¶Þ%Š bÄgwû ûšó×æá¿u ÷GÞ5sË î,ˆõæšøE,ÝuAr«^ç¹J‹§MF¤›±U’;xò«Éàz“D0wɃ!ÿ Ç}©ð£HÞsŒvAýÑSíö«l¸ÓMÞƆ“„›.5ûE•_ iaßYX…éϽvvþ7Ñô›VOøFcšæU,O¹‰?yµâþàŸFõ§êú‹Úè©knæ9f¸2»Õ¦Ma:
¯¯ßú •ðôÛr©v»\ëu k—ŒàˬMÆlâçü ³ŸÒ¼÷_ŠíîD÷·Ý†û³ÈåÏëÐÕÝ3RK©/É1éèßOj¿yo,ö’E ž[‘ܱÍi
q£/uX¯aFtïM [nƒ¸{õ§ÛÜq‚JôeÎ2*ÃوЬ·%Àá£`F? •B@3Éù‡q]ªÒ<ÙóCSÖü:ü3a*œªÀyúfš¶Çû£g
nÅ€8ä©4ž_‡ÀðZ?´&GûÇ Îµ<@¢Ç@¿˜c÷VÌ}và:ðäڪ⻎5y£#—ðÞ®šª¤¤-ê .: Þ Öµš=€““í\g‡, ìÏ*±YŽöGκHndÙó3~òIÏá]¨¥&àvS§/f¤ÈàS扥S“È°íO¾YãÓÞK ®Ñ|Ágr÷ Z±vë0ŽhÇ\«B*”º”V ¼’e\R
špµšÜS©Í«9{¿\ÍFb‰C ¹Î*x¼C–1ÛË„ÄSf>`@`O¿©ª•ß۵尵XQùØrOÖ±fNõéÂœd’ØóêÔ”[gee«Oªë[[®òÌGÞ*¼œžÝ¸÷®×ðçò®Kᥡ’æöå>\KžÙc“ú
í.¢,W;sè;ŸËù×)%>U²:põ £ÌÌÛeÊ4§¬»ðè?J“Ë•#ƒÁ«f,p àM1÷År·©ºzÖ ›HóÕrŸ‘ÅX¹‘@j¤h2@ýI4¶±m3¯÷eoןëPê™$Š†ç>Àð*ºŽÈ¢ˆßgžáÆL=#®
é¸FáH'‚2?F …-gV]¥S§§zVâU9áþ_Ç·õª½Í¢ÖÌ[+ÆŠàKÝBrc` ~£=WØ×{¤6ƒ¯ÚI-ÞŸi
Ô+ºpo ÞvþUçÓB$ÚC‘yG ¿ÄRÛÌĺœÇ(R®ê§¯ÕMDãͪ&¤´½™ZîìË}+YÆ"¶,Y‚J§ðŒžçUKéÝ®F# /·=êûÃåÃ4¸Ý±ZVÇ çücxl›“z’rć?ŽAÓ+—c©µxÆûŸGíNš•b4õˆ÷®k +ÌD2)ØëRy~Õ Ë%½¼³ÎvÅ—vÆp&“B澈d¬‘ÆÏ#ªF£,Ìpz“^=ã_I¬jEƒû:ÄJ•öϯ· ¤ñŠ[_š8¡ŽHl£o’Ù21Æ ( {ÑyëëM¶ðWˆ/ XˆU”>ùä«žqÆN}±ÅCW=¬-á—=ggÙô9§Ÿ»Œzž• ç–oZôÄøgû„óµFóËfB¡qÑA=sŽN~•§iðûE¶›Ìš9îÀÆØç|§â3ëÏh¥˜QïsËô=ÿ \›mŒ_¹pÿ êÓñþ#ì?JŸÆÚtz%Ŧ™æ‰a´¬0ÓHIŸ@ À ³^ضë k h`*Œôâ¿æsã ¤“„Š(‘ÝÛ¸þ¤ÕÒ—<¬¶1¥‰u§äsºeœº–£¥» šwØ…É8$g J÷mN:fedÒy†Þ%Œ¶1¸Ž¿Ö°~ x?û*Ýuôÿ ‰„ÉòFGú„=¿Þ=ý:WkäûTWß*0Äb¥dW NÅXp‡ØÖåu
ÁM=*؆—É4ìO´)m£m]h;â“È>”X=¡P-(Z¸ ö¥ò=©X=¢*§…«>A§ˆM&ˆu
ê¸5"Š°!§¬5-J¡
Š•EJ°Ô‹ *3sDj1ROšxŒúRiä1iâž#§©åd¹ áÖž#ÇJ_.—)<Ã1ÍV‚-ºÜ¸ûñD3ô-W‚Ú ·r ¢ÁÌ ¥§í4»)rŠè`¥ SšpSG s RÓöR„¡@W)Âœž©@W8S‚vÊ¥\hà)ÁqK¶´P%±8K¶œ´P0€T‚oÓî“Ö' ¡«X¦Ì™†Aê§ùVŠ–§Ïmºò׌„‰ßñàë]ßÂË·Z…á (U…~¿xÿ JÄ’ÏïÆ~@€~9ÿ
ôÏ é¿Ùz<00ÄûÉ?Þ?çŸ3ô=\ekRåî^¹µ‚ê# Ô1Íꮡ‡äk’ñ/€4½JÕÎ vW˜ãËý™z~5ÚbŽ„èå¹åB¬é»ÁØùgÄ÷M¯É Ä,o¼À >fp*ýIÀ¯c¶ø~Ú~¤¾™*A¯éè Îè“?VV œ‘šƒÀÞ Šu?^!1©>Ƭ>ñ© è?é]v«â;KIM¤WŽ 8¶k½ÿ m¾ê~$Võ/$¢{8ìdêJ4itßµí·¢.hšˆÔì–VŒÁr‡eÅ»ýèd Tÿ 0z‚+Ǿ4Ë¢_jÖRX]G&©hnD2”#-Óp=½×iyáíÄwq«]C¥[È¡ÒÁ‰’T…’OÇ°ãžÕ¹§xGA°Ó'´µÓâH§ˆÅ+H»”ŒrML-~§&, EU»¾Ëo›ëòûÏðw†Äº¸Óa-Ñ"2¼®›ð€29çƒÓŠè>!ø;Dð¶‘oä_ÞO¬M Ù ®¤2gçb ‡×±luÏ
êãI¹O8†¶* €ãröÉÀ9æ±®¤šêwžæi'ùyebÌßRk¡¦ÝϧtëÔ¬ª)Ú §S=–©íûLœ¨Cÿ }³!7r¡8ˆ ý~•0ˆ"… UFI=€÷&µØë¿3ò6<áÓâ
QÒVd²·PóºðNz =‰Ç^µ¾$èºv–šséÖ±Ú—gÖ1€À.A>þþõè>п°<=¼¡Eܧθ#ûätÏ …p_.¼ÝjÚÍNE¼E›âsÇè¿r)9Tò<ª8™b1vƒ÷QÀݦmeÿ v¨ë‘y–pKØâ?ÄVıî†AŽªiÖÐÞCo
Ê–ŠM¡°p:ëæåWìz•#ÏuÝ Ní¬
ç#ÐVž›®KÜÆòÅÙ²7/øÖæ«áHÀ6÷rnc„ŠEÜXú :Í
ß® ’ß>› ¥(â¨TW¹ÆéV„½ÒM~Ö-GN:…ƒ,ùñÔ¯¿¡ ʹæóÂ×NtÙ´r.f¿X‘¶ YŸÛƒø×;pË¿) ô溨É?‡Tqbâù¹¥£={áOwàËè\Rõ—BˆßãLø¿|¶Ze¶ž¤y·’y®=#Cý[ •i~Ïöæ_ë Ôý²2>¦!þç 5!«xÏR’>bþË Ã «n?•ytéûLlï²Ôà§6ýÒ]7ÎýÔÑ_¿–{ùjp? JÖÔ,®Pª Fl`ò"AÆ~•Ìøbã2µ¹?+Ëì{þ•ÖÝÉæCjÄå‚?ÅuÔn2q=–ã:J_«2_MYno/&ö2m ªÞi–q*¡>l§ —?‰Gp'§zyU’8ÁpMÊOQž¿Ò±ogfÎ9Z*Ñêsšä‹kÙÚR£ýõõ¬lM³Ê~èpŸRA-V7“U‘?ˆôâÜÀ©¦c)óö˜vÆvI÷ âºwÃk +ÃcÖæfaô_#[þN÷i; •~Ïâ«šE‰°Ð´ûHàXØŽÇcúŸÒ=º…à ~@WQóI²©û±HÄ’,8€x'5£Mw}`R³û%ÔnbtìÄ wn}êÅõñ{¸Ö ¯h2 €ù·vo÷ÄÕ†c†3Ïj—d¬ú‰Ošk²2¢‡ u*ߘÇô«zvšoõ«b>FmÒ{( Ÿè?´¶ÿ ¾n: ý ÿ é|'j‰$“ñæ±ý_Ôÿ *Ê£´nUJœló}k2ͨ7÷ÞSúš®Mn€œnA‚; p:½} ó®Tç;ä ©ªv@›(ûœ_ºtEþCb12Ãkƒ† Þ™v¨±¤ŽJ0?#¹éù{S®™mó7?)^›ý?ëéXóÎóÈY˜@ì=+XAËTtS‹–æÓÜI¥ßÚEµ'š0¬1÷€láO¡éüëo@ð¢éšCËtõT1ÁÈŒg;G©õ?áO¸Ð.™k}óa’%˜?<@Ž§ÔTv "K;So:™Ì|!ŒñLžƒùT¹9EÂ&)ÊR¼5±îb S„Ug”QcåyÙ“êš&•q¨j¶…rÞ¬{(÷'Šó¨ôŸxêþ SÎÓ´6%Ò5l| ô Õ˜ÿ y†1Ò½FûL³Ô%¶{ØqnþdI ÊìÛz; Õso&‘½,W±à½çÕôôÿ 3
Ëú]·k=>Þ'·C O°U''“ÜžIëWÌ<ô«„sHEfÑ‹«);¶PhE0ÃWÊÔdT4R›(ù =My/„tq⯠êÚõʆÓí®ÛÊ D’/>Š[êE{è—ìw eP× [yjNm§?\Vw†´h4
ËLµæ;xÂ—Æ Õ˜ýNj¡%¾æÔñ•·z|‘ÜsJ ã¥["€+󲨇ڜ!«8¥ªÂçeq
/“V@æ—˜¹Ù[È‚éVñF)Ø\ì«ä Òù#ÒàQŠ9C•„䊳¶—¬K›+ˆEH!0àM‰r!
xŒzT¢œ*\Q.LˆF)Du.)@¥ÊO0Á (Ž¥Š9EÌG°zRˆÅJ4í¾ôr ˜‡`¥Ø=*R¸¤èy¹Bã6b—gµ;"—4¹BãvŠP R‚(È¢Áp NÛŠMÔoõ ZŽÚ)vÓ7Òï§ õ$Œ
}ê´¤ zÒñQ¥ßTš Š\ÔAéCU¦%Í÷èj<ÐíˆØŸCM»&$ŽSIÓDÚ”EÇÉ ïõÇOÖ» Õ
:]ÇVã𫵖~îýÍkOžC³Q\ÆÓA$jå ®ÝèÏ\{Ô”WQ‰˜t”’íä•ÒÎ5¶ðí #æ?˜zÒÖÞÒ¬1Ã豨QúTØ¥Å;¶7&ú‰Ôõ¯!ø‰ãÔLºV“![ vÍ2žg=Ô îÿ ?¥t_|KäA.“§Iû÷n%Sþq÷þñïè+Én J’ä|‘ Ë7Ðz{ÖÔéÛV{ùN\šúÅe§Eúÿ ‘FUTBÌB¨ žÂ²ÜI|ÅaÌvùÃ9 ··ÿ [ó6³–åÃÞr°©éõ5NÒîµ)Ŷ›j÷Ž6Ä8_©èÖ·ØúJêòvF …!‹j€¨£$ç ‰5é
¼ !xµ½N3¯ÍiŽIÇúÆ È~>˜è<%ðæ Žó]1ÜÝ) –ëÌQ‘È'ûä~B»©W=k
“¾ˆðqù´fuärú¤·ðcµŽeþò¹Ïå^#¯H÷Zåüòÿ ¬yŽG¦ ý+è™b9Ïã^ã+3mâ½Q´Þbû† çóÍ*Vì^MV2›µ·ês‚<ñëÅG¦)°9_èkA#ä}j=:å'Íeßum-bÑï?ŠæÂ[ˆ÷Ípûç?zCÀQèaXÚ¶£ PHÑ1UQ“&èzÓ¿±Ôdcç[KÐ 0+ˆñt’Ãq “!#'S“ÐW¹¯7ÈS¯Åò³ž¿º–êbò»; »¸ç™
«H¬U¿R¤àš³ rã&=£ÕŽ+sMžÇJ‡ýOŸrˇy =€ôþuêΧ,msËö.Ošg¨|$¸µÐ<âKÎIM›Ê«
ͲÁ¯,p>•áö®Q%ÜhPA™Kcy?xƒØ䓚ѹ¸¶‘••3nºÈÄH¤ä.Ü`éÐõ5pÂÉ"#}ü~ Öt¨ªnsþoøcŽU”¯¾ÆœGqo{¤Ü-Õ¡pÀ1Ù"ŒòèHïʵe úÖFž ÔyQI"G#0îéþÐ ¿JÖÝ
¹))“ÞLšæ«*—½ª:ý”£>òL-z·Z¿æ…YX£¯§¨üi²yGæ1÷€ùURbÜL.»€˜¬jMUIZÖ9-®¤pÛ$q<¹6Hïì?úõ{¶/{â(!‘wóäôÀè?ʨË!lă¡Ïéô5Ûø.tIuK€WÏä dùKÀãÜç …k É\«ÝÝÌñ[E-ÍÔ‹KÕØô â}>•çÞ,ׯukf‹Jy-áF©üSãûÞÞßVñ6q~Ë+Dl ñ·» 2LдÛíZäÁ¦ZMs*ýáá?ÞcÂþ'éZÂ
šç‘œæ¤¼Ÿ?öëDèT§_îÕŠî&YÉÀãõ÷ö†ÚQøywg¨\Ü+Ú_¯“ª@„ -ÿ ‚hש ü§ëš±w«½ë•…<¨:c9fúÿ õ«†¯5I©ÓøH¥PÖÚ£µ2}I®"Ôôk×Óµ•P¾g/ê *w žG"›i'›'ï
kYÉŒJ©ÊQW‰¥eÍ…–IdÕn¯í…ž¢Œd’Ü6å Ÿ¿ õê;ÕM yPDÍ”E#t`¥v^/Óc¿óîhåNdûñ0èÃõ â¸ý6äC=å•÷— ¡y¶/ *ã;“òéÚ¥54ùMéÍ´®bøº{TÖ®¡Ó¤im m–<’@'ë‚qøV}ŒjÛšg+|ÈøäžÊ=XúVxÈѳ ±É Éÿ õÓžòF‰mãl¢±p½ƒ >§ W©v*:ãS•r›wÚõÔ¶if&x¬”þî<ŸbG_§APi¶sê7I KÉçod_V¨´}*{é[Ë1ªõ·3°DŒ{“ü‡?NµÞi³è:M§ÙíµWó$…Á.}ý½c6©«EjjªòíàÓ¨âœ
sŸÉA¥ÍGš3RHâi„ÐM4šÍ€Š+5FMCe ëM4M& ±àÒæ£@Ç
vx¨ééBâÒ™N¬‘ÔQš3@ h¤àSàÓª0iwPÉ°ñN£Ü=hÞ=j6&¥¨„”y‚XŸ?JváUüÁIæŠM“bÐ4åõ5QeÓ̵7VY-K¼zÕ?6ËG0r—wûÓKûÕ?:šf÷¥Ì5Û>:S|ßqU|ڈɂEC™Jï26¨ù¾ôy„Ôó»æÒ‰=jš¹§4¹‡Ê[ó(ó*®ïzpj|Âå,ï¥Üj y§©ªLV%ÝO
PÓÅZ04áLPMJú
Ö(–Å
íÄQã’DI&b‘)<»,@õàøU•OzκÐígÖíõiD’]ÛÂmá ß$AŽ]‚ôÜ@>ƒ Í\¡xµäO5¶/»bQíRÓÀÇ¥!¤K–£BšP´êÍÔµ»-<”’C$ý¡ˆnsøŸj¡pŠrvŠ¹¢Wå9ú×â¿ìG³ÑÜ?+ÜŽBú„õ>ý)oλ¯‚‰lÖ¶‡ø lýãÔþT¶^SƒvOûŒ~¦µQŒug~ •
/Ÿïä¿SͦLä’w ùÉ'úÕý/Â:¥þZÞÌÃrÓÎvïÏ&½sNÑ4Ý<†´´d òцæüÍiN¢èvÕÏ$½ÚQù³‚Ñþ éñ„›R¹{ÒFà‘ü‘ Ë’?ílìíìÄ6pEC¢F¡Gé^Q©kz‡ÃŸËjCÜøvð›ˆmÉɉIùü³Ø« »Ð‚1Šõ}.þ×TÓà¾ÓæYígPÉ"÷ ÐûR’g9â$£R¬¹£-ŸOO&HR£dö«Df˜Â³±ÂŠÆ0kÇþ&‹y¼D¯lÁäX„síè õÁçð®ãâŠâÐí^ÞÝÔ^2å¤ê CÆãùý äÖü!gþû‰ç—ÎÔ$O6-¹G|gø³ëPª>t¢´êÏs,Qõ^«µôK¿Ÿ¡ç"?ju“[ÚÜ£ÜÈ5˜»q“Œç¥\ :Ö¿†mCêÊ#BÜŽç]3o•³é«MFO±‹«ø¯ÌfM> ¿íËÉÿ ¾Gõ®2äË4òNä d;öå˜ÿ Jö{˜#Þ̱ v,ùדA*ê (Ö¯"%¡–õ!OB±€:}sXÑz7ØáÃWƒ’„!¹‘öS+ i˜öäþ‚ – Œ,ˆpã tú zïõk¶´²wˆ3 ±“Ð Sô ×
&Øcã$tä³zŸrjð¸‰VNMY …JièQœÂª«;týi‹iÊùó±íÛŠ¿ojÌãå/<‡œú
?#¦àGé]Ž}o«¦îÊv°ïé" Ú¯'š¹ ¡ÈêQ¹üG"ùw /ð?Êÿ ^Æ´#m±•eÜ:€Nkµ,¯kš$éE´¶#ŽXÁà Œ{8Å6úÕ™7¢y‹Œ‘Œ‘ôõ©•"H°ž„†?•Kͤ'"W‹Ûi#òÿ
æsOTD§G _èsö0I¨j6Öv² ×Ç9ÀîÃè2
ëxv´Œ“^¥Œ.Ig;›’ÄO¿Ö½
ÛÇz®…—¢ÙiºT9’Õ cîà sœ×µ“9[]V'oîÏ Â¦ÞYm³ÄÀƒùqù×5v¥¿âsÎ’Ó™X{ç•ï î PD#,^µoÃáÖ9-&%¦µm›WB2ùqõ³ ’H˜0ç ×úŠÐk”ŠöËP‹€Ar™ÇÉÔž¸?ÌÕÓ¬¦¹FvG[aÆG¨©fÕ¬¬?ãæáUÿ ¸¿3~B¸‹Lncû ˆêÅWÀ A?OJͼ7W×2Ä|ˆd‘T¸sÎ;ÓöWÜ»´ÿ ¶¿ñ„rBñZÙ»g£ÌÛGä9®GWwÕdWºò•Õ·+E Ò8Æ2Iâ«Ç/ßšWüp*ÂŽÝèŒ ã¹Ý -(¯„Ì};.eSŒ}ÑM]Ðb9ö”ƒZ“M3H©ìO?•fÝkJŒŽü´~ƒðÿ Þ3«-Œ*BŒ¦L‘î–HiÎ]Îô¨RHѱ—è¤øšX¦Iæ
|÷ §¼Er¾à +¢°ðäðùÖZªË BO¡àÕÊ\«ßÉ#è…<{ÓÀ>‡ò§®N)ùÆ|kd9Å.EJyëÍFñ÷_Ê“&ã ¤Í74„Öl`M1ºPZšÆ³l¤”™Å!jÎæˆu ‘L
H\Ræ)&L5&@ª¡ÆE8Ê)ó•–wqIºª™½é¦p*¹‡ÈË»…!oz¤g ´Æ¸ ´ù†©³@ÉŠkËÇZÎ7˜÷?- ÃöF—ïIçZÉ7Ÿh÷©r ²5Ìþôž}d™Í'Pä'HÖûG½'ž}k3Î8ëJ%>µ.BöfŸŸïIçŸZÏY;}Cbä4c›©÷§Iª17š—vh¹ ¥Ÿ0Òy†«ƒNØŸq¤ÝQf—4‚Ä¡©ŽyLs–¤ÁÝN
èi«‘š‘`~2@ýi$Âèp8§ŠzÀ;±?J•bA—?Z¥C’!¥UcÑMN €¥8V O1ÄÝñR¤@u?•=iàVŠ‡!5 ¿:‘TœP<ZÖ1D6(ž)švGhˆ 8§Í0õ£>õ¢b$$´n ª/ƪ_Oun¾d • cVÚÿ ‡côâšwWv/6܃Ԋ"€b£Œ² W0þ7±ˆ’Òñ]x*Bä NµBëâ%ºgìúuà W‘T~™«Q™Ù ¿?†|Žó4™¯*ºø•©sö{ Dÿ yÙÿ ³eø›¯)ùaÓ‡Ö?û5?fΕ’âšÙ}ç´ M< WŠEñsW‰‡¦éóŽûdxÏò5Ñhÿ ´[‡ê–ך{ 7íÇù¯ }E ͘ÕÊqtÕÜ/驵ñOÃmâ? H-Sv£fMÅ° \ó'ü r>¸¯!ø_ãVðÖª¶×’Äšñÿ | ÿ ¨sÇ›íèÃñìsô•«iÚ¼ q¤ß[^Fy
±øuáŸ|.“¨Ii°§Ü±i‘W" O\ú#þ@ç=jãÙ9ehNÀâ6{y?ëo?Sß²
*FA ë+]½º…ÛL„M¨L–„Œww=€ôêzWð?Å¿ÚÚ+h÷’½±Pag?4ç>ê~SíƒÞ½5¸Ö²©u¡æU£,=W «Ûñìpšß…"·ðGˆ£Ü×zå”Â[©ÌìPô †{
ùãÁŸu¿ l†Öaqa÷¾ÇrI@Èz§áǵ}q8WFG‘V¸<ù/ÇŸ5j3ˆ¬§»Ó7Ÿ"æ2
™ùC’¤xãk„䳃;ðµUW%[[®•ZxŽ9ïm-ÚØ™1%»0o-ˆÏuSÎÖºïBÚâLrÎ} ÿ ëׂx ZþÄ×Wí¡Ïû›ýÀO Ý?¡5躯Œ¦ð·Œã´»&M"[xšhÀÉŒ’ÀÈ¿—#¸ µ¥j-®Xž½ZüÔ9NŸÆ—ë¦hw³`• }1’§ã^s Áö/ìËy ûD¯æ8 Þ9f?Òº/‰—±^kZf•ªÑ2²ž<¡ógñŠIJßç¶ é‡`D º:f°Qä ïÔéÀÇf·þ¿à ×gó®ŠýÜcoãÞ±3+‰H tAíëøÖ”ñyŒc9)Õϯ·øÓ¡µ–æâ8 BóJÁGrÏä+:rT⢺ £×W±§áKu‚ÇRÔäN ]¨ÇØdãô˲1ž-ØÜCõâ½C[Ñ¿²ü=´råcŒoÚ¸Þņâ~¤×œ¼x¹ƒŽ¥‡éE*Üͳ’„ÕW*‹¹„HŒ¬2§ƒN´ T£ÿ ¬O•½ý
jéVë5à‰¾ìˆÈ,ÿ J¯qlðK¼®^/–E î_oæ)º½ÐåïÛ¯èC,D 玵t+3pt&ß΄ìÁ=TŽõ‰$h›þ™Fï¦ÿ ëWÙ¢h^È
¼x =±ŠÓÐbÕ!I‚´fUº2·?Ž+ÎѺ3Tw2:å¢ì{ié×SYÜ$öÎUÇqÈaè}Ehêú¶LÒ[†–Û?VAè}~µŽ‘˜ùˆeð‡øTs©ŠPVU|ÑG\MŸÊZͪ™žšg÷¨r)bsÆáøÕs ¦<ùR3Ö³ÚçÞ±”¬T`hE1¥œ×¦©DÍ´Bzsô©V'#î‘õ«ÛŠw>´ùL܈D
ÜúÔ‹Ž¥H¢žùQ.CDh¿Â?A׊qç¥(Z9Epž¡V¤Ÿ(®*@(žU‰æ
AÖŸÐdôª±-€ëR-D\sMóOl
wB±g8 Òy€{ÕmÔn§Ì>RÈr}…8 T*x§ ÷ªL–‰·Qº£üi2~´î%ÝA`ED¹=*TPzši‰£\ðõ¦°¥¥S
Æ8:þ#¸¯3ñ'‡µ
³ÜDdµíq )øÿ wñüëÚ4`A ‚0A¶…F´;ð™•\+²Õv>l¹Te€#×¥fMó²I{HOó¯x×ü¤êe¤µÝ§Ü w@F>èxü±^}¬|6ñ©ci ¾¡ï› þùoñ®…4Ï¢¡šá«îù_žŸ‰çr¤ë·ö‘þUQä¹\æ8œz«bºÖðo‰ÞAè†ãêÏv+ZÓá?‰nWtí§ZÚIË°ú…ýj¹ÒÜêž/
OWQ/Ï5[© ˜L‘ÏÃþZDJ°ÿ )¯KâRæÕí'Öõ -œhf¸b¬PwrGÔÖŸŒ|+©øRòÞ
LÛ¸¸Vh¤·rÊÛH €AäW8à7Þ qMYìkJÉT‹R]˾Öî<9âKMNÏ–ŽMÛw`8#„ú0ý@5èWŸ ¥S¶
Ƨ¦e½<~kÇn Ša@¶I ¯eð?ßø³À–7×q\[j ÒÅ%Å´¥K•‘€%NTœcœQSÙÅsLñs%AµR¢¿MkTøéâ‚E•¶™f¾¡füÉô®Rëâ‹®$,þ »\ž‘* €ZôÛï¬ÐõùÐzKjú‚+ƒñ†|#áɤ·½ñ-æ§x‡
o¦Û'Ê}F%AöÎh¥*øàpFX{{‘¿È䵟êÊÕ¤ŽñÇÝ–XÍ_£¨ Ç5µ«RÓNiro-aû+1<ÈŠr‡ê þ[T¸µ’ô+g·„p¨ò™ û“ùŠÏ1 wÆ(¹{ªÈÒ·Õ®¢¤ÇsD Üß3*áè;W{áx§þÃK»§’Y®åÞI;G
¦zþ5åö‘I<Ë8ó$`‹ŸRp?{¼v±ÛÃ )…Š
¾€(ÆkÊͪ*QŒVzyS•I9½’2¾Ï´mêÄäŸRk |a&‰¬ºZA0Œs2WÏP¤r=3õ«:§ˆ´{”¼²wåv¥Ý²+# r§?6ßö–·<=ð¦ÎðEzþ ¶¼ÒÈݺÒ<¨,I ïÆk
08óâ:ô7Æã Ó§ ‹íãÛè7–’YÝZݺC$EÉÈÇNŸÄsW5³Ó\~`Ö½¤^#×áÓ´VÓÃúv]
ÿ ž„Ÿ¼ÎF=²{Ô7ð”…\Œ• öù°k²…9%
.V]eNKæI£ÅF©þF¯j–¹J£ž‡üiút8½ŒúüOª±œïè=kŸÚ¦›ebªJž"2]Œ{hD2ˆñû·9Ø÷_ê?*£©YùËPO™@õî?m[°ž²)VÄz[ˆŒÐ~d^AÇ_¥aÉ_©Ñ^œq½ÓaÚ¤â©:aâ8èÄ ÄVÎ̧yÑ# xùÇá]µtµ"¬4ÐvœÆ)\Ž»0?:·oc-Ü€Âg—aÀ÷÷4i°¨‘Ù‡ã5½c§¥M6ùK§uS²†ÊñbY2Êß ÍeKþÓÎÔ‹#ï JÔÔœÍ{+Žçhú*‘i'ŽWÎÚžÊüòkHG•ó#HG“bÏîäŽ^[c} ÏçýÉ,GîÉù±ü'×éëWµ[uûeÜ-÷Ø~§óªVŒd·þúõ²wW6S B¨Úݽ ‰ÉûÉÐýGCNXš õ_4gþYÿ wéþjÚw& ¨ë‘ø©¥{lw3î`ó¡1ÝFYq$|‘õIíÞYT‰#RÌ^œ óé]MâÅy –Âí®—æ6ë÷ c¾‡½bÇzÊ$·`~elgÔôiÎM{¥R”tuų† Æ:ͽÒ-n˜¸_*SüH1Ÿ¨ïSY™^Þ9Ã#( 7QíVÔg·5’•™‡;ƒv= í>ô†àÖ`“ž´»Íg{Ÿ?È?½4ÏïTCÓƒT¶.T[󾵚e'½K,›c'>©gŠÂl¨Äœ¹4n'½B9© 5ƒ.óšp¤U§ÍC(@)ÀRO•ŠLhJ6⤗"“=
zR‘J"v *±ü*‘WDdzÔlvõ«?e”õ }M/Ø»³þB©&Zš[”\“íL8/²Ä1OÔÓ„h¿u~j,~Ñt2Â3 *±ü*e·”õP¿SŠ¿IÞŸ)2¨Êéh‰Çà*xíS§ÌßSO^OÖ¬ Ú0*ÔQ„¦ÄŠÓ¢.~•dp8¦/JzÕ¤sÉ™éÅ( Z,gr ¤ ´à*}™ Ò*sŽôr‹™¹ êPÞÔ©tÓÄL:©£”‡+ˆµ;õ¥ OˆlhZxí§ÐÒŠ, )ÀS ˆ:œý*6œÿ Å1jY¤óTwÉöª»Ë I4f¦ábɘžƒÝÙ<š„ Q¾•Æ‘>áÚÕzBô®;7R«éU žõ,Mžæ„ÂÅå
7Ô
Kc52&:òJÑÇ),x©‘ ëÍ0SÅRDc8¤ iVœGéV‰¸P)GJ3ÍUÀx¤-éQ—'ØVO‰5ëOio{zXŒíŽ$ûò¿eQýzÖ‹ßD8S•I(Å]³NæâKy'º™!…ZI*¨÷&¼çÄ_4Ë-ñh–ï©J:LO—?SË ÅyŸ‹Ðá%B‡ièØ=wzüú~—ð»ÁÖJúìµÒ ùçY˜wrŒ ¯jŠÉTJ'•Œ£œ“øžÿ yGâ¿Äëfâ}+Ã÷-’‡cÏ{¬{ŽBzש㯑»6¨ íLÙ›‹a¶2xƒø}ǵQÒ4«ÍZú+-2ÚK›©>ìH9>çÐz“ÅtÑP§
40xe‡\›y™ŠÆIêME0製z7Ž´8|¥ZhÛãŸY¾As2r±ÆÈû¥²Ià¶ßN+ÏqºbzàV´ê)®e±Í¤ã¢7<`.üOfJ‚ffÏû#ÔÊ·¼C«Ë¯ß®¤JžK™g._²†<`ôÀ'ð¬«$šÃÂWwöàƒyqö Pžaݳ×ÐW;Ý*Ø8àZç•V¯µ—MÓ
Ž0t¡×ò'»±¸±»’ â– ˆÎ «/Ô·¦j÷¶ ÑlD_||è}Å[÷]˜)hB–ìàí±Û½)€¼9÷nÏ÷ÐÇ:q¸gè{Î¥óˆbµ(ë¢ ÕqÔ¯
¬‡A9ñTõ]=¹¸
2æÔwüFk[Î×pêAäÒã+Šž!©\4Ï–Ê!Øg ]@ éU A
"g¥\‡’)TZ±U—¾ìtÁ©ÁªŠ]ÆÝ[o±©„ñãýbþu‘å´ËA©áª‹]D½ï¥E%ÃIÆ0¾‚¥“ÊÙby¼ÆOÊ?Zh9¨$ð3ô«)§¤mõ”¹ s]
K·ÝF?…L–Ò »GÔÕ±NZ=šBçd iýç'è*E¶Œ ?SSv¥ÔDæÆUûª£ð ŒÔÂ&#ÓëN0ï ÊŸ )”Ȧ°«mþ׊ї†ùY¢šè@Fi˜©ÊÓvÑbÔˆH¤Ç5?—JšCs
|Ùô«
½)aN¼Têµ¢‰„¤F¥T§ªÔŠµj&-ŒTâ¥U¥QÅKäâŒÛâÏ^•.À½=xíCv¢Æm‰Šp¦—UêGÒ‘eÏ ~t˜F|‘ŠÇÁ"£,ÍÔÓp"€°ã1=>´Ç;Æš8â—4™VéŽW‘Qæ¦ÍW—å9
CE¡û…ª%0ÉŠ›—ÊYßL2Uc-0ÉQqò–Œ”Ó%W ]° šž8€åÛ'ÐTî;XU,çå´0>ñϵTÅ] ZEÉ“¡àÅH*íVfµF,zŠ•E"H*‘
Š¢¤˜8ëHÒc8«Ø‹\I / ê=Ùç4ÌæƒÅMËH$•"ä‘‚¢ÌÇ xuÙÞKW±Ÿ+=ã‹+ 8gîÞÂP±B„ú*Œ“þ5 ñ…Úˆ¼d*ªŽ¤œ ©u³}ÞV¼‰á»ÆY a€ì¿þªÝ´{ñi=^¬ãåã2Ý õ5Ýü5´ðö•"ê^ ¹S»t1^¥á”ù“‚Øåt¡²ý} ÉÇÔsúÖ´ëÖ±dº)xgŠ òáXôö≵‡”2¼áÈ4ã4{uéʤ”£Øµ:õª3
YVcõ4aÑçZƽº
ašê>SƒP–åfÇ¡=©ÌŇ5Rf滩N5»¸¹ wRUˆl‚5¥áxüýIû„ˆ“øbË1`¡¹ ` ø®ÓÀ¶io¢Þj·Œ!·“¤Àò×?7Ð’qëŠÒ¬¹)êsâ$¡Âõ#±·–â㜟sÐ(ü?qÓÝ<Ó4Ž~f=oj›ÄzÛjׄÆ-P‘7_÷¹ý?:Ôð¯‡Òö¼¾ÂÇ÷qgÇ÷· ïRç %/i[sSik¹‚²$.XŽÊ3ü«OH» ·Ÿå p…¸Ãz~5趶ñÀa#QÙM]MyžY,å–F,Ï"î$ýMyßÛ4çu(%c‘†Óɼ’<~îlÈžÍüCñëùÕ-n#oa Msha9[CϾõ"ËP^ÚÜØ]5µì/ëÕu £Ô{Šdgšö•šº%3J93Žjô
Ȭ¨h[žEe1ó‰íÒ2¿f;9?‰‘~œÕÔõ?•gc‘ÍŒŽÊ1÷Ù›ô«QÁ
ôAøóM
N‹#6Û,F@û¸ AŠ•MVVæ¥V¥b89§
…Z¤¡¡XM=MWRjU56$œzž*%>õ ¥Ê!뜌u«qFs‚Õ²d–?…Z©DÎR QŠxZpZv&äXö¤(`ŒŠŸoµ.Úv)LÎ’
‡ŽE7Ë'@ÊAªÅ1Ö—)j¥ÊÛ=¨ÙSí£X®q±.0_j` ÔŠAh†ÃáHÅW’@úÔM8 tú
dnX¥•A,@íYÍ3·|}*HûÐ' Í8 tgëP¼¬Ç¯ Õ0¯4Ðx¢äØx<Õ€p ª¹äTäó@Š]Õ ênîh²œ5F^£šO˜}*#%C-D°^¢™ò‡éP)'éRÙj# žôÃ!ªÁË`($ûTÑÂå¡üe©¸»Ë .Iô Ö-]„Ú]àç‚‘™üW5î`ã qŠr³g‚r}*#‹šøµ4£›V‚´¬Ï´ðÆ»~sk¤Ým?Ç2ù@ßX?¥&á
cJ³’ïT¶ jŸ~H$YvV q^³âoéZ+´Ê÷7ƒ¬
Ì?Þ=ñ5å>0ñö½ •-4àÁŒJÙ/Ž›Ûú>µÓN¥jidzx|N.¼”¹R‰… †™!ÿ Y½ý3åš¼–é
"$ ÿ ýzçX¼à…ÊDz± ·Ðv¦YXK{¼Â|«aò†$àóɽtJŸW#¦²¶¨Ýžc ]ÛÃè;þ¦Ç+§72•aÓ`ä}
º}µ™i"Aæõ27_Ï°¨ÝÞì•„•‡ø¤=[ØV:t&.Û”æ “d3o ÁÊŒn+^×Äú¾›e%Œ…dÓÜ{ybY!pzäžÞ¬ÿ ²G *ƒ¹Uü¹?Ÿò©ì‰ž8;X‡ŒàçŽõmÅ-ŠTÔþ=L)´»k†v²ŸÊc’±7!sÐøë_FÅ™tëfŽIÞ%Ü%]»Nx®'ÂZŸl·ž+ÛÄà»|¦ï„<ƒîy®Ó½|îk™9µNôêÎZÔ©Ô’ºØ£{æܹyÙ¤>ý¾‚³å¶vû¨Çè+aÖ«ËkÄW}N˜;+#M6å¾í¼‡ðªw]⌛Iþ¡ þU¯4ž*›‰b$Å$ˆÙr?•vSªj¥>æ ¨ñ6ÙQú:•þtŸ…mÿ jßÆ6¼¢tþäê F[M¼ ¼ˆéó2?š"}ÇjêR¹^ÒKâF=V½\ qô5¥}e5”& 2Ž§*ãÔ¥r3m ÿ g5½ ¸M4hí8èhø3DµÔ$¹Ôµ¹ ÃæœàJýD~ã¹®@õªž3ñLºýÀ†k}.û¨Ár:;ä½¾½3/õ®m-lÇîìm‡î¡^›ÏÞ‘ñ9'¯nƒß<ŽkÙ…;Ëü¼5SrŸ´ŸÉv©à~5ì¶vëă …Qôä–÷‹HdÔç©nG8>•ìN¦eH”óÎz0\r=‰é^Fvù¹#~⛳™æ¥šÚpÒ·ÜSéî~•z I<éäsè¿ ý?Ƥ¶‰cEHÔ*(ÀP8v$é^"·C–¤ÆCl‹Ñy÷$ÕÈãô¢$«1«‰Tá x9Îsž1øV±‰ÅR¥ŽÇšæŽ› m"Ô¯ä)$, KŽAö úך¨5êó|7Ó§–Y#¼¼ˆÈìø$ã‘ÓšæET
; Îq\מr·RŒ{·8½ =Ÿ5D{~\Óöµ–Û" ‰7òÑwJyØ?™ª†X<ͽÇ@>êýzÐŽÜFF®ÎçÓ,çúý+£Ó´E±Œ\ßlŽB±ùbÿ þUÙV¬iO^¥XÓWžýŒ+] ²y—ªB‘ÄG¸ÿ kü?:µtÉåˆU *€?@+Rs$™ò ÿ ËI €êJ©„“]$vñ½ÅÔŸ(8Ë aØ
ãu µ‘Äê¹»³69õ˜á(~s…„ O|±úsíIr “i„ÛГÀÅvší„^ÑRÕXIª_&•z$Cª¯±8ïÍq3ü÷pÆ<ÖþCüh„ù½J§:ml"'–1ü+ùóP(ܺ »(Þ>½Çò«X&à %8 ry®¿Eð,×ËÆ«$–±«XP0ö³÷Aôëô¢¥xQ\Õ Ž‰VŒÛ&Ñ4»i55ËF5Ô|@ûŒàcŒ:ƒS²Õƒk
Éæ,Q¬˜Æà zR:בQG›ÜØÚ23å5FxzÖ»Vš<Š˜NÌ茌 áëT.Tž§ À ®‚hK6ÕRÌz 2MU¸±X¹»Fçš
Ïþñ®úU¯´IêdÚÝì„ÚÜ‚öŒrW¼gûÉèG§z¯wm$k"6Þ„)Î7zíWžEIBÁÀí2¹ùï“ÓðŸ e‘„™Þ
““šíRꊊյ¥Ìv²œtPßF¯ øíò´÷ÊÂÙhN†Cõô p
w:Dk àb~£$ÿ :¼VaV4ùc»1¡zÒ†5ŽÕ#^¨Àkj;"°'¿n+>Þ¼>mÃ2ÀyHAÆG«}}+JÞ$K”TUP¨N ÇR+Åk]]ÙÁQ–#…Ô~êCî¿#óëV£—Ëÿ ^†1ýáÊþ}¿|KÅYH÷) Íiœ5&K VPÊA¡9«H¡F[êxªVö«"‰"& ?‹oL÷t5:ƒn½„H¿óÕFà>£µmŠrì\ŠHI K?ï
fµ¢ÚëzsÚ^îòÉ ®‚Œ:0íùñVᆠc ©)èB‚
M ´Hsì?ì ~+¢Óº8ç=t<']Ñ.t=E.ÆŠ9@ùdOïê;~U^!ƒ^ÛâÍ 5Ý!àÀ1üðH…ñÓèzñ`ŒŽÉ"•u%YOU#‚?:öiÔrŽ§§…¯íc®èÓ“RÆ;Rª™céÅu؆ÁV¤Tâ¥DÎ8©V?j,fÙ¥JˆjULv©UE+ä1šP;4X–ÅQRF
<,"E©¨CS÷QbKvï‚G¯J²
fƒéS-äc†a¿Û½8ܼ
.~•E®Iá@ 皌È[ïh'”ÐiÐwÉô \1û -UÝïHÒcRÆ¢I,‡±É÷ªDúæ’YL‡Øt¦¨f±V šLÓ7Rn¤XòE!4ÂÔÒÔ “u!oz…œzÔm i7â˜òÕc7½BóPR‰lÌWpiÂøôqøŠÌi½é†^´®W³5Íäd}ïÒ¢{Ä ÅŸÂ²¼ÌœOµXŠÝØeÎÅýi\9-
A²/ Z…Dœ»l ‡U‰1ò{žõ&êH—n†Šyh0…G¾y Ίzäú
§šxâÈå'yLžÃÒ… ”Õ©‘M+ D9OóH‰íV=ª’"ROʬÆ(*e¦‘“*Ô£ sQ³„ë×Ò£g.yééLÉZBx^0STóKš
°ìÒ晚BÔ…bMÔŒÕ =DÒb¥±¨“3Ô-BóuæªÉ1õ¬Û5Œ å ü'"¸ø +ù çGxín’Ð0ýÓžäÊ“øjèµýb-&Å®&رF ·§ÓÔ×–jž0×/$>Eã 㠈? &®Šœ¥x³×Ëðõïí)»/>¤¶ ×/oŽŸ´„r÷.C À ŸÒ¸ûõ—FÕÜÚ]…»³™–)íØœ•<²ûzöê¥y«j×Kå^jײ!1‰Š¨ øí^¡ð·Ãvún‹ üЩ¼¿\’ë’‘
ôÈäýkÐö®’¼õ= \çNU¬ï¥‘æÚ—Žõ]Açž×w¬Ï C*vÇýÐÝI ö µgÃ^¸Ö6ÿ ÄïJ‚IG˜bY¼ÙŽyË(ÁÏÔ“\íý°‚úéR?,G4©åŽÊ †??*EE‹/ÊËó«¯ÎA
lÒQµ= ¥‚å^ã³ûÎÎ ^\1]*Öþÿ .UftF ?x“ý3[±|?Ö-ÕSÊ´‰?ŠFŸ'뀿¦jÆs®ÝÇ cQ¾–áÑYÉ™‚¯ðº*Â[OÞ]_\ÝÎì’±Uö ŸÔ×"µJ}WÜïù…|M\:ÖKÓVÿ 3+Nðõ¾‘:“5É <Î1e Â?_Zci²]7™>nz>rÐÕ¿Fu‹ØtT'ìøÞ°þæ~Tú±ýoÆ© i j¨ˆª¯E°® 9i);¶yÕ+JÊrw“9ˆ¼/,›©Ò%ôO™ô'E¶Ó.æšÜ6éb›$’OÔ“Ï°¡šG“j3túTsI«J´ç£g˜x¶èßë·2ò!òSè¹ Ï5ÌÚ1§Ÿ´µÝ V¶¦LV’Íüex÷cÿ ë¤ÓôÉ& kl¥åH‰T \Žp=ÍwA¨ÀõàÔR]_MÓnµ-ZÞÞÅ¥`ÀœàF8;‰ì{>•c%ŽŸ¼÷RÝȃ™e<“þ ™÷¨ü'áèô-8!¯%ÃO îº=‡øšÙhÿ ¼ÁSùW‹ÄûgʶG
lO<´Ø ÉPºúÖ‹—¢3ŸöŽ?•DÏ» Kÿ ÍyÎ(Q¨ú#1–¡uõ)$cÁXÛÛe5UT5ÇîA裒߇jÏ’ûFµ¾#$¡fÚŠY½ É¥{Uˆpø#þY§-øörYÊ®Ëuò“¡?Ä~¦©É ØW=\–üúÔ4‘ºœº&•‚D*zíûÇêÝk x±ž+eÖ©ÏA¢i´’ŽÇ?s9qIx" Ô°|ÕÚø§Î¼ ƒ¸Á«×1õ¦y&]ñHÿ S*L¿ÊßÒ½5
föe(ÛH˜m–+ËR‰dó}sÍu–‰ –1$r c*«¼õ®
Šë|!r¯e$,@0¶yþëtýsKã̺ˆ‡,n›:H–¦D&èíûÞ_ ø4‘-L.!oPPÿ ?é\QG•REÛr C/CúUè—5E•&ÿ ànØúÿ CøVœ"º ®pTˆ<›€Oú¹N³õÿ iÄ•\D²!G © ÔÖ¬Ñ0Šc’xG?Åì}ÿ opT¦Ì+™-›Éõ |õ áSA1Ü#<¹n¡¾‡úTê3NhÑЫ¨*}EuÓ¦ú ÎWÜx W”üKÒþÅ®äkˆ¯Wsz þcó¯TŒ4Gk’ÉÐ1ê>¿ã\ÅYi6ÑKo!-(x§*¬:©ïÊ“ƒí]ôã¡®£un§ ±Ôª• P)ßJï±Öä"¯5*ý)‚œ
+J)ÀŠˆp<ÑaÝN£škÍ™€þt‰Á溨=çh×ñoð ;·ßb}»R )|Ê«Õ…F×ÑG»UPiÁ¨ /+rퟡ¤
@>ô6Z@J“ºðG½Kö£ýÑùÕ"H84¥aY
à €
arÇ$æ ÝFêV ‘>êBj àSZ^jl'ÝMgÅVij6›Þ“E(²ÓIQ4µQæ÷¨^oz Q-¼Õ MïUoz‰¥>´ o5BÒŸZ®Ò{Ô±[Èü·È¾§©ü)dƒÌ©â·wÁsµ}úšž£‹î€[ûÇKÞ‹åØXcHÇȼúžµ.êˆS±L†H
9j5ÍJ‚‹Çš•’5$ô«qAÜñíJÄ6655e¥Š EXH—Ò«”ÉÈ¥XE§ý)X„ 7ìe{Ž×”Ÿzågã¢úR
!àääšPi™¥Í"‰£5 i Pɦ3Ó ê¼’{ÒcJä¯'ZI}ê)%ëUe˜ I` ä“Ú²“6Œ Þ^zÖ>«¬Ãd¬£÷³àõ=«+UÖÞBÑÙ±Hºzúz
βÑî5&û›`êYø_Ëø«–UníÛÃ屄}®%Ùv0uK‹½zø3ouo’5AËÿ ²ƒÓß½Vñ›ýŽ°A(V¼ÙæJŠ~TÝÂF=ýOÒ½WIÒítîa]Ó0ÃJܱ ƒÐ{
ó /5»©X39‚¯rGÊ žõ×N§-“;°Ø•^n•£ý|Š ðùÖµu· ³G‰nœ£û¿‰ãè
{jà P0 è éX¾ÒcÑtÄ· Û÷“¸þ'ÿ 8¯ž(«Sž.a‰úÅKGá[ eñ#ÃÇ&¯§ÀòA6^åSŸ-Æ>luÁ ‘ õçÆ?Ý8L0u%}9 ʾ¹œ°,½ ùk–Õücz[lZ]Ÿ˜• »sþÒöúŠÞž&Ð÷C˜(AF·ÞtZ/4ËY-Gîå‰$ÝݲZµ<ë3BŒàucدJÂð’ÜZi§N½M—m´`ä4g•`{Ž£ð—äMßq>`=OoËšâž³»<ÚѵV›º¸Ý6ÔÚÆí.
ÌíæÌû ß@8 J»º¢
Kº¢O™Ý˜É¹;²MÕ
ãbÖúæßʺ¡»mÖòUÅHEj:Ôm÷Íi8,do¢ñ"»?‡:A’ö}N@BE˜¢÷cË Àcó5%£5ä®;QcQêO'ùz¾§.›¥[Z€3üÇÕ$þtb+5TtâkòÕuZ‰—µ]d¨]kÉhãŒÊN”Å·yyT Xô}¡HÆé²Od ÖªÜ;I€xQÑGARãÜÒ5 ´‰I ‹uË÷‘‡òB@ÌŘ’Ç©5uÖ ‘k9 TÒZ”„&Y4ûÌqQ]íyŽÏ¸¿"ýù5£·É·/Ñå'²÷5AÓ”••éËš\Ý
Nµ^EÈ«Ò*³ŠÅБ™,
$|Ìp)–¨²µì1óZ:¯¾9ÏãÖ´¦_.ÜŸã”`{'ϧҫiË‹©˜ôû<™ü«®”í ܹ¢ÙÈNœçñ¤¶¹{;Ë$#1ŸæàEZš?—ðª0ÕßtwÙIYžŸ£Ýý”7 ük– Ýnâ´ÊåûÊw/ÔWšxkYm*䬹kIHÞ%O÷‡õ¯M³’9áIau’'WSErT¤á+MÒ•º`à |¬?J¹j…FÓ’CíTàŽÌr=¥Z¹»†ÆÆ{»—Á$cü*:ŸÂ®
îÇ•S]cN½µ¼žæy’Imdò§@~hÛ à¡´¶«)V ƒÔðÿ jo©¬Y ¾yÁI`;K /;‡^1V,Yb‚0óºÆ™s žœ×ŒÏãMnê/-u„€÷x4íŸÍ›ùVeĺà?iÕ.îÐõÌìWñ^?•R
{ê(dµeñÉ/¿ü c”2§ÓœÕ]cL·ÕtÉì®Aòä^ê¤taî
x„3\Ç„žxÂô +(ü+OëVdy:•Áød"@0k¾…js\Èç©”Õ„½Ù+¢Í(éL¡PeÈQï]£°üÒƒTÞõ„¿AQ‹‰&''jú/‡ÊÍ,¨åÜ(ýisñ–÷j£œóNÍÊXk‰ ‚Ø €b¢!OQL–‘V°øãÇÌ9Öštd„’qÈ –(4¡ª<ÒƒHv&VÅ;5iw{ÑblK!}ÇJ‡}8=Uy0Äf¤XßHd÷ª/½FÓZ’¹K¦\T/?=j“Ü`*»ÏïRËTËï?½BóÕ1¨Ìµ,Ñ@¸Óf£i}ê©”žõ,0I7Aµ}O‹d…2{Šš$—ÿ
žxâÁ 3úµXÝïNĹv#2ßÞnµ6I5ißZ,fîH
8ˆSÅ$õ¦(«¹¢Ä¶*®jtCK }*Ü|Ã"‹JCâÆ ÕÈãïB'N*Š¾SHqS(¦ð “ÀÌ[„àz÷¦gvÉÞP¼Z«¾\䜚AKRRIŽ¸¥ÍpsëMÍ š3LÍ4µ&1å©%Dòb ’\T–¢>I1U¤–¢’n¼ÕI%ɬÛ6Œ ¤—5O5ÕÀ±¶Ë Iéøû
Ò–Cœ/ÞÇ~Õ ¬r±õc—sÔŸSYM9hváªFƒö]ôD:n“ $3,½Ù‡Ê¿A[ˆ€¢¢B( ÓùÓÃSŒV†5«N»æ›¹.kßKωî/JmŠ3•Ïñ9Q’?3øÖÈ4»©¸ÜTªÊ’—/Ub@ÕÌßÀ?Iæ¯ÜzU@Þõ/±õ%È$SóPYd™ƒÏµñÞ¡-PK.9Ï4†£rè—Þ”KïXÏyƒÖš/Ç ¦žÉ›¾e >clõ¬¤½ "µôûUÓãˆIüx Ö¦~ì[%Ç—VI£éâ}fÙF7ùÿ çü+¼d®-M¬u—û$+<¸0F¥°72xü«¿[ËQ!S&â£=ë–¤]“g &O™6Ud'€9¦¶"û˜2zö J¶ãŽ½ÍVuæ°jÆQwÜ¥"’I''ÔÔ¾µuÖ qÍe$uBEZbƼ¼™ò—¯« AV™VÈ ƒ©¨&%± ‚³k«6RoDR¸f–BÍÁ<`tҪȵvEªò
ÆGe6’²):Ô"0ìwçËQ¹Ï·ÿ _¥[T3p›ÈÎXúŸO³·S§™½Fጒ3·öô …Còá¾“Ò ƒêÇbAQÜ
¶J½å}çè8 ®iAÙÜÝ좎ré:ÖUÂu5½rk&å:סFW;âÊH¹V#°mZ»Ñßì rпÝcý½QXÊGÏSɨ%â½ê8h¸.e¹ãbë:²qèz®â?S‘ %®›¤RtcþËt?¡oªÉáN"Æe¶‘ˆÏ;IàO ð+ÄPä‚{ \W_ªx„êþ ··÷j1ݪ>8,ª7üx ZóªÑ…:žæÈÃê÷'»ûŽkìѹÿ F¹ŽTs Œ›G®Qô«pÚ ….yˆ0sÕ—±úŽõi,|ˆÒ‚sºSêã·Ðtúæµ,í¼¦W^
ò3\•q
:#Úu -Ó)[Ysœ~5¥
¨\qÈ«ßgT ¢á=qS, úÓAHvdûè2`pqUj…¦÷¤W!y¦çš£-ÀÜØõªó\íBÙ¬ç¸Ïz 3I®=ê¸÷ª
6G ú“eëOžõ“5W}OLr£ ýãÒ•‡Êâþõ<0I.06©þ&©àµŽ>OÎÞÓò«`暉}ˆá¶Ž"ßoVÿ
³žy¨ÁÅ(4ìC×rLÑšfiE+vjJWš™TÑa1V¥E¡W¶*Äqô¢Ä6¥ZŠ?QK xíV£Š,c)IŽÕrÝIÇjdj*Ä@Uc;’ªÒ´‚>¼ŸJ…çÇ Éõ¨³Îz“A%w.r߀£4ÀisJÃ
(54¹¤Êx Z‹4²·AP3Òe$HÍQ<˜¨ä“ÞªË5C.1%’^µRYºàÔRÍU$”桳xÀ•ä¨‰&š[ Z20K5µ‡ÆŒí…#뎕q#ò× øûÓcóõ§æ•‰“=©A¤<ÓIÁÅ$“u#HK60*<Õ+©÷¶Õ?*þ¦‡¡J7cä”»î=ûRyœUS%1¦ÅdÙÑwØ»æzÐf ÍeÉsŽõZ[Üw¤Ù¤pÍ›p1ÉFæäv<ÖDÚ†;ÕïÉÏ4#¢V‹·wx'æ¬×Ô
“ÍQ¹»È<Öd×=kX£®4¢ßRäe«Ðü3v¶ ¼ÔÜüÒ1XóÜ•\׉ÃtCŽ{תèw^"Ò¼5¢YoH~Î/杻•‰Ú?Þ?6¶{TÕ¤ä’8qÔã¦ôGSðóLk©ŸTœ d¤9þ'þ&ü:}I®ôŠÉ»Õô?ZÅk=å½²DRmÎ ÿ drk™Ô¾$Ù¦Fc<þ1©ü95ŒéÊLð\jâgÍ» Ë
¯;$q³»*¢òXœõ&¼¢÷â ¹1"²[/û1o?› é\¶·¬ê:»gS»–á¸N# ðÇçP°roS®ž_UüM#Ý¡š+¨kwY"q•uèÃÔ Jcμ)üM€ukÕQ€8 n)‹â½~6Êëg¾«Õh–_'³:c—Ô]Qíî3Í@êzàâ¼joø†UÁÔÝ}Ò$Sü«2ëXÔ¯2.õ ÉAê ¤È`TfMï#h`ª-Ù뺾·¦é¹wH$ÿ žIó9üqþ)žûRµ0£[ÙÇ2±\åœ xä+‹ƒÀÅ\r¦º)àiӻݛ{ CÖä^µ]ÅgØkK{¨AmÊygîÏ=‡5¦â¾~½R—,Š¦ÊŒ…œ(8'¿ îj –1`0 Q裥[|¤×ééU\uô®wÙ ÕÝ™W)ɬé"²z
Ô¹u$…çÞ¨ÉÞ½ÌZN¢&¶+NHó
£0ëZ3
£0¯z,ã±^.poè¶&ó™Aò”¸»tQù‘ùV~‘•ÜwWYeËsÆ70 Í|îaW–«Hõ!/ܤöÛc<Ÿ›$÷9«ÐÃ’£ÔÓâ‹1§±?Ò®ÛdžSŽ„ Ö¼›9;³š¥[&,#ÆØØÍdzgƒý*hàRpA‡ ò*eƒÃ n#õ«žQtW?{£}}[¨ž|êÙè÷(<,‰'È‚Ÿ”÷ã¥qêA9°ô¯DH² #§JóÙeÄ«Ù]‡êkÓÀ+s$ªs7rŽy£u7<Ñšú3 RLÕ˜Žä ܦ*X¤ÚØÏùKyíKšu¤+fÕzi’ùI¼Ì Ž¢Ÿç¤ôÅQyqT®ns·=Í ©ÜÐyj›Þ³Zõ¿‹ô¨žôs×4‹öLÐy½ê¼“àN½P’ìö Uy™ÏÌ
Tû–ç¸27\Ò 2{Õ}Æ¥‚)&lF¹ ½çA¯*C·“SA“rƒåþñéV`²DÁ—÷ù
¼Ðt¥b%.Ä6ö‘ÇËþñ½ú
¸j0iàÓ2zž*1N
Ã阵<@¬8
‘Wšx©‘9¦K¬F”¨•b8é¶$qŠ³ yíN:qViØÆRÐb§AÅ"ŒRI0N¿AC2näÅ•XàTLÏ죵BÌX䜚Pi‰e[#4ìÕem§"¦Vë@š
;5 piÙ ›Í!lQ³ÔÔËŸaI!ï&I5^Ix5 ’Õ9f÷¨f±‰,³{ÕIf÷¨f›Þª<Ù=j¼`Lódõ¦ê*¬^Ÿ.UTsRÍlN™vFM^‰5ÀüOEדÜúԀБԗ4¹¨óFi“bPÞôȦf›$¢4Ï~ÃÖ•‚ÄW3mï §ÐU64ÖbX’yÍ4šÍêod5‰¨$cƒS1¨œT4tBIfcŽ+>v<Ö´©“T¦ˆ G)ÝNª1¦fÍQ™Ú¶'„zVuÂÖ©#¶LÍ‘95RVæÌ95RAÍkb Üú}+¤>-Õ泎Æ;Ù-,1oj|¥ f 3 :“øW6F5X†ë[£š(Ô·2½ŽžÊà $äŸSïëZq˹k”´œ©5·m>GZM “§fh;Ui<¾EA!§DqP³f¤ðj¹5ªFÑ@O4åëQæ¤J q,Ä9«ðjŒ õ+qÀ¨’9ê#sÙ]ZÔŽìGæ
vŒC T‚q\ £4l«ã¨í]n—2
¸‚§ðÿ "¼L΋•¦½TìÅ»!w,z
Êšw“© z
l²´Ò4ŽycùTLkl6
’rW‘©)h#Õi*Wj#uÉ®ô$Šó§ æ¬ÈsUßšÖ,Ñ"}eƒPO0á$ù ôô?vðÇò€G9¯;#< •ÜéÚ„Vú¥ÍÛ|Ì„ z¹P¼lÓ ç8ÔŽïCU>Xع¨]ǧY™Ÿ ÙÚ‰êý\ÖÍ IâIb!£uܬ;ƒ^a-Ô×.^w$—/ŽÀž¿È~U±áýzm)¶óIÉ8+î§út©yk5Êýã–§3Z ’‘î úóøÕ¸"ÎTôn? Õ“¤kú]ó¬q\„”ôŽa°Ÿ¦x?…tV¡&‰%‰•£a¹X ‚+›ÙJ/ÞG™VmhÈR Ojò¶q$ò¸èÎÌ?kÓsü#¥N§hÚ ô¬]^IZ{>¦ª’œ[§«]
ðX¢ó)ÞÞ¿úõt À …4Pkc‰¦÷$
N£å%ž¦¢¥Q“ŠâIÏZuŽ•2
dØrŠš5ÉéB-OS± D‹52GÚ¥Ž:R™“c#Ž¬"P‹Š™E3“©
2ÇÖ¢wTúúT åÎXý#6®K,åŽ!{ŸZŽšOJPx¤CÁ§• iAÍ$¥&£Ï—Ÿžbþ$ÏR‡ú~X®AZ¦Fæ¢PRVf5)F¢å‘ê_®!¿ðΟyg"Ë\‚ }чà}«„‰ª[ùc°¸³,ZÚb ¡<+ƒãù Z"nk5dcF“¥ FRi9<Ôm-UyzóP4¹ï^‘Ñ~j3-S.OOÖ—ŸZ–o ¹¤ó
C†íÍ.jY´bKšJAOUg8PIö©*Ã
"£9ÂM\ŽÐg2‘þè« T =6SŠÈe;÷GJ² P€ vœi´I\Bi§œ ZZ‚k…ˆg’}+:ª2,()©ÞšÔb^ —Ê›÷oú qíüªÞr ÷Ïjv× ¯*ýp_P}éšó¥øµ‘‹,™Ûõÿ Z)E¨Ø鯇æNiY6ð)#qÉéÖž:W6ºˆ>&ÚÇ÷@›qÏëù×J¢µjÇ%Z.¯ÔzÕˆ‡ Z…Z…xŽy «1¯jdiV£Ni£&,iVc^i#ZÈzL‚š‚¤,e3) Œ ¥FÒö^¾´É$.}¥4RBóšZJLÒ!‹šQMÍ‘$€Ð)™¥Í ž)¥±L-Š†I1H,Jòc5ZYºóPË6;Õç÷¤iM?Z¥4ùÍA,õRI}êÑI-B^©ÜÜ™1È9È©"4€œ“Û½eÏ n^§S¡(ÁT¶ŒrìFIxÄKêÇ©¨mãV=MOš£žN䙧dƒÅD
8 Ó$²¯Ÿ?5S4ñ!ã<Ò±6,f¢¹ŸË]£ï7ò¨ÞàF…˜tížµžó³±c÷&TcrbØ ô¦ÜrzT;‰ëNÎM’ ši4ÝÔÒjJHVjޜ犂F©fð‰ÏÅfÎüš¹)ÏJ£0Îk6zb‘FRI5 Sš´ËMÙM#©Í$B±æ™*ísoZn•¢2æ»)õ8©¡'šfÜ·zÑ2yÞ€!â”GƒÒ´!¶šñãµi•È¨8¤~•4‰Šˆ#ÈÛ#RÌOk5©VfãŠ,Òåî¡I#N\öwvÅ^û$vêv ݽ?Þµ¼gý©â«(6H!Œ5ñù~Tß©_Ã5¥OrO¢6”}œ åÐëô]RµdÕuk›‰ˆ‰Jùj}3Œ·éZ’Zž0 d’:WFÐ íAó õRæ Š2=Osë_]º²æ—ù L1M³˜¾´•Û… ùïX·znûwOãÉhϸ#èGê+²»„yõÀ¬ù¡ÃÅÇCŸÌÖ0©*r=
u¯yë+FJãŒçÿ ¯W^Oâ$ŠÆÙ§á*/¹'²–^z×Ðà=ø9—‹’?:šdª^oy™ï]Ö9K%B^¢g÷¦¦•‹å ÍQ–Í0·½7uUŠ±&h&£ÝFj’%¢PÕ"5W
NSEŒÚ,«TèÕMZ¦CÒ¦Ä4^°jÔMš¡sVâ<Ô4CG<òdâ Κ£’iÜ×a駩¦RF¥ˆ
¤ŸJ–hõ©U œ Iö©aµ#™=…hÚÛn
¾¸¨ 5Š jGúÏÈU¤UQ€ ¦¶±Êî>ôñvEü©Ïs.ŒÖ“ÛFßÀõ UIíž1‘ó/¯¥ºef¦š}!†ŽHÒA‡@ÃÞ¥"“4˜ÕÖÌȾÑÖpLÿ rA¸~}kâÇP°‘.¼ä0‘Y>qÁäzàŽ:WjsúŸˆþÍ#-œhûx298ü ê*éÞöGM:µj×0u¨.¯Ñôä‘Lì¤+sûÂ{{gé
§¿^õæÚüx…¯5(‹<û¶RbfêØ=3Ðzs^— 9hÝÎ|-ƒÿ Ö´¬‘ËV§6’,¢ñVàOjŽ4õj5Å`sL–4æF¸¨ã U…ÎyE©Pb˜0O˜Ò“Âð=j‘“Ô™¤ÛÀäÔe‰9'5 µQ6 “J
0RŠ c÷3H=é@ŒÛ
Z0)
"XMfÅ4µA,˜¤4‡É%Tšlw¨çŸƒYóÏïHÖ1&š~¼Õ ç Iñ¨f›cj‘#1cÁäŽâ³©'tvá¨Æ¤ÔdírÝÖ¤ŠÛPï`pG·Ö¡ûféF‚cœõ¬ÄpWåöëùU›Hàן:óÝ EO.¡f®X‘ŒÍž€t=£˜å'8ã £½Cu ?¥OÀ`lõ®IT“|×ÔíT¡~ÎÚV“™^BütÀô«Y eˆ¦IÅQ†Ï ì‰p?SYR3 ùY‡Ð‘Ud¸œtšOûè×LZ:)MG¡¥2óœsë]WÂ5VñUÒ¿Þk6Ú>Œ¹þ•çO9ë,‡þ]çºñþ«4‹ lóÎw• R!'<ôÜSŠ+ÇÚR”{‹YK5¶‡Ð[áO¿ …Rž ±è¼çÓÞ¸? üU‚!5…ÕneÁC¨1ýÚ Ÿ þ2=~ïׯ1Õµ_W\꺅Õ°ÿ VÒLzl\øƒ^-<ªu5“²<\½}^‹Ìî>aÀ ¤ð*{³9>Ši/có/mâÇʹ‘¿•¬u:é;BåàòaT=G_¯znÀJŸ|Õë” SPìùâ“f“—-ãä58©Œã¹Í4-=EbÙÈH§Šš4f (Í@§µX·lH=±ªÚ‹qܸ$ä“, w#ŒgÓ5a,·Æ ’wô?ZU
´àg Z·ewzs^DñU_SÒXZkR…öŸå@ |ñ0Ù&GsíéX~ ŒÁc%±äÁ3Ç“Üg þF»¥T“÷r(d`rzæ®àú槌t™G³.?öZìÂb]H¸K}Î
ô”dšIžxï]_‡ô Íè;Èm°‘½FIú:Ú·ðåŠØÝZÛ!æŒÆfc½Æ~½ºU¤$Rb¤#4m¢åÜ‹b¦Å&ÚiŠä`sYnŸ;zdÖÃ
ªIì3YásL¨2¾Êr¥O²ž‘|ä*•*¥<-=V™.CqŠw’$nTnLí>™àÔ¡i¬á:ri™¹d'&˜\·Ò¢É'&œ)£)2@iàÔcµ-Ìéf™Ûó6Ÿ`¥s^2¹Ó5„Û_Fקð©òäSÎt ;~UÛ…mKÉždåy °4àjiÀ×£aØ”Pj-ÔìÔ´"pqNÝQÀ¥“@J
"™š]Õ%!Û©¤ÒfšMC5ŠP µ)59¬ÙÓM 4Ò)ÆÖnGDb0Š@)àRSÎiÈ*dpjU>ÔÀ*AT¤g(I£êv8£3žjÄ%sQ²gZÅ1–·ŒŒ›(¼u GWÝ:ÔF‚5iÉ]2úÝ7Ó¤Š6…í?ZÍÖENzdU›+½÷²DÜ€~\{jcJnúlp× 5ÜÓ—àR7
àŸaÓ?™ke;†Oïcqþ!ïY{ ·‘‰!9 °x'ºŠÒÖ[‹¢U Øž=‡z#®ˆóëœßÄIdiñ #Øò ½3ù:äƒSõ §¹»™ŒÒI•Ý7ÀcïÓŒU|×¹JŸ$TN+Jj iÙôIšp54ìÒ°X™µ<®)á³I¡X›4 Ôyâ€x¨±I&ŒÓsM-ŠÎFðB»qQæšL×<™ÛN"šAE( Ö‘×9§b€)ê=k>c^@QOšÔŠ*”Œ§ §Nœo 5ÌR©vÐVº##•¢³-FÉVŠÓ
Ö©Šãô”ÿ NAê¬?J—Yxã ›iXïàf8°I8 `ÔZ¥ÂK}3FÛ×8R:`VŽ¬aOVoi.X”vÒJ¼'û¢¤Þ;ƒMl õŒkFZ&W$¡º+²Ô*Ó÷ªÏV™H€€µ4l {ç¥Bÿ Z…LèF{huÓ¯(鹯 `qÚFB.I<÷=Me؆9•ØœŒ MhÅÁ ÄgôåV‚Œ{ž„%ÍÚÅØw¹ù‰Eþêõ?SþzÅ£*è $í=ÇOÄVRÊÛK'Ê d9?AWâ »EÉ £ƒÜÁ鹕XÜÖ¶b6ù£nžqì¥YY Õó_ìùŸ›gÿ [ùU iŠUÆp@þ•q\˜ˆ'æ^sôç4Ó<ê6íäm£æFÏqÅy×Ä{v‡XYžðÊ· ½af$ÃŒŽÛI v±f6Ým‡’€ô÷ á\ÏÄÜ>a0‰ •óÞ\Œíú ~‚ºpò÷ìsR-TΚ¢f¦»T,õÞ‘è»ï©á~ERÝSBØ5´QËRÖ=ñf¢e«,9¦0¬äx*EVZ…—ZqP°¬›5R+¦0ö©ØST\Ñ2 sN¿¼ß;m.*“!›s×4õZpð+TÌÜ„ OÛJ¢”°Q“W[
¼TR?eüèw-ÇjŒÖ©
ãO|ÒO¦‘T‚ãqHÚRqM&©!6Qš*¬dØ¢—%æˆlu.i…©¬Ôì+f¨¤“£’Lgš¥<ø hÉfœ äÖmÍÎ;ÔW=y¬Ë‹ŒçšˆS¹-ÅǽP–å³÷ª¦Ïzªòf‘ÑX™æb~õD\÷5j7fƒD¬J
iÙ[y`<œ¿aýßþ½EcmåâYGÏØzõêð4Œç"@hÍ0]Ôœ
Gž)s@fœiÀÔ´žà›[$…‚œn8§E+Æû‘Š¶1•<Ôª÷·>RmSó·þ:*yºn4Û²ìuš.¯ã=´ŒuA' a9Î?*£ã-VQ0Ó “y¿q=àë\‚±V „†R
ŸB9¦¼¹{»¹®%Ç™+nltÍsG Ôç[ “jÌLÓƒT9À§]&d¡©ã$àIèG
´®9'ôkxRòýîìzš,LŠ±ÚLܪ=ÍL,[ J¿•ZÍ.h3seµ•: ßCPäôéZÙ¨§…f ðÝš•‡÷3à Z]æ˜á£b®0E 5
¢]Ô„Ó3KšÊHé¦.i(¢¹j ô…œ:Ò
zŽk–Gtà*E ŠjŠ™EdÙ ¡iê´ªµ2TY„Æ*óO R*úÔ3[FG
DA²•ga ¡®ˆÈä’)²Ôl03üêã¦=ê¬Ð³Ÿ›§¥*˜ˆÓZîU:\ïÈ£38"£úV”zcH¾c²Ãüôà ê
~Ë qòÁ5ãÿ zgòÓðQÏç\2©ÎîÎøÊ0\±ÔÊÅ!¦×›TlÓ´åSž<ŒŸÌš‡|7 U#„ãqxIP u%NE8¶ÑNMé%¡˜Ä’GABÛ»÷ úÕƒ†` ƒ¾*奜÷#°I( «ÇçÒºeŠ—M ý”`®Ù”Ö,>ë>üU9CFJºí#¶+¥›N¼wKk2¯¨]Øü³Y÷0%Ì8< áoCZQÆ4í=„यe[ÎÂeN ñJÒCž[îõÁþf°e-²°*êpqëZ¶Ò+ ÃÀlsÎ+Lm%¤Ñу«{Á—Ë—
0³ÏSßúUÈ$(À ºz{{Vz1w‡Êœ ¼Ÿþ±«Q¶FÓÉõþµæMicµ«š¨ü‡‘×ÜVN¯¬_i: *ë-¬ÄHÇAŒ2ƒÛ×ñªZÖ«qdbH
.õ$’¹ ä+UÔ›Q6í"…’4(Ûz s;W^/Š[3Ï(ÞÇRÞ7¼¢+&dòÙ¤Á>»†8¨5ŸYêÚ}ÅŒÖw$Š&Èb’A vϧq¬Õ5uF„"î‘‚Œ[¸3qéQ¡Û5 k¡DÑÈx5f ¢ª¯Zµmœuf}Çš©Ìj65Ç#ÂLêëR¹¨˜ÖLÕ23L§±¦Î执M§SL.(÷§ƒLÍ5Ÿ<+h²G³ÀäÔdääòi¹¤Íj˜ÝI‘MïHzÖѤÓI¤&š´Á4ÓéKM5d1h¤ÍªFl\â‚ÔÒiŽÕB N*%ëÍG, U‹Œ@ÔI'Ÿ óY—>õÍÏ^k.æã'D)“OqïYòÍPË6OZ®Ïš˜Âį&j2Þõlќұ¥‰7V¥…¶ÌI(ùºªžÞçÞ¢°µÛ‰f 7ð‚:{Õðh±œ¥Ñf—>õ4¹¥c2@isLŠB$ŠPj:\Ð"LÒƒQæ—# ž:Òf˜Evè:{šÈyG.ç,h»¸ó¤à‹Âÿ D
#XÆÚ’f”Œ5(4b\Ó¨A§ž=i±a ÈCŸ¼üþ ªÐ58 €bš,s½Y.h£Í.iXV%”Œ\Ð"øÃGæ¼½~•C5¨Øe`{‚+ :楫›ÓwD Ò棞+£¦’Í8t¨Á§ƒÅrTG}AÚž¢˜µ"×B(©c<ÔkÖ¬GÚ²l¶H‚§U¦ ©Ñy¡3 Š«ÅJ©šr-N‹Z© ³DA(d⬧Ù*¯n¦´öœ±r}I¢ºZ’¡ˆäÓ¾Ìä¨vô#õõC µ!Ž¼)×”åÌÍ•¬cÍHÛœ–n™5]í}«xÅÇJ¡ ”*ÌÑM#’×Ú’êÛÈÈ^$$4¤ ã¢þÉ÷>ÕÑÇ Løä õo_ÃùÕm³ÉÍo E†ªsKÉÖðÅ#þø"È>ë·ÇÑÀþcñ¦^Ëy¼Ãvò®Î<¯º«ìqε
·Žõ(¶[»xå K‚ ýÕŸcÛÐ×L+ón)ÉEó=QÎ#4d4nÈáV Ô’Êfù¥æNî úúýióÛ²1J°8 ö5 zÖ©›+=Q…ⶔRÀF>ôõeUÌ%'hè‹“]Ë8ˆJżµÚ¤õÆ{Ó3P§$Tê+wM-‚«}XÖæ£j˜©¦:ûTò*…v4˜©JsJ¨hQ TÐHÖ®ÀœŠŽ8úf®Á "´Hâ©3ÛËzÓÑEy²<Ò65 h¢°‘¤HÚ™š(¬Ù¢
BqEÐÆ“ž´”QZÄbŠ(¢¶‹ ô¦“E´X†ÒQEj‰“4QZ"”…¨¢¨Ì›^YqÒŠ*†Šã<Ö]ÍÏ^h¢ƒ¢šFUÅÇ=k>YsÅPuEÙé…¨¢‹`ÍiXZãÌ9ꪙ¢Š›²4sKš( Ä¥š(¤³Fh¢€ ž)sE„.j†¡qÖ?ïü¨¢‚à®QÍ(j(¤j.iÙâŠ) N
Ž}9¢Š,I¿»<Ž‡š\ÑE#î(4 ÑE 8Kš(¥amªIì ¬aE™!àÓ¨¢²™×àÓ×¥WC¾‘*Ô©EÃ3¾(«u¢ŠÄ¦YŒU„QA„Ë*tQVŽiOŠa%P=É¢Š¾U%frÌi»º–@*=‚ÿ ^¶‚á~k‰•÷UFãEÅ‹Q¦ù"‘„‰Œt‰’EEà·Oz(®Ø¥6¢Úà,ƒ1ŒG¿îúýr*³GE2îiIÛB?( ŒTW6ãÈ‹êãõQNhÑ»´A¨Áöˆ’ë ¼'Ë—Ý€á¿ü«{j(®ÚswF´]“]ŽsÅ0âÅ ÿ ƒê®M‡4Q_[•¶è&Î\_Æ&Þi¤eÿ J(¯Eœeˆ–¬Æ”QX²Ñ!JiŽŠ+3X±†:UŽŠ) l± |ÕØc¢ŠR9äÿÙ click-6.2/examples/imagepipe/example02.jpg 0000644 0000765 0000024 00000114302 12372607550 021672 0 ustar mitsuhiko staff 0000000 0000000 ÿØÿà JFIF ` ` ÿâ XICC_PROFILE HLino mntrRGB XYZ Î 1 acspMSFT IEC sRGB öÖ Ó-HP cprt P 3desc „ lwtpt ð bkpt rXYZ gXYZ , bXYZ @ dmnd T pdmdd Ä ˆvued L †view Ô $lumi ø meas $tech 0 rTRC < gTRC < bTRC < text Copyright (c) 1998 Hewlett-Packard Company desc sRGB IEC61966-2.1 sRGB IEC61966-2.1 XYZ óQ ÌXYZ XYZ o¢ 8õ XYZ b™ ·… ÚXYZ $ „ ¶Ïdesc IEC http://www.iec.ch IEC http://www.iec.ch desc .IEC 61966-2.1 Default RGB colour space - sRGB .IEC 61966-2.1 Default RGB colour space - sRGB desc ,Reference Viewing Condition in IEC61966-2.1 ,Reference Viewing Condition in IEC61966-2.1 view ¤þ _. Ï íÌ \ž XYZ L V P W çmeas sig CRT curv
# ( - 2 7 ; @ E J O T Y ^ c h m r w | † ‹ • š Ÿ ¤ © ® ² · ¼ Á Æ Ë Ð Õ Û à å ë ð ö û
%+28>ELRY`gnu|ƒ‹’š¡©±¹ÁÉÑÙáéòú &/8AKT]gqz„Ž˜¢¬¶ÁËÕàëõ !-8COZfr~Š–¢®ºÇÓàìù -;HUcq~Œš¨¶ÄÓáðþ
+:IXgw†–¦µÅÕåö'7HYj{Œ¯ÀÑãõ+=Oat†™¬¿Òåø 2FZn‚–ª¾Òçû % : O d y ¤ º Ï å û
'
=
T
j
˜
®
Å
Ü
ó " 9 Q i € ˜ ° È á ù * C \ u Ž § À Ù ó
&
@
Z
t
Ž
©
Ã
Þ
ø.Id›¶Òî %A^z–³Ïì &Ca~›¹×õ1OmŒªÉè&Ed„£Ãã#Ccƒ¤Åå'Ij‹Îð4Vx›½à&Il²Öú Ae‰®Ò÷@eŠ¯Õú Ek‘·Ý*QwžÅì;cŠ²Ú * R { £ Ì õ G p ™ à ì @ j ” ¾ é > i ” ¿ ê A l ˜ Ä ð! !H!u!¡!Î!û"'"U"‚"¯"Ý#
#8#f#”#Â#ð$ $M$|$«$Ú% %8%h%—%Ç%÷&'&W&‡&·&è''I'z'«'Ü(
(?(q(¢(Ô))8)k))Ð**5*h*›*Ï++6+i++Ñ,,9,n,¢,×- -A-v-«-á..L.‚.·.î/$/Z/‘/Ç/þ050l0¤0Û11J1‚1º1ò2*2c2›2Ô3
3F33¸3ñ4+4e4ž4Ø55M5‡5Â5ý676r6®6é7$7`7œ7×88P8Œ8È99B99¼9ù:6:t:²:ï;-;k;ª;è<' >`> >à?!?a?¢?â@#@d@¦@çA)AjA¬AîB0BrBµB÷C:C}CÀDDGDŠDÎEEUEšEÞF"FgF«FðG5G{GÀHHKH‘H×I IcI©IðJ7J}JÄK KSKšKâL*LrLºMMJM“MÜN%NnN·O OIO“OÝP'PqP»QQPQ›QæR1R|RÇSS_SªSöTBTTÛU(UuUÂVV\V©V÷WDW’WàX/X}XËYYiY¸ZZVZ¦Zõ[E[•[å\5\†\Ö]']x]É^^l^½__a_³``W`ª`üaOa¢aõbIbœbðcCc—cëd@d”dée=e’eçf=f’fèg=g“géh?h–hìiCišiñjHjŸj÷kOk§kÿlWl¯mm`m¹nnknÄo oxoÑp+p†pàq:q•qðrKr¦ss]s¸ttptÌu(u…uáv>v›vøwVw³xxnxÌy*y‰yçzFz¥{{c{Â|!||á}A}¡~~b~Â#„å€G€¨
kÍ‚0‚’‚ôƒWƒº„ „€„ã…G…«††r†×‡;‡ŸˆˆiˆÎ‰3‰™‰þŠdŠÊ‹0‹–‹üŒcŒÊ1˜ÿŽfŽÎ6žnÖ‘?‘¨’’z’ã“M“¶” ”Š”ô•_•É–4–Ÿ—
—u—à˜L˜¸™$™™üšhšÕ›B›¯œ œ‰œ÷dÒž@ž®Ÿ Ÿ‹Ÿú i Ø¡G¡¶¢&¢–££v£æ¤V¤Ç¥8¥©¦¦‹¦ý§n§à¨R¨Ä©7©©ª ª««u«é¬\¬ÐD¸®-®¡¯¯‹° °u°ê±`±Ö²K²Â³8³®´%´œµµŠ¶¶y¶ð·h·à¸Y¸Ñ¹J¹Âº;ºµ».»§¼!¼›½½¾
¾„¾ÿ¿z¿õÀpÀìÁgÁãÂ_ÂÛÃXÃÔÄQÄÎÅKÅÈÆFÆÃÇAÇ¿È=ȼÉ:ɹÊ8Ê·Ë6˶Ì5̵Í5͵Î6ζÏ7ϸÐ9кÑ<ѾÒ?ÒÁÓDÓÆÔIÔËÕNÕÑÖUÖØ×\×àØdØèÙlÙñÚvÚûÛ€ÜÜŠÝÝ–Þ Þ¢ß)߯à6à½áDáÌâSâÛãcãëäsäüå„æ
æ–ç ç©è2è¼éFéÐê[êåëpëûì†ííœî(î´ï@ïÌðXðåñrñÿòŒóó§ô4ôÂõPõÞömöû÷Šøø¨ù8ùÇúWúçûwüü˜ý)ýºþKþÜÿmÿÿÿá ŒExif MM * J R( ‡i Z ` ` Ð ¸ ÿÛ C
% # , #&')*) -0-(0%()(ÿÛ C
(((((((((((((((((((((((((((((((((((((((((((((((((((ÿÀ ¸Ð" ÿÄ
ÿÄ µ } !1AQa"q2‘¡#B±ÁRÑð$3br‚
%&'()*456789:CDEFGHIJSTUVWXYZcdefghijstuvwxyzƒ„…†‡ˆ‰Š’“”•–—˜™š¢£¤¥¦§¨©ª²³´µ¶·¸¹ºÂÃÄÅÆÇÈÉÊÒÓÔÕÖ×ØÙÚáâãäåæçèéêñòóôõö÷øùúÿÄ
ÿÄ µ w !1AQaq"2B‘¡±Á #3RðbrÑ
$4á%ñ&'()*56789:CDEFGHIJSTUVWXYZcdefghijstuvwxyz‚ƒ„…†‡ˆ‰Š’“”•–—˜™š¢£¤¥¦§¨©ª²³´µ¶·¸¹ºÂÃÄÅÆÇÈÉÊÒÓÔÕÖ×ØÙÚâãäåæçèéêòóôõö÷øùúÿÚ ? õœÑšnh¯ÏO¡c³IšLÐi\–.hÍ%¢ä±Ù¥¦Òæ‹ŠâŠp4ÁÅ(§q\x4¹¦Š)Üh~iE2”QqŒÓI£4\hvhÍ&i ¢æˆ\â—4Ú3AC³KšfhÍ º”4ìÔ±Ø~iŽ¡….is@¬g][çiеCAÔáÔ4‹§µ¼‹îºòî¬:2žàþ„>‘øqñcLñ*Ãa«˜´Ýh¡ Ä7þ™±èØ<úds_4_Ù\é×ÓÙßÁ%½Üc–v?¡Èà‚àÔC)V ©êÈ5Ý_
êÒûÄ´Õ uò(Í|¯à¿ŠÞ ðÒ%´ò
WN^nw ÿ b^Hú6GÒ½ŸÃ?ü+*%ÅÛiWMÇ“„ô ¡üëÄ€«OX«¯/ò5SîzhÍ2)cš%’HØe]0#ØŠ}qÚÅn£4QHaš3E fŒÑE £4Q@ 8"¸ÿ B,üI©@ü6/¸ÝŸäEvÎx’ÆXîS³%döõèßÐûRk©Qê»4f¹û/!@/!eoïGÈ?‡QUõ]®TÁhY!#æsÁoaè*…Èïc~ûY¥òâ¹…äé´0ÍYÍyòÅÀÇn˜í]Ž‹t×VcÍ9–3µ¯¡ r)¡š3E‰ Ñš( 4fŠ( Í¢Š 3Fh¢€ Ñš( 4fŠ( Í¢Š 3Fh¢€ Ñš( 4fŠ(fŒÒRК3IK@Ã4u¢@ îii™¥Ž£½&iiÅ¢’ŠW4´”R¸…§SsJ>aÍ.i¹¥‹ŽÃ…¨…½…J±¨íšµÆˆE/Z›júÊšc§ùI‘ÒC§ž=)¦ ÕÍ&i¹æšw)!ù£4ÌÑAI@4ÌÐ
1Øpí ç¤æK)~h þü'ÝqïšúÀ¿´O4v³·öfªÜ iÜm”ÿ Ó7èßC†ö¯—8?{ó iZ0ÊAÔõgóÍ_N¾²Z÷VØûˆõæŠù{Á 5ßí®ØêÚ`Àòn$>lcý‰?ƒd{Š÷¯xãCñd_ñ+ºÛv/g0Ù2Àˆ{®Exõðu)kº}ΞŠ(®B‚Š( Š( Š*+‰D<„d(Î=h”ú=‹¹s×km-¦ioƒJÍýæ;cË æ¢Ïå´fP2¢RB/à+ž›QÖ´mGË¢R0ÞZ òä_¯_ê(›PܸÅËK†½o…$
†Æ@ê)Ú>\HG.Ø AP5×ö•½³ÆŒªê iê íZðF"…#^Š1VôDßKQE
(¢€
(¨nî#µ´šâcˆáF‘°4íw`&¢¼wÿžã[¶û{¯Ù/$X¶+q‘ô$ë^ÅÓƒZU£*NÒ¸QEQ@Q@Q@Q@Rÿ P‚ÉzÙsÑ©ÿ
ç/uK‹¼Þ\_ÜS×ê{×5|T)i»fýÞ©mnJïó$ ÂœãêzVdúÌîq¤Kÿ }ÆýÜW—WV{;#6Ùmï.$?<òþö?• q2 ¤²ìÆ«N¹ å{ÜÉ£ZÛV™~õ}z5mC*M’#¹zä3Zº ûnLGî¸ÈúŠïÁâçÌ¡7tË„ÚvfõŠ{&ç4
(¦÷¥ÍX1Ô ÓE-Kd¢Š*
;ÑE+ˆZZm-+€´ô]Ç ©™©á .}já«(ý(Í&h®‘¡h¤£=ª†
VèpjÆj¼ü>}k9®¦‘M&i´¹¬Í’<ÒIš3ïL¤…§LÍ Ð;f”`<ÒÐ$šZ`<p4#("ªÍGJ¹ëMeÈ¥kˆÇš"*”ŒV·fˆ ñYw0rx¬å¢Ê‰!&µlŽk+fÓZ6mŠQB‘½AVTÕ+f-€¼“V÷wVê7W1eŒ‘J
Q{ryI[Ö’ÚæO<ÛÎ>qÈoZV] ±¢
¨Áâ”V05VëP··Þ¯,fUùA†ãøV‹5ymÕ,lK}ª\d§U€¹¬Û
m,—¹hÌóÀçg=Ï~qùT§yY¡¥Û5 :¦¨ÆU•¡ørÅGà'ëN°Õn´ëÕ³Ö3µ¾äÇ·Ô÷ ý»×0/uß\‰557zD‰¸BOUÏ*}§ZëüOWÚN„8E#êzþ`Ó”Z\Èmkg±‰ã †> ñ;I;Û›
Eù7v`#1ÿ m~ëþ#>õáþ.ø[â?y“-¿ö‚óö›5$¨ÿ n.X~‡Ò¾“ðÍçÛ4x¶dŒyOŸQßñ5ª8äW] uJi'ªó1q¶‡Ã¨C ÊÁ”÷"œ8éÅ}[ã †Þ ñK<ó[µ– Gü}Úa ÿ ¾¿uÿ Ÿzðÿ |.×ô€-Ö-RÙŽKf
ãýøØä}A#é^¼+þ8>æ½Ãà (ÑüOmçh·ÑÜ÷â?,±û2 E|ÁsámF,îŽ)1Þ'ëø VYŠûJ»Žá>ÑkqÊM(Ëô#ÿ ÕYN F°v~_äEL5ZJò‹GÙÔWÏþøÍ©Yàñ5¿ö…·Au 8ÿ xp¯ø`ûö
ø—Hñ%©ŸE¾Šä/ßAòÉ ³!ä ¨¯>¶¥-Zºîc¶æÅ”W0Ŭ}W³°„Å;&q‘x-õôëWõ icqqÞTeñë^£ØI¬j¤\HÛŸ2ÌýÏÓù
Mµ¢.OW²:2å%E¸µ`F9¨ö"›¨iË©_ÇqtKGíH@ãÔä÷çµjÙi¶vJEµº!#±–?Ry;{=ÊE=8æ·‹SÑ«³9MGTgÚÛùg{ ÃÒUÓd€}öü…C%³.JÃò¥8J÷d*±dPr:‚(¬Š*Žµ©Á¤éò]\ …QÕØôQM&Ý©©[éЇ²Í÷ucþ õÃø¯P¾Öt
VÖݶË=¤±Ã
Å^}sX×:¤×÷osrû¤~âŽÀ{T±Üû×±‡ÃÆ•¤õeržásªø“OÓ¡üÿ ´Çæ¦0Ñ*¸.X ={ñ_U[ëó[Éó :"sµ g±®d\ ÌÀ(fûÌ Ë}OzŽKŒ÷®ªü•U¹t&kâw=?O¾·¿ƒÍ¶}ႧЊµ^Ie«Ï¦Ýųr8e'‡ ‡üñ^Ÿ¤êjv]Û6cqÈ=TŽª}Åx¸Œ;¤î¶¬\¢Š+˜©ßêV¶+þ‘ z"òÇð¬msÄ"&k{
á¥êØzŸzåYÙÝس·,ÄäŸrVÅ(i Y¬)7«:¿øJÍâÕ¼¿]ã?—Jßµž;˜hNcqkÍÔú×uá¸Ú=ßvrÙqô'"§
Zu$Ô…R
&bkȶc©
7ñ7PŸâhñ¨m#@ØÇ$uEõúšäÁ¥ŠÄ¸ûÜ•êNò4ŽÎìY˜ä±êhÝPN-è:ÓfûÇhô :òÚoV7äûñׯ¥8}ªÀ /ðp9éPÑ›D Ó¥¶´¸¹Ç‘ Ž=qùšÓƒC¸nexã ŸxÕF…Iü(ÍÆænkOB…¤¼`ì9>øéW ÐàC™dy}¾èý+R8Ö$ …QÐ]¸| £%9ô
nÇÒg ž-pß¼@t_
½µ¼…/µmã ò‰ÿ à VìÓƒœ”QªM»#DS©”ñHáÖ–’–¡²î‚’Š*QKISq
(RP4:¬Bv*¶EI `íõ«§+Hv,RÓ¥5ÕpBÒfŽÔ•E!zTçÚ¦ÏRFÜäÔMécH¡(Í!ëHk#d.i ¤Í&i–?4f›š3LƒKš`4àiŒRƒL Ö” Zd ÒÓ3@4X–+ Š«4@ƒVÅ1†E&…{ÓEƒNµ‘¢‘YqÇb2ô"®O R+µª-gt=͘nÆÜEEž¤OëS£VM¹æ´#n*ù›ÜÎÉ·zU XºfŒà¡Æ}=*È42¬ˆÈãr°Á ³ºK¨Dˆyþ%þé©ÌŠˆÏ#Ebz\Üú}Üï²rÞ…[k~>µN{-^ø„Ÿ~Ïújà(üøT¹X|©ër-›QñZܺ’4Ç? Âÿ 1]F³ŸÝÈþGÚ»åpØ ‚Zæ|E¤
J 6«uàžCý
SÐ_SÓažHf¶ #9ÜžÁ½=« eMÚF¼Žª¼w:FÌ^A´;G"ò¬¤ÏÚ¸«»w‚fŽuÄŠyÏ?tÿ ÛH î‚OÀŠâ<[âû•½¶¼9v-·…k âF öT@sÏbGµg:+ð=N¼#©AÚQÐ’EªW†Î¯§2b¬#‚ÁRdÈ5æ¦âõ=ØJëC
öÝÐnt!OCŽãÒ±®bÀ=ˆà×K#<$˜Ù“× Ôt5Ne´¹Ê̬½¤A˜ÏûËÛê+Ñ£3¡M¯‰] ÔV–ñDÑ,Iå3ØF@'¯ZΛEÜ¥æ‘<¶7±ò•Ç°#‘ü½« ½³žÊ@³¦rŽ§*ãÔ õ_ƒÕ‚´‡ßðë^…:õ"ïML5
гŠ±éŸµ/ëÑMý¿ ißH6M#Ž (\íòóÇ<ãÕEŒ rû“QhöpiÚ]¥• bTLzc¯ãÖ®f»åmß• ŸT¨ÜŸ.Ý
Wš]½Í´°6õY¡ çsÚo…æÒõ, <%J0aµ‡¿¡é]ajnðN;Ö§N]5g .d²•$0 ûÕûIƒDýå$\À ThŒr+DG^w Õ‚‹¦îŠsSVe¶j‰ÚšÍQ;{Ñ9™„7Zƒ¡Åõ¿½rJ¥‹ŒÜI«Ç¼}â íMqíà|ÚY“ã£?FoÏÀú×}ãM{ûÂ÷÷Š@¸ åÀ}do•,ç𯷘íêH Ï9ú×£Š—ïÊo›Tt‘\tæ¥Ç½s±ÜqÖ¬%ϽzF†÷ÚxëQ½Ç½dý§Þ˜÷>ô\ òÜpq]ÃÍìâÙLøµ½!9è² üz~UÄIqÇZ§-Ë
1WaØŽAüê*EN.,¹õr¾)ÖÌeìlß
ÒW ¿Ù þµøgðvŸ¨Ä@¼¼‹zìqßÀçñ®L9bI$“É'|Ö*n âÜÒ….oy“Æ §P©§«WšÑÔâJ
kZk·–ÖbÚ3 ÕWa–QéXÛ€’ ’{V|š—›/“`¾kŸãì?Ï©«¥Þð2”ÜÖ¸¹
ZK‰ f9%ŽKdrI7 ÓÔýãþZÚÐ#y“·›1ç' úUÐÙëYÊËmXšKa誃å SëVígº8·‰ŸÜ?>”Ë á›uÌ&Uì8ü;ÖÈñ
Û© tÜàÈS…8KZ’±Œ®Iiáç`
ÌÁG÷cäþfµí´Ë;nc„3ÿ yþcúÖ'ü$³v¶‹þû5,^%ç÷Ö¼z£ÿ uÓ–8³£µVÆú ä-nù#ª‘† QV«º-5t ¢Š)€•óWÄ]þ/\ÜÆÙ³·Íµ°õE<·ü ²~k×>/xˆèžkkY
_ê‚2§ ;þî¾} €jïÃBËŸ¹Ó‡†¼ÌúLS…O ›c.à{š—ìc³ŸÄW?²—c–誴áR=´ˆ ᇵ0 •Ï8¸îH´QIY1X^ÔP(¤
JSIEƃ‚qÒÐ(,G(?{ƒüêNµO4¡™z[F¥·‰j‚xæ«_×ô¦3êI=ª)D’Ysò¯OçQf’ŒñRÝõ5H ¤ ÒSFˆ
”S(\Ò曚)ŒzPpi™¥š ´¹¨Á§ Š,&J
.j0iÙ¦@ú ¨‹{Ó P;Ò¹6\§"óRI0ÅWi4ž£±4<½¬ø›5r6àR!–7S·T;±Kšw!“†éN
P¥ÝJæl˜¶BòR3qP3dÔ¶4Lš•i¶pãÂzúÕ—L Q*–ØÒ»Ô¬ò0)ÛïT¤$žµ}Àç*OãP8º¸ú05Ë6å¹ÛM¨ìŒéUpCdô9"¾ì»O£Œ~µRx]Xp{ŽAük ENÊuУ;4ŒZBY»“ÔÕ9^Uia.çm7m—s d]GÖ·ç\ƒY7IÖ·£-NÈ2…Ñ…Þê6šÁ¾ò÷ý¥=TÔlÍœáC‰!q¾9GSÞŸt¹ì)`“ílÖÏËC™â>ƒø×òçð¯Jú—nW̾æoø{⯡ڹò¯mb\$sä2Ø8ç Ä·mñų́ûW‡o•±Ï“qü{i®[BÒ›[Õ`Ó•Þ1>àÒ ¢àå†xôüëÅ¿ µïïšÞ/í;çεB]GûQõüW?…z˜IFJÕ7è|Þq‡ÃƪåVoV{o…þ,øc^d†K—Ó/àC|>Šà•o¦k», à‚2øWÃë†SŒÐÿ …v^ øƒøY㎠¾×§½g;¸ÿ `õCôãÚ¶«‡¿ÀxÓÃÿ )õC³/Ý;‡£ ?ñ¨üõfÛÈî·ÿ ¯øV'…ôÖ¹÷
I.8<ÕIn=ê‹Üuæ y‰ïÅ;Îÿ Á7Í5„Öìäˆ$ÊzäãñÍu 'zó\mÔncÏ߈ }ÿ ^»Ô“Þ¾w1¥ËYùt]âi#ƒÖ£¾¾‚Æ$ïŒýÔ ³ aXz¾½š¦4Û%ÑO=[ü*¦‘¦O¨ÍöÝYœ«r¸gôÏ÷WÚ¹á„J>Ò®‹ó-Êú"ü-y®¾Oî,”þÿ Š?¥tEm —
í^äòOÔÒ UETUF jx5ÍZ¯?»d „ ñN£œ
sX‡n§DOÃ*¼„TaÆ~ðüé8µ¹›H˜vj ÓƒÜTØ—CK¸k{ø ;‚‘ê ÁÞ÷5ÅhZd÷7QJèÉnŒ³ nÇ@+µ¯OF.ç<í}šìYœ…P2Iè:¼ÃãOŠ
‚è6/þ•x›®YO1Ãýß«‘ ojô)Óu%Ê…¹>Ty—Ž¼D|MâK‹äbl×÷6€öˆü径zWMðÛáëëF-O[VJûÑC’ëÜúGú·°êÿ …~þÙxõf,éJso øùaüGþ™üxû}ÉF0Jì[Ùû‘ßò7©S•r@ÌáLñVÑÆÇµÌ ‚è>aÔzÔÝé՜बÉØÍ¢Ÿ2l•€éÔS
yrVv,;QE ši~”è°Âš
%2’ ÑIFGzi-!4™¤&"’4f›š3VZ ÑIIÞ™h\Òf“4SE Fi(ÀvqHZ˜MFÍ@2pôõj¦¦Fé@™gu#?n)¬Ô2EgªÒ¹©zÓ <Š– ¦ ÔK1ÝV'€óU¼’
eûi3Z7²íÔƒWâõà ÷c©¥ TnžB†õ§îîÿ ´¥bìú QºêT™mP•?hcßîŠÌºû(Ïî&o¬¸þB¯H*Êg ©„¬ÎêjËVcÝ=¿8´üçjÎy-²GnŠ[pûì}zÕžÒi3¶'?…A&—q-´*#†rCž9Æ2GNõéR¨«7UiÇwøÿ Á kÏ êæ+X¥Ü»1 œü§µz߇|Ga®Ç›G+:Œ¼Ã¯¿¸÷â“X]ÂÄ<qÝFáùŠŽf´¸Žh^H'ŒîG_•”×B’g63KïÅÚ]ÏZñoÃýÄŦ¸€ÚßÅÝ®Ïûãþ"¼ŸTøGâ+]F8,í¬…¹ó<¡õ‘NHÿ €îÉô¯cð_ˆW_Ó‹K„¼ƒ 2ôaìžEmJÿ 9ö~¹R‚î¼Ï”®§‡“„–¨ä~ x5¼ mx%Ô>Ù=ÞÂá#ÙmÏÝ’OÍÔúW^ÏP4•Išó+beRNRÜâmÉÝ“4•NáUÛz’’vq×ñõ¡¤¨^A\U*'¸†ý¤«œnÌ>ë…bxÎöK]A ²K+,JÊp@<œ iYYJ· õÈøÏ";HC›™À=GþµX UÄÂ/]#Ji9#ÇümgäOo¨"ü² ’ŸW ‚~£#ð^)ÁŽ¹®óPÓcÔ´ù&áe\n%Xr}¼±ÌúeÔ¶WèRh[iôö#Øõ¾ï—š:t;/Êõ/êŒOâiúVx’›ux² D9É5TIMCMDä®]ó>´†Oz«æR(ärÉ’˜ÒUc'½O¦Ú\jwÑZY¦ù¤ÕÕ¤žµ˜’sÖ§I+ÁÄNU¥Í#®)%¡¨’Têù¬Ä’§I+ŠP,¾k©Ðô(ÜÅu4Ë* :*¦sü«I=Mz7…-å·Ò#©Vf.º€zi‡¦œµF‰5 °££{h$ÿ Y Mõ@jZZï±ÂT:m‰9û ¾ë˜©"´·‹ýU¼(Ù@*z)r®Á¨ŸZZ)
03|G¬[è:-Ö¥w“ +€ó# ¹8á¾
Ðnü{⻫Ý]ËZ‡ó¯\tr~ì*}0 öQêA?Š:ûøƒ\MÓÉ’ÒÖO*5Sþºrv“øghÿ W¬xCB‹Ãš
¶ŸEæõ’ ¼ßÐ{]‘—±…Öì×øp¿VkƉk j¨ˆª¨À tž( W!‰’)àñQƒOé²ñN¦
p¨%¢¥çúï¡Í,ïºV#‘ÐS+Ì©¬›-!sƒFi¹¢³ ‚ÒþÜÐR@O4™ šm ¤ÒA4™«HvšJLÒf´H¡Ù¤&›š
U‹H\ÒRAŒ
;û^Øýï1~«Ÿå[^ {¬Ã^¥· qôª²´ô¾µ” —~-ƒúÔfh¤b±ÈŽzáXÆF°+J*¬ƒ^UY±’;!"”‚«2–!TÇ ®È¨3½ÑÆ –V
V!å©ëŽ§êk&Ž˜I¿„« K~[kÌ?‡ª§×ÔÖtÙbY‰,y$ÕÉ¥T”uÅa.Çm(ÛW¹IÎMDjW5®s‚¤ç)>aQšy¦´8Œ=j¼à0à ÃЌՃU¥5¬ªvØM*öMôÜجjì»JåXuäWSiãkIˆ]FÞKwÿ ž‘~ñ×ù×)ªsWd[’åz˜Ö§ºÌô+¿éÍåÄ“.ó"ˆ•úzÑŠ´‹–Ú/’6=ÀÇŸÏŠòùÛh$äÖUÍæÌá3øÖë-öŠé4qK K¹îþrºF §¡ ÔO%xNŸâ»"`Ö…Ñ3ÌyÜõ_ðæ½gÃZäþý¸)¸”’3Õ u Ô àŠòñÙu\2çzÄä©G“gtl&¹ß®ï²·`X*Üf¬íj/:Èž¦6
ý
e•ÏÙâ¡'ßó 5i&sqÇíXþ.ð¤^ µW‰– F%ÄRŸºÃûŽÞ‡¨údWG~µn8ëïÔœ]ÑÔÒjÌùÇS²»Ò¯ZÓPíîÜz©èÃÜUa%}'©è¶Í§ÙµKH®¡êŽTú© ©÷¸M[á 1}T–ÜÄWqùª=ƒóÍtƤ%¾‡<¡(í©åé œ× ÁðƒZiŸSÓb@~ò¬’>˜üë£Ò>iV¬¯ª\Üê.:§ú˜¿!óìZ›”ì\³ocË4- P×®Ìd aSûÉXíŽ/÷›·Ó¯µzÿ ‡<7m Y˜á>m̘3\0Ásèe ‡ç“]LPYÛ%½¤AoÂE…UúQË ^+ ÔæÑlm[VdÉ 8®/íÓIu6 mó ™5ÚkS‹ 6æäÿ Ë4${·@?:ó«&À œšÂqRÝ&ÖÇIk+?Þ9GÛ”‡ ëYl8Ë91Žkš¦œÖÖ)T’-é6o~åQÕqÔw®®ËÂÐÈ£|³ƒê1þ„ížòô08ŽÎyößA ^ ¯6¶ Ÿ.á*Òègi:…‹,‘úQÑä;ˆúzVؤêÍ$¶0m½XQE%Š0qœT770ZÆd¹š8Pu28QúÐ+“W/ñTŸJðÄÏhÁ.'qn¯žP6rÃß þuS\ñå¢2i‰öÉú9XÇãÔþ y–¹ª]ê×_hÔn7¿ERvªE ª¢Òfôè¹;½‹
íßÆÚjÜàmñ/¬Š§hü²
÷zùœj ØúÖ‘©#.-.VV9à/ÿ ñÂÕôÀ`ÀåO úŽÕUîÆ]lj^òbÐ( V84ñY‘_ñ‡OÅMN/“ + ʽR=Éqeàj ™ö)E?1ëíU íØa~AíÖ¢¹êUÒÑAÒ—4ÀjH—{dôÆÑV {¹<
”*¯ÝfŒÒ°ì/zk z€hÏ4™§a؆H»§åPWFIã$ûTWÒ ™PûŒÓ±H¬M%#§ >†›š´‹µÇfŒÓ 4fªÃHq4f™š3T‘Hvi3MÎhÍ;8Òf’“4ì1Ù nh¢Ã&SO Ô*iàÓê)¤Óá]Ïì(J佤;€-*`F —4µ²ŠFMÝ€»ŽG>´P)òˆ‰Ð§¸õ¦3`U†`F
gÌû‚k
‘å4‚r %Æy¨|ñëUî&àóTZãæë\òv;!BèÙI3RƒY6óç~9r*y®aR‹‰l‘j9©WŠ™+œ²‰0¡× ÓV¤ê*,dÕŒ»¤ë‘šeüÖL|–IåHÈ5vé8¬k…bØU$ûQt•Ùqµµ:‹]U.%]ê9<˜ê0Er¶þdx,@öÍZk뀻Q‚a\õ14–ÎìNVkÊ*œ¬r@úšÊ’W“ïÈíõ&¡o¥rU»(?Ý·?Ö©Lþ%“8KôµÕ ºÉ!ó\P¬åƒ>Ü1ÔÕiãXÁÇ'Ô×/e¾º³Ü=Ç’²)pe^W<ð
uWPÌЙU~NO^Oá^ÖN¾£ž¤¥sôŽk%l®µ Ì66òÜKŒíŒt ¤ž úš¿y&s[/b¼¼¶•Õ.n6y[Ž7œ¨÷ç8±UeF”ªA]®†
Ù] Ñðˆ. G‘m
ž¦[Çà ×£x;@O
hßc›‰^C4ÒíÚ v 9涉ÁÁ>†˜Í_'ŠÌëâ¡ìåd¼Œ›rÜyj‰È`U¹`ÒLc\VwEF&c©íÞB”çÃuê*hzWÚåøèâ`“ø–æ– ua"§Â*ÚEÅz)ù_Z¢3 ±àPT‘Õ9SkJ•¨\ªHˆiG;úô\âL³›Xb„fÞ7Ý9 sü?†OçŠä,ä¯A½…dWI@upCÎAë^wunÚuü–ÌI
r¤ÿ ž‡üúPÊFõ¤¼Šé´4Žwo0’ Šå4híÉݶ%à·ôÐOZB²Á$ƒ rÝséHOø}nmM”“˜ãúà’?Q] å>ñ¥¦‹¢Çi”÷,Í$®ÌK“Ðu$œUÿ øOµ î¬# ìÏþââfœÛbT§'±èôµÀÛxÃQc™!µaì¬?lXø®)-Ü
áùu®E^µÂTfµ±ÓU
rôéÚMÕÒ¨f2 ô,x ©«‘K Ñ,‘:º0Èe9²|_³þ»àçA®áÖ´oKµi eu{s3I=Ýùïæ €
e–“{«J~Ë“°8iEú±«þ ±KýjÖÚPZb\Œ¨ãùW«ApB±B‹ j0¨£ ~•4å«gUJŠ›´QæÑxQ‘s-ͤDöùŸù]_…<=ý‘g$7‰g<žad•#ù¶žÇ#=s]²VØç•IOFq_|-·á›—¶¶Œjªg„¢€dÀùú† \³ð·VþÙð6™;IæK
}šFîÅ8ÝøŒ ƺºòÿ †².‰ãÏøk8ˆÌníÁïа Á^1ÿ 5Ó~”£ÛPZŮڞ£@¢\Ä 2žjU5]MJ´ ÔÓÁ¨qO
Y±X˜µ~jŽêº‡å_¥E‚Ä™¤Í&i ¤æŒçÔÓ3ïO€þý3ëM!ػ׎½Ï8ò) ðiˆ2,«µÇÐ÷‘ 1»+u¶ äÖUû´¶=ZEĈµ¨÷Qš´,?4f£ÝKš²¬?4f£É£4¬;fŒÓ3FhìÑži¹ pj‹4 Ð$ÍX¶û„úš§š·jß»#¸5pZ“-‹¥Îi´Ö|VÆV ÍŠ‰æÆy¨&›ŸqrFy Úœ‹ïr=k7PºÔ稪’]g½eêWY‘ @ÍcWcС…».Ës»½V2sÖ¨,Äžµ26k†G¢¨ò£J#½i[ÉÒ±á&´ 9Åsɳ–µ4lDùi:Vt$ÕØÍ56y5abÀ§nÀÉHØûž*áÿ å¢Æ?Ù5eŽ:Ó=ëX»t6‹ìŠX#œË$Ž}Í'Ø-Gü±
þñ&®žµVŠ¤»š¦ÈVSîEýPI 2>”ö¨Í>f÷f±ìpy5NcV¤8ªršÖe8¦K©È-ÖÝP4€lBåÅ,¦³nÙãdž1—Œç ¢½Œog+=™Xݵ+[ˆ#/$(êTƒsw’ÇjìÚõ'|M¹O§ò5ÄkJQx`ÀÞT( ‰íù׸µg)Ùø/SÕRÀ¼·ÓMœE ÇÌ
£Œ‚yäûö®ÆßU™Àó"ŒŸbEsZ| 1ƒ … ‡·h½+š®UÞpB±®—A÷1øæ‰æߟ› ¶êª¹c€Iª!ÍÍÃHA ØzÕÉW+ÂB.RVKÍy7ädt4‹+!ÊœŒœ)…¹¯™O–W†‡Bm© ÀHÿ iy •lÙÜÛÏþ®hÛÛ8?•qŒÕ ’×zÔ3ZÑÒjãt=æâÖÝ7\\Áÿ nE_ækÿ ÅLC÷3ý¥»áÿ }t® YH®$‡1©• !±È v„ó ˜ßé•?Qþ5èhóFö±>Á\ß¿×n¯‰HWìО>S–?SÛðªvð`ä Z¯Â'XïP@Ìp¯œÆçÙ» cƶcˆ(äs^V&½Fï&m¤´*\ÛfÃ9Q’=«„ñ¥¾"†éGÍlo¡éúÿ :ô©"/"¬Ã#5Ëx“E¾¸Ò٦r™@„ °9Éée˜Å(òÕ’ùœõ£ÑÌhº¥¼6H GRr<óÖ¯ãj6¶èxÏV>µ•¦øC]š|O¦Ü[Æ:—dö 5u–žÔaEUŠ£ oCý+«‹¥Ê¦¯êL·cm!é[Vôâ ‡HÔ!ê3þòÿ šÐ„OBº7ô5àVŸ7ÂîuE¦Y :-2"§ÐŒU”Zà“&¤o_=¥ÚÄÄùœ0=‰èjÏÄ ¶–Ö`üÒ?˜ßEéúŸÒ¹û™f‚"ðZ½ËàG
ZÅÓç¾»¶ó59n$¸ÞÊ<òK*ƒÂóÎway&Û9¢“Ϋáý®ýJæàŽ"`>ìÀW{X
µû>Š²†¸c'áÐ~ƒõúë‚´LêKšM…QT@W•éQ›¿ŽÚ…ÄC1AŠÌ:d$küÉ …v>$ñ5¾›±Ú:M}Œ*ƒ•Œú±öôïYÿ ´4è.uÐßk½ üÿ {fIÉ÷bIü«Juoæ\W,\Ÿ]ÎE³ óõj5V¤
]
X²
8Zž³hV&
W }ÑQÁ¬àÕ,yoÏÝ=j,43Išfî„t£u &6GQÍ0šBiØi‘H$\Ž½Ç¥+6>•–ƒ•$¯s¨K÷Qø N4® ·4&•"Œ»œÔÖ<²™$gn¬sQI+;fF,}雫HÆƪ6%ÝIº£ÝFjÒ.ê7Ty£4X 3Fi™ ,Q&hÍ34f‹&hÍ0\ÑaͦS…Ù©`“kúÅ@)sMhK4ª9
CûF ‘ëR± 2¤ ¥nÈÙ™÷M‚k&åÍm\¦sÅb_ˆì·sC= 5™JIB‚XáG$Ö4“fg=úARÞÎÒ¶ Âzw?Z¬¢¹*JçµF ªìµ«qvªQu«×,‘s/CÓÞ´!=+:Õ~ÂHáªhÃWb5BW¢• W“‰“u ϶³cOJŒóOjŒÖH"7§jaëR¤o+„K1ì+FÛG'
pßð?ÌÖôéJ¦ÈÑI-Ì…F‘¶Æ¥›Ð š¿o¤;àÜ?–?º¼Ÿð˜íÒÛ €U-Jõmb ÓÀì¾æ½aiÓ5Gq©·¢"¾[[ LFŠ$|ryb?À™ÌŽXñè)ÓHÒ¹y³ ¤Ô,p+šE7î«#®ã Q¦£4ö5jËN–ò9 2ªànþ#éJrvF—QÕ™íL&¶ô9ÝÇÚ #NûNâ~•“w “s4G #ôÏ£§(«´kN¤dì™RST¦5fSÍ]Ñ4WÕÉ+íTà°êçÑÆ·¥Ç)(«³”óïTæ<קêº< ^[i¶È²²02ÎA<’q^kö+¹¦ò¢´¸y3¢&Ïò®ØÁ£(ÔSW9mfÎD/=‘`zº)Áúð¬= 3k–jù9”1϶Oô¯nÐ| $ 6´Î¤ô¶°àL?üë;Æþð¥Ü¶rǧjsö{p\OÁ :ºÜýÿ Ï5ëá± .YœóµýÓ:ÓµmZt·zâ&Õ§EÛlŠŸí8Ü.•}5ÕÞ~Õq,£û¬Çoä8ý+¡Vˆùéš¾µain!–þÒ6só™x·Zf‹{§jwj,õ%’5!ÄRî
ŽYGÓþ½yÆ… Jä®|›d?¼u?Aïü«Ô4‹[{ T¶³‰a…z*÷>¤÷>æ¨T‹RZ2_»±¤-Ü…lÏ G$};U…ÑüÁÿ ?îõè·=+N®%–a—ÙüY~ÖFDþ ½ÚM»Ã7¶â‡õâ¹ÍF;‹9|»¨d…ú€ãú ‡ð¯IŠ\UmVÞ
FÑàº@èy^yVìAìk*™e+^«Ë©åè†IKÖ´-áö¤¶€ànÿ ZЊ<`¦¼*³w²:Õ·BŒŒŽªÈÃXd ¨ªék5—6DÉüû¹éþáíô5©5´–ò˜å 0烑BbêJ›qqœ¤žÄ6³%Â’™ >ò0Ã/ÔU¥ZŽKd‘ƒŒ¤ƒ£¯_þ½I2áf Ì:Æm=bc'u¡"¯=*EZrH¹ÜŽiLj+D®¸uTª´ð•V2u,gMmåò9CëÚ‘¯CÇ¡C`Tô5EWhª6!]ÉY‹Ï ¡§\ZÌE•lpã’¿ãô©A µ2=ÅO;‹¼w2œíª,hž#5[=ÿ NòÚU" ‹vݪ.NAåNNkªžd‚–S¶4cè+™µÜ’$ˆ@e9ô›•þÑÓ%‰p²0è}AÈü+ÛÃbÕuf¬ÿ 1S¨¤ìÌÕ¸Õµ|½“%¦p †]¿Ïù5LJµ+¿–ïYwŒõ]¬3øPÕ5-b;K-/G€Åq!òžå€>_>¸ä“éÇ&®Ç£Üè–’\wQºœ€\\¸tvÿ eOÝü;W_"kVtk ‹z_…´ûIX5Īr¦@6©õ
8údL^$f%A#ÓŠ}JIÛ–¬(P)æÁ©àÕUoz‘ZºÚ:¬Z
Å85V
Í85fÑ6,n÷¥ÝP£u.QØ·ÃGÇUô«)q½ƒèx¬ÍÞô…©r‡)¯½OñΣ’â4 ¸ü9¬¢Ô›½éò¹5Ùqµ2£õ5XµF[Þ“uZE¥b]Ô›½ê-ÔnªHd¥½èÝQn£4ì&Ýͪ-Ô»©Ø,Kºœ
CšPÔX,Mš¨óïFêV(4àj iÀÑ` švj<Òæ‹“4¹À¦RƒE„?4fš
/jv ᘸþuys[oÓ5FåF
&uP™ÍO ªáy[¤5AÆ
a#Þ£>d"
µZ®¸«õƒ4–ÅØzŠ½ ªÕèj8ª¢ü&®DzU5r6¨q<ʱ-°Þœvæ«šž6©6# ²çÞ¸1nwÍ Ï.µgÌŠ-ÖÚØi‰DëÔÿ …Y†8ÐåQAõïVTÔS¨¿xÇÙØ’ÒÙ…_nõ2š…[Öž]kEdfÑ ýÂÚÛ<¬#… ¤ô®BGi س±É'¹ß1ò ù¿<úë šä¯6ß)µéqLcO&Ÿkm%Üâ8FIêOE ¦³Š¹Ô¬–¢YÛ=ÜÁ… ³tWHŠÄ HÐ`ARZZGi Ž1žìÇ« ZÉ¿Y5;·³‰Ê[Gþµ‡ñ Jõ0ñTãæsºžÑÛ¢+j>%†ß+k¹qß;Sóê
ãµ zò{—–X-ù ùœœ×} ‹aÇÙ’Cýé>cúÓ.4]6a‰,`>ê»Oæ+d¹¾#XU§
‘Îh_dÔDÀ•x’6?q¾Ç¡®ªÚë©&Œ¾²·¹[‹nm& ã“p#І#Ú´ÌL sïŒVª_NJf‡›š©©k0iÑ‹ »òÍøz{šÎ¿½6©² O@y îk™¸å‘¤•™Ý¹,Ü“YT>TU:Õ†·âMFü4p¹´·µß‡—4’{³9è›64È’ÖÞ8cåPuþñîOÖµíÛ žÞ½¿:òÍ[ÆÓ Å£Fª½>Ñ2äŸ÷W·ÔþUÈj7—º‹–¿»¸¹'¨’BWþùû£ò¯v4´ÕØâ”Ï£!¿¶WÚnÃzy«ŸçZÐKò†^WûÑù×ÉfÒ cÉ‹ ›YÓ¯ot™Dš]ÝÍ›ŽGÙä(? )üA=Œ^ÌÏÚÉt>µI¨iøë^YðïâÖ$LÖŠ&¦F!@U¹Çb:+ûlt¯@3{Ö3ƒƒ³5Œ”•ÐË»HÞf‘Æc–È'Ö¦µ²Ž)I y U¤›Þ«jÝž‘¦=æ¥p°[Çò–<–=•@å˜ö¸¾¡FSçåÔÕÕ’Z½
MO÷÷äUEZó}#â\ú׌l,…¬vºLîaþiK;Y›8 €6ŒõêkÓ•kÀÏ(JŽ"ïí+“
ªK@U§ì 6°wªµ*-xnDJv!E0ú´™_ñ«J2})UiDeX˜ûõ^ß…C’f2Ç*æ¤T& þª³ }8©Pr9Û!
nrMeã~ìäg=
]Ôô3~é"ßÞÛºr¢7üŽk:çO×ì˜"´Ô”w\Å'ýóÐþ»á„æK’JþzSµ·9‰õ}CFÕ%¶š_¶B‡ J0ÅO#æ ç]~oª[‰Xðpèßy¡ç¤·êIx†;‚~hÙJ•ì
;IÔ.4»Å¹µ#wFFû®¾‡ü{W½‰Êc^’’INÝ6fӧ̴ÜõècÇõ£k”pËô>õ‘áýN×Wµó•âHÛïF}þ½
nÄ•ãÒ¡*r´•š8Ýâõ9&ÿ AñUÌ:”®¶W%¤‰ùA8 ç·p
éàÒ•ÖBÍ( Œ‘þ½SÔ KÕ¯fÑ®$ m…C…èàœ¯¯¸¬[?µxkWŠÞID–S0:`œn±¯OÞ†ŒïO_©ÛÑEÉ
ò¥lÓÃUUj5w4v–CSƒU`ÔàÕ
ÅæÕê7R°XŸw½ª
üѾ‹bmÔ›ª Ô…ª’DÄÒn¨wP[µ;‰wQº¢Íª’ ‰CRæ¡—u;‰ƒsSÛA%ÃísŽ¬z
ŠÊºœ 8QË A]H±F1µG@*dùH”¬U‡MŒ ÊìçÐp*qcl?å—þèÔÈè ®ÌÛ¦äÕ<Ô÷-ɪ½ëšg¿B:-XŒò*²ÔњɣibíWajψÕÈMMŽJ¨ÑˆÕ˜Ú©DjÔf“GŸR%ØÛ5aOJ>Õa5”‘Å8–ѪUoz¬¦¤²håœK ÓƒñÍW
NÍEÎy!o`[«s ªÞ†¹«›Y r²FÞÄ ƒô5ÓÅA}yöKc ˜ð«ž¦±•57¦â„œ]‘k¥ÜNApaûÌ9üoÛ[ÇkŽÂõ$õcêkšYu©³42ÌGm¡@?@kWK¸¸¼±-r ur‡hÆqŽ£Ö·£‡ÖÉ•V’Õšdô¬ ä–ulîo›ž§çùÒÍx¶—ðÛÈH £g‚sŒ CR][ï&H‰Wÿ õëd”t¾æj<ªÏf\'5J̆ætš0Î] Á
Íh“Í'x;2'Mو«ÝÈ ä<àp=MX'5™¬“²$ìI'ðÿ õÓ^X6])sI#MÎìÌrÌrOFSÚ¬•æšV¼ÞcÔS±XƪWhÛ„Pnÿ Ý µ¦ÿ *“ŒûzÔQA°lc–?Òµ„í«/šæjY¬1ì@p9Éê}Íq?&Ú¶¶+ü_¿}8_×'ð¯Ie¯.ñr}«Äw–6¯ÑGø“^®TÝJÜϦ¦Uþ •íM1VÉ´ã¥Bö¤v¯£ç8ù †‹Ú xý«ZHíÅVxý«HÔ"P3
°(Y †S†SÔ{yÔW»x/Ä/®è\ÎWí‘“
À^…Çñc¶á†Ç½yv*aã%†@ôÑ|4¬õḆÙ4+*t8ÏäÀ~ršœZìL`âîz£Íï^;ñBî[¿}¥g‚Ö™á .qêFÚôén™Ø*(%‰ìS^/¨ÜGT»½aƒq!Eè£þù¦“µÙUÕŠ‰"u’¶hØIz:œ©üôÖ‰ ¯¤Yê1 -ÔK.?ºHä pr+犽SàÞ«û»fåK\ÛgÐÿ ¬_Ï
ÿ >•äg”}½u¼uùu%G•\ôµZ™V‘V¥Qž•ð͘ÊBªçŠž8ýª «›m>ÒK«éÒ xñ¹ÜàN ÷$ îhѵ?T‘£³Ÿt«É”«cÔÔV´ðó”yí¡*œç4®‘tBs¹8ÐýjÔ*t Ž õ,qÔ ËÇú jì§G©Æ¤u:ÅíRD¹ Œ â§T®êt„d뎳oå_C¸òJ¼:}ôé^;â
}T–ÎàîÚ7G&0$Cчò#±ïª•ÎøïDƒRÓâE&K6Þ1Á(xe>Ýá^– «¢Ÿ7Âtaäù”;ž/gu=ÊÏi;Á:ôxÎÿ _èjÓü[ñ žd´¹°Ó'ËqµÓ#±Ø2 â» kX¢Š$EöQPMá½&òàÏy§ÛÜLz¼«¸þµšÍ(Ô•çØ©—_v™ÂJMNc©ä{‰ Ìi ëþ öí]-¿Š§º{8õ¢eŽçÛNáߧjهš2nòtè`ÝÔÔÏäjŽ£àÆÚ_NŸqÿ žSqù0þ¢º7
]rÉXÆXyCcÓôÍNÏSƒÎ°¹Žxû”9#ØŽ£ñ«y¯ŸH»Òï‰{K¸û‚U‡â:ÌWU¤|BÔT&£w±ã »“ôàþBœðn׃¹ÊâÑëµÌi~6Ñ/ö«Ü›IOð\Ÿø÷Cù×F’,ˆ 6 ‡£)ÈüÅrÊŽèG†§†ªÛ©Á½ë½£Ðh²Ž´íõX?(z—X³ºÕúÒ°ìOºÕú7ÑÊ;n÷£½Cº“uRC±6ú7{Ô;‡‡;‰·{ѻޡÝFïz,;î£wÖ¡ÝJ[å>¸§aXé´ˆ„vjÄ|Ò|ÇéÛüûÕìÔ0`CŽÈ?•I\ïs™—4ÌÑš›‰§QƒRÅÉÊŒS@ˆ/#ómÝ‹_¨¬Þ•×%¢ÿ ŸÀV$šRe¶JÀäã U "¡%³+[Ê
í'‘Ò¬Tî-e·eÊyzõ©‹3Ç¥¯ª.Åöp‹“UKbOSQ$ç$šPj’°X“4¹¨Á¥Í tÜUÉŽk:í¸52:°ÊìÌœóUóÅI1æ¢ÍsH÷éh‰ÔÑõ¨ÔñsYš2ÜUn#U!«Qu¥c–¡v*²†ªÅÒ¯C 0ùE
5,‰c5aM1!Q“S,\|§ð5›Gì=
H¡‘Šx5Œ¢rÌ“4àÕ4 Ö2G4‰wU[¨¾Ñ4Jßqy56iÈ»òßíïE/‹Mìg°ìŒ p¥Io" £àdç5\‡H¦ƒÍL%:2æ±:”µ
{›´–K¡$jF®\ç qZ†\ö¨·x8úSKVÞÖ›wQ ª7k†$3AïSg34Í''7va99;±ùæ¨êhYcoBE\¦È‚D(ÙÁô§:nph!.Y\Ä)HV®Ü"#lNqÔŸZ®ë…?¥yr÷]ŽøÔ¹Wfçö^ŸZRµ8M£ ƞЬ,>µæ×–æKÛ—#–•Ïþ,‰'PÒ t=? ô¸øãç¥z÷Åý]iöº°„éé亨ÇîIãþù?¡5æ6Ðdò*iWXsD©Sq~ñVäõÍjé~}ìv²âFØﱃìMMmmíZ0Úôâ›×F+ ¹áíVßZÓÖâßåq,Dóz oCÜVÌI^9§ý¢ÆužÎY ˜q½8ô>£ØÖéñ.ºW xªqŒ¬ Ÿå_3_!“©zMrùô9eAßF\øÃ2›-&Å[÷¦ãí, ÿ ©Pï¦ãèk™†imîh$hæ·#¯U>µ ÊÍs{ö›·{‰™Ã;Jr[ µk•Ó/A
Oœœ Гý+²tVœ)okŸG“.JrM] á]Z=sLK”Ú³/Éç¥mNvnÇJ‡?ã-SEPÖW1G}ȉ_kCžìÑô¯<"»eøSo÷ãÖ/Ùݽ¢CÏ©ïúÖF»á]SC„ÍsåÝZ/Þº„ýõ<¯×‘ô¯{ *0\•Î)JïSŸ#ŠšÎòêÁ÷ØÜÏlÝtåGåÐþTÖÂ+¹«î#su85W
Í85s´z,¥ÝP£uM‚Åônªû©wQÊ'ßFúƒu.ê\¡bmôo¨wÑ¿4ìÛèÝPî¥ÝNÀJ—uCš\Ñ`&ÝKžÕjPh° ŽŸ(šÊ Ôõ Uœ×= ^v¶s€çr}{ŠÞ¹¥™Í(ÙÍ;ç½DÎÌ3ÔÌ—®j1É©¥ šŒ)®i#݃ÐrjÄb£E«1¯N+"›'ˆbÅÒ ‰jÜkLå©$]³ä}+AE
á@ ©Ôb‹ eIÝ^¢¦Zˆ
•jZ9ä=—p÷¨jqPÉÚÎQ9fÀ ˜ niOsÎ&
ŽÍ7'4CëX4dÙ"Í `2[¶ÓÎi׊]£®9 • rÉï)Š–êG_Σ$“’I'œžõ§=á˸!✠±âž# ù¥N
È…-L¨?º)ÞZžƒÓLÉAùTžàT…
õ棘~ï òjªþè$g²äóLÙ–úU¢µ\Œ÷<×Îsu7S e¦•«‘Bd|t ê) ÀzÖ¼’QS{2ÔÊ¥jŽ¡`D©.8•sô?þ¬V²F]ÂþunhÖXö‘î=«ÚÉ“ŒÝG¶Æ©ÜäÚÓŽ•R{\gŠåþ#øãPÒuÇÓ´l‹ks4Ñy›œ€J‘€=É=1]¦—3êZ4 n㙢?ÀYrG5õ®›QR!M9rœõÕ¾3ÅcÝCµ²8"ºùí$™öÃ;z(Í\Ó|3M¨í”ŽD#•ÿ zý:W4êF³UÎg¾mjhïuu'MC”ˆŒ} ÿ ñ ¾½:g>¨˜ c t¨íÒ¥±Íyµñ÷¤ô67²$uIbhæE’&Ydzƒ^-âO ¶ªùQ†k) ky<pŸï/ê0}kØÛ÷ˆúV~§cý«Át¥Ñ¹ ò§± õÍK19m¡¯Õe%¹åV¶ùÇ«omÓŠ»q£Í§Í¶A¾"~YCõô5rÒÜ q^å9Ƣ拺9%fTŽÓÚ¥û *ö£sg£é²ßjS-bÆæ ’I8 É$öhžâw¤Ìe‰_ËpÈQ‘±œ2žG ûÖÜ—šÚó+òõ2¦¶ÛÎ*ÊŽÀt «¢»Œ3áF{ wªsØlºqì¸ÜçþÛñÅ|î#ªÕ|»#êpT)%-Þ¦eµàò
¥æZÔô=L'ûËýGq]ƒ–Òïu;4º°'·ºèxú CìjòŠùŸGÖ/ôiÌúeÜ–îy`§å÷”ðz/ü$ºµþ›]Ü¢‡Œ0§—»#ž{V³ÅB”nÑòøŒŠ9û’N?‰êʼæ±üK£G©ÚyŠƒíQ
ÈÝÈêW>õƒµäÕ¬cIÈŽéF0ÇU NÕµ¨_A§ÀÒNã?ÂØú]éRE¶ôhÿ .ßj‘É9_cB ¤à2çê*¯ˆ´}{I’ÆêI£Vù•âr¥Xt$taìx«°ÙÛ:!„©ä¢¬Gl‘ÿ ªÜŸî“Ë¥tÓæNèâœï±ó¦³¥ßxoS’Âù2WæF vEìËþ ë n²—¯¡ë^ëã
'ˆôV…@ÐæKifþéönŸ‘í^å²1VRŽ¤†SÕHàƒî
{”j{HÝîiN|èÖÝN
U÷óNÝEVÅ€Ô»ª Ô»©X,N—}@¢Áb}Ôn¨wQº•‚ÄÛ©CT;¸ëKº‹‰wRî¨sKº‚ÄÙ£uD©¥Íb`Ô»ªÔàÔXV&
ƒÇVþ¬+ áÚÃ'cõô>õÍîõ§†©”9‰”nwJÁ”2Tô#iè~eÏLŠâ!¸–˜exÏû'hj·»H
õÚ?±tY“¤ÏF=ê´÷J™ †ÐVMµã^ZÅ+9mÃOCÜT¾õÏÉmÌ9m¹!bI$äš\Ó3éKš¢‡ƒN‘QçÒ™s0‚ÞIOðŒ¯j,¹ÏÌGŸ&ó¤
ëÖž
u¥ÍD)A¤!_¥Sœfž•.j^¦ô¥ÊÌ׋&…‡ž•¡å Ó–*ÅÀïŽ*Å%†¬G 5ab©’>EgÈ7‹C"¥ZŽ>:S‘*tP)ò ³Äܹʃê*`µ
»òžªÈrœR©¨N
QY¸‰Îã‡J‚C—8íRHÛTzš€–Œ$ÇgŠ\ÓE:¹ç&b—£½sI3 ´mÏ êLSã_›4F:‰‚®)Øæžž×\#bZxZ-<%tF&l‹o¨ª×@íŒÕð§¿JŽhòß…a˜Ç÷
Ì·C¯Òµ}âä~uE_4é´+Œ‰1 ךŠh bW5wnAQ°¯©x:s£rèuE\ª±„ OzCR¿µDÕ´)ÆœTc±Ñpú¯€íu=rK«§Sk,¦Y™ùÉO¡èO¥v.‘·T\zcO'ŠD¤ô»TñµOáPâÞåÜ‚0ÎÀ É
ŸZ±ol°§ÝÏ_ð§´_Þ!G¿_ʼÊóçv[%©A’¡uõX—³¹ÿ ¾EDî£îÁú‚k•ÄÞ5_DeË`T¨ õuªFÆ$l ÛíÔVÌŽ æ(¿ïœSZÔmó&>Jz’~ƒU*µ);Ó•‹“„´¨Ž#âŒúß„îl‘žå$ŽxÐ —(Ù*=ÈÍs¿
ô©´»DLÏ ´ð¦ð’ÊÇØáå^¥$â0VÕ|±ÝÏÞ?j¥$x„÷¤bÇß <×l³j²£*SÖÿ "#ƒ‡:šV*M&Å"Õ õaËŸÇü+â.NyÍm:Õ+ˆºâ¼¸Tw=ªVŽÇ?q^8¤¼XquÄmoé^…*†²{2œi¤Íò™.í˜÷l:þœ×Ykµ”Q£¬ˆQWzôaÜŠà˜m85×øFàI`ð±¡~þ‡‘úæ–&-Ç™t# F÷¹Ñ½1ÁíŽÕ0×{‰,þ_ŽIç¦i!0\\Â}ASüÿ ¥q.Ç•Q«—mðêt5z%ªQ*\ÿ œ cëøÖ”#5¼QÁRCc_&ägý\§¯£õÿ jFž½*·”²FQÆA©íY‘„S ¿ð·÷Çøú×DQÁRAöC/hÞY=PýÃøvü*ż۟d¨c—û§œûƒÞ¦QNx’DÚã#ù}+®7º9å+î<.x·Åmû;Äl‰qú™0A€ÿ Ÿó¯g|d,‡röèƸŒOö-¤3G(˜Ì Bå22 ìv’G®+Ñ¡M954xþì•ÏE8÷§ÅŒdòÞµ(jéå>…²/*OOÖ˜IS‚úÕ hl0Á Š\¢¹[u.êlɳ‘’¿Ê£ÝRÑIî÷£uB
(jV £uEšP SÅ ±.ê–8å”e#v qZV)
0
'¡ä
½œ÷¨s!˱„ñK /¨÷ÀÙ®‹$*¥Õ’L @_QÀ?ZÄ¥ÜÊÝšPj#¹ • 4»ªìY0aN
QN=((jp54ðy¢Â5´}Cì’—>Cœœ õÿ éу(*AR29¸QW,林ȉþSÕ‘XΟ6¨Îp¾¨ì¥Î+-tc÷¶üú£ÿ +ëƒ »·9ÿ m¿Â²öR2äfá`$€$žÕªßý¥Äq©Sœÿ xúý*Õô÷\Jÿ '÷Pi
|º²ã jÉ©5©ëTÆǃNÑOQRØ…¥Å S±Rà¼Ð:Ó…&Æ®9EH£ÁR)楰w&J•j©”Ô²Y"Šž9ëȨTÓé\É“‰G¡ Êz(ǹ¨iE.¤1Ä’y R($àU„ˆÏ5%‘cŒÒŠ›bžØúSJ8®y’И§(æ€)àq\ÒDX@*X—"
š4ç'ŠQ½É°ªµ ZF=éâ:ëŠ3‘CéN íRªÓö×L ÙÊFLÔûiTH¥‹‡=+ÊmDÑV‰Ž˜±üàúW‘ 3œÔWQ-Ê&ÞF .¿ÚÊ: ÕaQ_K죱ÕbK!Ã) Z®â·ÝC 0È=f]ÛyGrò‡ô¬§IQÑ _B”qï~~èëS‘ŒT‘¦ØÇ©äÓ\RŒlw j»¥Ûù’4¤|©ÀúÕVZèmü‹d¸ ýkŸ+F˨N\ªÄ ¸éP²UçJּnjÊN”Å¥?(À Xô¡ä*Óð;(êjµÄ Û¨:(éR⺚ƣzD®Í êG™'÷Û ú
£6é³’O©«nµg-Nši-z”ü£$ª‰ÕŽ*+Í1 ÷l_ ÿ &´Bù0O8*žÃ»V{¦+9-Šræ•ûäZ¯"f®ºÕw…¬vÆF\°pŠ2Ìp6ÙUÍô ÌfÕÕO©9üOôË·/ÿ -$/²÷?OΪéèÔÇÒ ?•uR•´*Ræ‹}ÉNè´º’×ÎòÎ ±”üzƒøVg ÓµPqƒÒ½JèîiMYž£¥\¥íœ7ýÙ$z ãóBcÊýå!—ê+ÎÕžµÙJŒ!ï%©*6dLj'8§¹ª²ÉŒó[›F#Ù½é‡RÈ#©ÉpëL#<š,l É m%On*&Á¦Op7^ R½a%ch¦YÓâó¯a\q»'ðæº7_jç´û³Ï¼!‘ÈÚ«œrk§ ”€ÝŽ@éšàÄŶŽzÍ© ài¬^'è¿ýz´Ã :úÕgZåjÄÅܧ(,K1É=껯yÖ«ºÖ2GT$Ru¦$A²ÒdF¿xúûz´È d/ê~•ä¶ QÑGoþ½C]MÔ›ÑîXË!b0:è=*¤‹Wd^AXËS®›²²)8¨DAß v vôjAQMòÇ°u'/ýáüë;u:yžÈ£rÞlŒÌ0:è;
†%Ùìž” V U‰ZŽàm°
2¾ïÁx ®*PzÜèû*(æî úVUÂàæ·®e\¦ÉÀ¯BŒŽø2Ƈ`o,u‡ –ŠÛ)þþrþ;ú×£èÖ‹§é–¶£‰ o¯SúÖg„tã§èéæŒM9ó\ Ùè?*ÛÍu´¤¬Ï›ÇbI¸ÅèŸüäRÇ•V` N2}ª?F&ðÖ©õC%¬Š tÎ þ†¸?ˆ7„OclŒÃfg;NláN{ ´í_Ä'Vð]°wÛ¨%ÚÇ&Î Ú¥·b?REB¤£$Сƒ©%N¢êþã•{]Ïû›ˆ&\d•b6R *ÊZý¤y ’è0Ùî½›üGãV£°ò"H1ó·Í)÷ì¿Aüþ•«elbe`:z÷ö¬jâ4=÷QÚé”m¬³ÔsëZpÚ…Áè}ª÷Ù‚(ÆííøTñD\Jóå9Iêa*÷WEkhÖ9QÚ4ueAwâºÑ´¹Àced\*K1lÜtG÷ç5 ˜P€ ì;W§ƒR„t–‡…©í$´³zNUeÌ‘¨Â¡qXïNßu"Aï“U.o¦œáÜ‘è8 •sº/©q¥.¦Ûa†AzŠÅe}¶à ¤Ð )>Ù?üôÏÔ
ÍÐ}Í’hºàžOZ‚AP5äÍÜ ¨ZY«Ïêò}Mc4‡ËÖ«·&ŒRT¨Ejõ/Ú¾…yVqWd^3UdæÎ.ÌôéMKb£!f
8$ã>•Ës·! Ú¿AþZ· À`:°ÇÐzUIdôÐ駫¹Î¾£i6«q§#¿Û
8Á¡ê+[@Ñþ×p.ný 6ʃÿ -AUô} MãmNiÑÖ6±¶r1Ùyÿ eܲ*¢"
ª 1í^·²Œl㵓9qXþXºpÜmMe’-D[3ùˆè]I긫•QgŒô8? B§ }é%\çûª¸ ~$±üªž‹fÂW\ˆÆü ät ž+{ÅÖÆ]BÒLuŒ¯äúôÛ(6[· ³ùdÖ8Šüº#épÓÿ eŠ¸°[á#-ËÙ>§5zrTçø¢ýÜSý*í¼x‘ Çó¯>ÎNìÎ¥]°DÞ6û¬ß/³gð©â[€J°=üjQ øþ#üê畽VLrÜ7×Ö·Œ>ulôe4„†ç‚åWéR¬Y=ºTÃèk·
trV›•®x$7Ì¿ÊÇó ‚¨B ª2IÀØXÛ¼ óŽ§Ô÷5QW0©.QÖ–pÛݨÝÝ&®LAS(69¸mÈÁ †©]i©&Zúã±ÿ
Ð Râ“I‚m Ã!RUuݼVÆ«n0&QÏFþ†²È®yFÌꌹ•ÈvÑO"Ô2„ðj<Ñžk)
"LÖŽ›8(b'‘ÈúVQj@åX2œÈ5š—+¹NV:¦T`ÔQ†&ù[ûÀp§ÆÃ+"þðT“ØË•¢Bi©f (&«KyyÝ 'Ñy5•wz× (ÊÇéÜýh”’F‘¦äÇÍ73¿Lžµ*µSV©Q¹®k\èjÚ‘ªtj¤S£Qc&‹ªõ;Ôeê9M#?Znꈽ75J%UýêTz¥¾¥Gªå!—£j±É u5B6«vûèþ´rÍÈÈU t Tª²ž*@ÜU´ek“n÷ µEš T´U‘&ïzŽoš6 Ç"šM4·&®*oô£}VßÅñÞ°å4h¶ ž$5H==^š‰-ÖJ•$¬õSR,”Ò3q4´ï7Þ¨ )|Ê´ˆä.4žõ’uªí-A$ÞõEÆçV]ÔŠ3O¸Ÿc^Üõæ‘ÙJ›d7²ŒÁ¼”f¦½¹Îy¬™ä,hG«J•ˆglš¨ã5`®i¬œV¨èzdZ‡o¥[sŠDqS!½Ø±V®Û@œñÍrvÖä •ÒèêQ—5]QÁˆ³G¢é’eEk!éXC|«[Ñr¢¼Êš3Á«¹%Š8¬\ŽvĬ
kÄÖÚîíö]Ï’
¬œ'Ôÿ …?ZšKÖñ9Xº1^¯íô®rm=c ,1¶;¸Ýút¬£^
Ùž¾/R´ë}ßæ\°ñ¤žxöÈ!'—‡9AëƒÖ»xʺ+£Fƒ„ õå’BÙ;ííö¼Á6=ˆÿ &¥][]ŠÊ;M:çìðÄ6£™ Û–ëü«~ESX³£–Æ¥Dï|G¯éþ ³3_Ì¢B¤Ån§÷“ÙGõ<
ðŸk×¾$½K@D`¤H‹…IÎÑž§ß½uz>‡c¨k-ˆÞú[›¶ \™È`ÙÎ=
žžÙâ»-_@ð—†t+‰îôÔdaåÌ^iXÿ ±9úŒ`dñŠì¡*Xv’»“ò3¦©`&¢âå7÷|Ó´ËJäÁe M"ÏÙc Þv< ÷?E} pLc‚u¸ÀÍ@B3wÛžJŽÄã=qŒWAë÷•¨²†ÞÛNÒ•·-¢íŒ‘ÝÏW?^=³Í`ìÉ,{ôÏ¥zJzj{Ôå¬Õ¼¿¯ëÔ¨cÚPSü©¥6 Û•[‘>dúÿ JœXÌö2]ªn·ŽU…Ø íf\ŒŽÀà€}xªR¹m%¹V;x%ƒ xŠçv6Ê1/³ÿ úðx毅µ¹„Ò/N mþ^ƒÓ§¯bj–„Ýô®— +¼ðô‚Z}-›2[ÿ wý¨ý·Cõæ››·»¹ÏYTŒy©êüÈ,~ x’æà/Ø~Îcù„“NŠû,AúWe¤i?4¦dÚuìIÒ;»3 FÀlû’kЬ.-¹³•e·•C¤‹Ñÿ =*Æêâ–&RÒqGÏÕÇT¨Ú’_q¥Üj’¡µ…µ«Ž† ¯5OàTúÕüÒ3Te¹¬$îïk ›“ZZf¨Ö¤G(ß·Uúzý+ 5H
M“Ü •™Òø…–K yc`ÈÏÁ¯°¥K—ÏnÇ11 ÷Xw4íØTââ¬Ï 5"Šh Ô¨+Ùg¶Hƒš³¨PUˆÇ5œ„O©Ñj8ÅXE¬˜‡*Òíâž«‘OÛSqLe«iŒ´\EF Ôl9«L¼Ô,µW\Ž(ǵI¶“\b(©R(©R¸‰¬Æ9
MÉeˆ‰Ç×Ò»ßÈ.-Á 9ùHôõüë‚Žºí F†ÎÝ£?À ¹©=N*6’¢gõ¬ÜKD¬ôÂüT%é…érš"bÔª
Ôæ©Dl²¥FªjÕ2µ;˨Õj'Áu5
µ¬Žl ÷ëùUøí# Y.GЇ%±¥†PAàŒÔ Õ{XÕfòmÜâ¬Ý )2¢®ÈwsFî*64ÜÖ|¦Œ˜5=Z«n§«S±,´Š=VV§†¥blXßIæT%©¥¨‰#ÉïU&—Þ–GªSÈpy¢æôéêAu?‰{19æ®Ü¹9¬©Ôš›ž•$P˜–& Ù“WZ,ž”‹µR:\Ò*¬U ©ŠÒ1àU;•Åh™Ÿ5Ì×_šYÁ¸Ž*0™ZØÓmÉ#Š¶É©+"Í¥Ÿ +^ÎÛc*Õ•¨Ú88m€#ŠÂR<ªÕKšbíÅoÃÒ²ìâÛŽ+ZÀÅPò«J䘦‘œƒOÅ:428¹¤s'wc2x#çdx÷ɪoj[= êIì+£kl *‚ǽV¹„•Ø§>þ¦¸åNúžÕ*ü¾ìNVúÍ[(v?ÌÖ-æš Ý”2ÑñÛ«ëõÚ]ÁûÇãŒÖ|°€ñdt9?‰ÿ
!VTäzë^*Ç̲¤pd5 Þ# •Eñ^m[>Y?b¶! ™ˆßêO AïZÚÔk`<òÎ…H
ÉÙíŒ×W z×µ…’šç;ãJ5**m·ÌªS'àuÿ
Óðæž·úÕ¼SÇ´y¸¸?ÝŠ?™³õáàUW`U$ ä“ü뼇GmáÆ«{v…/u4H‘†Ž'` >ç%ÔÕÙÏb1U((äì¾äyÍõõà F–C!E ¸“´{ ãðÿ ÉÕeÒïãËV‹ìr²ü˜Ûêÿ B2ä~ þ´„:Ñ ²© ‡Ñ‡ þ`UsÜÖ/iëȯuk$Ímp14NÑH:|ÊpQUöœínO¯zw‹ü>úõµ–¿¢Àdšî(ÞxS ±#‡ïØýí^s$Yàä}9ª3¹Ž ² Öèì¾k3Ûêm¤ÈwZÜ’0X.AÉ#=˜u¸Ïz¡zùêÒAÜ2ᢑ_÷m†àç*ONÞµî‘jv×v÷PIæÇp¡£
>gÏ·óô¬«¤½ãÆÍ0üµHËÌÕ¿5_θnL(ƒÐ¾OéHÌÛwŽÆ¹\“<Õ ù©Õª„oïV‘ø§´Ošp5êx5B<\/5*-H#äÓÕ1^³gª"-YzS*ÌiŠÎL.>5éViˆ½*Â/‹bVŸ¶œ«R¨lD;iŒµd¯Â´\
Œ•\e¨™j“™Z@µa–§²±–îM¨0£ï9è)§}]-YD-=@õ uVÚU´*2‚WîÏÏéÒ¯,he~͘ºélŽ5L¢ºylm¦ûð¨?ÞQ´þ•“}¦½°2FKÅÜ÷_¯øÔJ-5´*%tÚ<ì#å2†¹• *ì[MµÎ"~ ô=:r³"¬nŽ”x8éÅAšvêé8Ù0jvêƒu½ê‘-î®{SœIy)€v¯ê7¢Ö‚<ÖáG§½s'½L»Ò‡VLÒsQ3õ¨šJ…äÍEÒ$wæ wæ˜òTô¬RD¬üÔlõ =F^§”Ѧ–÷¨KSwÒå*Äû¨
š€=(n(°2Ê5kiЀ¢W 1åAì+Ý|É£Oï k¡CéUÜÊ£è[CVÕ45f3C1-¡«QÊÁvŸ™}
RCÈ«k6,Â&ÁSƒÓš®†>UüÍ:åwBÞ£š¢k)6™¤,ÇM+É÷ ‚ª±ëš•Bæ¤Õ;±¦næ•5<ÕXæœPçšp4X *Õ <Õu5 <Ô´%&˜M¤nEfÙiÊxªSsW$^E©:a¡™*æªÉjÉ ¨ª²'¥4t)™Í 7g
¸ëíVtû`ìeaž½ip”ì®ÊÐéå—tĨ=uüiím
}Ø“ëŒÖ£WtÉ®ˆ« þѲ’[Fçæ{¨+M.#ƒØ};QmXVÝœxÅW1«Q¥¡ µ¹ŒíuÁ© @Ô¢ 1=ÇJšÝx®Z‘±çT©rHbéWx›â¦Q\ÒW8§!«zT{îX î?1UØU)YµU Îìzc?Ò°p»±‹•µ4$€(½ Ê»¿ x: =à½Ô–ñFáT½}È †kÔ…¨ÁG±õ1tðRªï.Æg‚üCèëQãi
£ýC8ýBþ'ÐoüEµ{Ï
]íe·/žêœ=úWHZ²|P¾w†õX‡Vµûæ¥Tr’lù•«_
Ó{5òÔð¹“
}¿ÆŸ0>õfUÊ7¦3Md®•#îylz¿‚OüR@'%`
}ˆ'ŠËñ¯ƒïškÍ5DWïó2ˆå=ϳ ^ž¾µoÁ%¢ðÅ |伌3è\â´üMªÛél.DŸ¾ß´¢ç‘ŽçK™¦Ú>6U'C)S}Yâ¶W“4WPK«Õ]pGô?…u
µ8๸²¸™Ëƒ°9-üJNx8îs[ѺôÓ=ôy·+´&~èìõïšä|Eák9–%Ô9#z¯Ï ?.@ëõ ¥iN´j«3×XªxÈ:U=ÖÏQfëè:ÒFFÛœ¯”[žÇãÜ~•£svÒ'—ˆÑ3’¨¸É÷õ¬¥™äJŒã.Y!\± ØïYÛ¹©‘©P±¤³
™_=
c™Jž¼U‹yóŽj‘‹GåriË]òyéJ!ç5è¹ ÜÅUš¥L"ö©?jÎR)1‘§µXE§G L©íX¹ÆªÓÂÔŠžÔð•<¹ÃMd«[)¥h¸\¤ÉQ²UÖJ‰×Ši…ÊÑ@ÓL‘ ù˜àWSon–ð¬QŒ*þ§Ö³tHƒ];ž¨œ~&¶öŒWE%¥ÎzÒÖÄ;y¥Å<Š1Š¶b ¥À<‘F)hÎjvÂÖç?vÿ 2û{U`ko]@Öaû£Œ~Me(ÙP|Ñ4¬u)-”#2!ÑIÁ CZ‘ê–Ž?Öl>Ž1\¹lS ã½i4D©© sjª2n#üjÖ·Œ[)cýæð®q¤¦=ëNvJ¢“.KròÈ^F,ç©5KU ”Æ–K-/½FÒÕc%FÒS°ìNÒTLüÔ&JŒ½)D™ž˜Z¢-ïM-JÅX”¾h
Pn£u>êPÕ cÖœ4¬Žšßé‘çßùVêšæ-äòåG Tƒ]n ƒÈ>´#‹RâœUˆÚ©¡«µLŒ™y
NTãj™Z³d$oÝ>zm5»Šžî]°•îÜU ùⱞæÐ{5BƆj‰š„Dv¥‚˜ç¢÷'úScS,ª£ñ>Õ¢0 cŠR¶‚GiÑA>§“S‚:`TY§Š»#;Žhcr QÅ6; œæ!¹?¾xëW´ëo´9/þO>çÒ· ¡@qŒv¥ì¹·%ÖäÑé<~ònÙ_ñ¥}$cä˜ÿ À–µÝ69 &* 8V–÷9›»9`‘~_ï/"©:WdËAäÂÕ,¼ƒæD?tÇþéÿ
ç©O—TtÒ¯}‰"uÍV‘:Ö‹ÇŸWt¬îu)Í ZÔ¶ˆ%¼c ³ùÕWÚµ"]С ÔVÔõb©-
Ε—Í_1ûSD\ôÑ—0ËXyé[©ŒU[xù;tÀ¦rÕ‘nÒž)Ñ-;”ÖU‡™4cRÅF•%s8œÒ³šh‘£•Ü6’:ãÒœj&ëYI=HÉæ’”ši`+žQ Èø¢òëTÔEÓYYëÜÙGÇ~=« ÔÞäÚ²X€.$ùC±ÀŒwoð÷¨4{4«rüÒ?2Jz¹ÿ j# ]Nì$¡‡^ÚZË¢ýY6‡£ÙèðâÝCLÊIWç?€ÏôC/½Qi©†Zj-»³ Êudç7vË-WÄ‘¼l~WR§èF*»KïQ<žõ´`\#gsËïôùlœÁp»\&G¸äúUa| ¥‰ìI®¯Å‘n½ŽL}ø¶þDÿ eè¶Í%í«'HÙ]ŽzßüúÕu±÷q<ÔYv:í"IF²æWvzôïWüW§Å©Ahò;¯–Ä©\w õA¤çk_>ý =ü«V”ª¯>~ìÍ·Ž;xV8Fzõ>æ’Fô5š=iOz—m
ög7¯hF[Á¨iŒ‘Ý«(Ü+7¨ô>½]Óõ'¹B—P½½Ú}øØ` u=Çò«Ó7z¡,݉¥Îíi ð›œTg‹b^jÌRƒXfãK
Ö;Õ!Ζ†ÄÍ‘E³üø¬öºpM-¼ùqÍhŽÂÃÌ Ôy Õ¨a¤òkiHJfp‹Úž±Uï&”CíY9¤TXêEJ²"Å8GY9˜€%.ÚŸe)\9ˆvÓ
Õ‚´ÖI…Ê̹¨™*Ë
ª“ 1gCÀžU=Ó?‘ÿ ëÖ»
À¶—ì÷ '`y £½t )HÈ#¸®šNêÆ7¸ÌRq¦“Z¢4”M&ªÂ3õ× `Gvuù×6[Þ´5û±-À…V.¤{½c³ÖRÖGU5h’»ñP³ûÔnõ =RF–&i*6’ i=ê7’´Hv'i*3!õ¨ •IVX²d÷¦÷ªí'Òš_éNñ9ziz€µ!j,2bÞôÝÞõñë@j,&ÝI»Þ¢ÝJ‹ ›u87¨§¥aX²¦µ4ÛÀ˜ŠS…þ=½«Z¥F©z(ÝjuˆÕa‘\͵䰮²¿ÝnE_‹T?Åü¥´`àѼR´ËnsüëûIÏÜE äæ˜nF˱'Þ³lJ Í® ²n=:è)7Õ%“ó§‰+;bÉ|Ôeª-ù¤ÝM"‹úxϘßAW*–šß,‹ßƒW€Íl–†2z€©š«RÄ¿:ç¦Gó¤É½Ž‚Î!
º ì2~§ZQM É©V¯k ·"¸_º
ˆ
±8ùT{ÔakžoSH½m¨§„MÆÝb¤ÛÍg¸ÔŽ>HÈ$ ¢ döK”ýü¸é¸ÿ :®É\Wèw©™Ì•jÄåLg¨ä})Y)¡
ÊpGzÖ³)Êêů.œ±Sà‘_†ù[Ò¬„ö®˜»˜9Xl1ÕØW¥GÕ€UXâ®öG<åru!±íHœœš‡yr@:
š:ÆNæDëȧŠN)KÖlÂHq5 µ#=A#æ³hžPy*#%FíQÅeËv5V’ª‹è êKa(ûDx-ààŒäz¥4ΆVŒ02*†+ÜÐþ†¸ŸÈ²ër´gî*¡ ô`'–§¥—à>µQÁé¥îw†Ja’¹ +Y–‘oIã9*@ÇåZÚn n£¾Õ‰Ç¢ö§ kåu°é¶®—SU¤¨ÚJ§sw
º«\M HÌ# ì ,N ú“N/ë]
×9JÚÒ¬–À @k7C”¬Ø6ëߊո;âaŒñÇÖ©éÃe¾9ÎMC¾zÔjµ…qó,ÈÜÖáùü-žâ"#\ô†º[-“ø}#N†CþöZr8ê»(¿3“3b“Ï÷¬öàzâ¡iÈî(=EE3JIs'SQµÇ½U–\÷©q¹q£a ljÜzÕi[š‡ÌÁªQ7pÐÒûQÇZ³erKŒšÆšž 6°«Q±ÃV‘êÆ ji†´Œ|ô¤1{Rrž¿ZƸ¸–cûÙ ÿ ÞlÕI Õs7±¤h÷ ÏP;Ó Jäâ…{i*'z‰ä¨]ëEؕ䨚J‰ŸÞ£/ïZ$;)›êô…³Ua¤J_Þ¿jLÓ î÷£w½EŸz2h n ‹4¹¥`±.iCTY¥•€›u*šˆ ÒƒÇ41Xœ5HUÁ§«TØEµj™[ *’µL¯PЋ¨õ2ÉTýêUz‹ ¢ú½=^©#ÔÊÕ6&Å°Ôõæ«¡õ«ô¦&Z´“ʘ÷O¶Ux¬D\Ö”Û I9^ÇÒšf3WÔ¸©S*SâP˹HaíV?j‹f½±óaG Ç?Z²«YÖ2ù FÝO¡õlŒ!à÷§Îš9å£"™¸è( RªS¶Vcæ± ZŽR#œôQš²WŠÌ¿›Ì!#ûƒ©õ5…JŠ
ìqwfC)''¯zc-[eö¨Ê{W9ÓÎT1æ“Ê«[ h¦W9WË©zð¬EK¶¤ŠsÓSÒ¶„¯°9÷!๩zõ«1Ú ë–«)o >î?ÞÌÆU^5â¦#AÇÈP6AÁàÔ½ ›¹&ìSJŒ¶*6j’l=ߊއ~*z†5öcfJÝ^Aà/–ü‡5Èjþ&šâpºqh£ò²C?
ž1]ˆtñ©Xv¦C J»uœ™„¤1#'““õ«–í$@9 ‡¥*GÓŠR°“kTc)¥Èþ(Î}Hfá
1#ÀÉ Ò•Åfç#&Ñ ìÒ ÐUWˆÒ®²Ô,+žNû”¥c>HÈ÷ ZÑaUe=«¡jeR)1ÍLWšP¦R˜Ãæ61òŽM^T ` éIk #Ï©«!+¶“²ÈÕjU§=©ûxÔˆ¹TSG½}ÇJ†*6ª¸&f¹æ¡cV.†Ù¡æª9ëX·©¢ÔkµBíNcQ5+–ÒOjä|A¤ˆgZE#+’Ζ
s×ñæºàk™Ö5‹È®d! 8fù˜QØQ'¡éåžÕVý×ÌÃèMYU.0BãÐŒÔç°üÍYŒ9é³õ®I \Z‚«…sŽ„7"¬}•åÓä´.c2.ÍèyÁ<àõçÔÔp™¨*ŒOL?ÈUŠÈ þðrò¢-Ŧp×wM-áŽ%U(3Œ$j:ØjÒXQ£+( ?eêƲ¬Úé#
öuv|‘ 1#èqùt[;˜qæoÎÖ2)\ Bz
·9IݳË5Ù"Ž©o ˆ&ýÏ“–n·Ö³·Wauj×Ú|‘ÄÑÊ’2þŸZâ%%X«N=¥wQŸ4u<Ù%ÌHÒbè—b J0Í„—÷gêz~µ”ïU¤“Бî*å«©ó+ w‰áó´ÖuL¼G~sŒâúñ\
Ãç5Þéz‚jv'ÌÁ•FÉS׶~†¸wM›N˜îË[“òIØCèsÒ•›ƒ/.FéËs"vªS5X›5N\×J‰ìEHÕ riÎ9â’4ËV‰
ȳl¹5·`‡"³m"Î0+zÆ.œSg
j‡¹cR“M&¼¹ %qÒ¢aÅJj&â°“)2'ëP½LõVw4L‚J‡njg¨”|ß…i©¢c_½W~µaÇ5‚ºâÊEy
@Ʀ’«¿Ñk
Q¼æ<úUÉjÙÄOôÖƱÜÌ•ª¬SÊjœ¦ª'DQ U]ªYZªÊktPÇlš–F¨Õ¤ZB³Ôe©¬*c5ZC°òÔ…ª<ÒNÃ$ÝFj<Ð
0%ͨ÷S³HƒJ
F
(4X A¥Ô@Ò‚iXD¹¥¢
ëN€$š‹4 Ò æœ
EšPÔ¬I.qO
PO
JÁbuj‘[YO<Ôª}©X–[ªÔMïTc5nÒ¥¡3JÒ´më.œVµD‘”Í[zÓ·›mÚµmÅdÑË6_zUØ–ªÁW⬤sI’¢ÔȽ)±Ô«Á‹F
Å1…HH¦1¨’3¹TOô©ÔlkšJù
‰Ó*jf¦¶éXH¤Ê»sJžŠzsóÌOn¿ºZœ-2߀Wñ`
í§;ÅÌ1TÒ‘RAº®WaQ0« *' sZ&Rfeî<Ï©H*äçs±íÚªIÞ±r»6NÅv¨š¥’ f¦™ªcMr $¸j[7%ØIÝÎr=««–L) n tÎ3\N£%儦ëbÊRä/ U?„ö²h^³—d6=ÇÚ? Õ„.¤`£1è0EUVÆ0ìIè [·]®¤’ÌÀ‚}}?sI[V}+zë²TÉÉpA>ã‘ýkN‰ÔŽëÈÿ õë9:Æ} V”?~3õ©G
bÅ‘x¥‘ï[;?‰AäcÔu‹tYK ØÆGqèÏ’˜7ñã‚W‡cÔ~™‹aóvNøèÕ¢<ªýʺ–¶šuÙ…mŽÅ¶õú
å¯ïe¾—̸™OWD
O× jξñI©É,$‘ÈeNFq‚?J̯J•4¢™Â{±Ò qZvÚ}ÍÉm±EPí,¿$j§¡,x¤ºÓ¤†9d·¸‡;L–òo
}B*Ùj¬SµÌËi泸@ØqÁ£Cí[që¶Ó©K¸ŒY9Ôÿ ŸqY- zÓ¡ÓçºÝöx™öýâ:Ʋ©J2ÖCš„õ‘%Ö‹§ÞörˆÉÿ žl.ÕqỀøYá+êråSMnQÈ*UÁÁìED..a`Ri ÂXj=•Xü¿©¬eR+Ý‘‹§Ëe?—6ÒHÈ*r¨á‡&º aÊÁ2Ž1¦yª[÷ÅmF£œ–æ±®å½ÂÎœVͬXÅEm;V” ŒVœµ'sÔKR¢Šó&|àÂÔÆ4Q\Ò)±Îj¢ŠÌÐ…ê.š(§©¢ZÅW\h"ñUäQ]0f±+H8¬ûÓ… êsEºfðZ™s
§(¢ŠÚ'DJstª’œQEoDU~õ(Q¢"céQ“Eh´74ÅPš3E…Í(4QL,.iA¢ŠD‹šPh¢€\ÑE
p4¡¨¢—4QRƒJ
PÄ?uJE„ÉÕÈMT²¡lkVÛµVlÆfµ©éZÖç¥VLå‘¥ àUØJ(¬$sH²§Š~ê(¬Ùƒ$/‘Lf¢ŠRFl‰FZŠ+šh÷SdlW-M1‹RW1D©Áur6
ÇJ(iI§`d”Ö9Q]Ð%2'8ª72ç!zw4QNm
bQõªÒš(¨F¨©)ªò(bi¬ƒ\v§G¨LˆKœäï=Ï&Š*¥±îdûV¼„Œa¹#“Žµv?¼¿Sü¨¢¸äîϨ¶†„}ê*õ´èg1žt÷ãš(«£$ïÑ ^.n-[«/¨&qÙÞöÿ ëV‹Ü{If( ÊRàcùQEգϮ´8— »’§µ&h¢½›XóÇ´²4kÉ#F‡*…‰U>à «ZcǾxfm‰qw`r
“øŠ(¨–ĵd'ÙLµÈ]£
Æ¥¿Y§Ò,±Ìi½§ €7nïÿ éEÉÏïË{“{¤Ù~¥Ä2Ÿ˜º ÍÜ‘Ç?¥g¼Y¢Šé¥ðúÁ»ÿ ,!HéÒ›ðoÚí°ö-Ðþ4QX'ÉQÆ;&Ó²5¢LVcŠ(®’¹ÿÙ click-6.2/examples/imagepipe/imagepipe.py 0000644 0000765 0000024 00000020351 12372607550 021705 0 ustar mitsuhiko staff 0000000 0000000 import click
from functools import update_wrapper
from PIL import Image, ImageFilter, ImageEnhance
@click.group(chain=True)
def cli():
"""This script processes a bunch of images through pillow in a unix
pipe. One commands feeds into the next.
Example:
\b
imagepipe open -i example01.jpg resize -w 128 display
imagepipe open -i example02.jpg blur save
"""
@cli.resultcallback()
def process_commands(processors):
"""This result callback is invoked with an iterable of all the chained
subcommands. As in this example each subcommand returns a function
we can chain them together to feed one into the other, similar to how
a pipe on unix works.
"""
# Start with an empty iterable.
stream = ()
# Pipe it through all stream processors.
for processor in processors:
stream = processor(stream)
# Evaluate the stream and throw away the items.
for _ in stream:
pass
def processor(f):
"""Helper decorator to rewrite a function so that it returns another
function from it.
"""
def new_func(*args, **kwargs):
def processor(stream):
return f(stream, *args, **kwargs)
return processor
return update_wrapper(new_func, f)
def generator(f):
"""Similar to the :func:`processor` but passes through old values
unchanged and does not pass through the values as parameter.
"""
@processor
def new_func(stream, *args, **kwargs):
for item in stream:
yield item
for item in f(*args, **kwargs):
yield item
return update_wrapper(new_func, f)
def copy_filename(new, old):
new.filename = old.filename
return new
@cli.command('open')
@click.option('-i', '--image', 'images', type=click.Path(),
multiple=True, help='The image file to open.')
@generator
def open_cmd(images):
"""Loads one or multiple images for processing. The input parameter
can be specified multiple times to load more than one image.
"""
for image in images:
try:
click.echo('Opening "%s"' % image)
if image == '-':
img = Image.open(click.get_binary_stdin())
img.filename = '-'
else:
img = Image.open(image)
yield img
except Exception as e:
click.echo('Could not open image "%s": %s' % (image, e), err=True)
@cli.command('save')
@click.option('--filename', default='processed-%04d.png', type=click.Path(),
help='The format for the filename.',
show_default=True)
@processor
def save_cmd(images, filename):
"""Saves all processed images to a series of files."""
for idx, image in enumerate(images):
try:
fn = filename % (idx + 1)
click.echo('Saving "%s" as "%s"' % (image.filename, fn))
yield image.save(fn)
except Exception as e:
click.echo('Could not save image "%s": %s' %
(image.filename, e), err=True)
@cli.command('display')
@processor
def display_cmd(images):
"""Opens all images in an image viewer."""
for image in images:
click.echo('Displaying "%s"' % image.filename)
image.show()
yield image
@cli.command('resize')
@click.option('-w', '--width', type=int, help='The new width of the image.')
@click.option('-h', '--height', type=int, help='The new height of the image.')
@processor
def resize_cmd(images, width, height):
"""Resizes an image by fitting it into the box without changing
the aspect ratio.
"""
for image in images:
w, h = (width or image.size[0], height or image.size[1])
click.echo('Resizing "%s" to %dx%d' % (image.filename, w, h))
image.thumbnail((w, h))
yield image
@cli.command('crop')
@click.option('-b', '--border', type=int, help='Crop the image from all '
'sides by this amount.')
@processor
def crop_cmd(images, border):
"""Crops an image from all edges."""
for image in images:
box = [0, 0, image.size[0], image.size[1]]
if border is not None:
for idx, val in enumerate(box):
box[idx] = max(0, val - border)
click.echo('Cropping "%s" by %dpx' % (image.filename, border))
yield copy_filename(image.crop(box), image)
else:
yield image
def convert_rotation(ctx, param, value):
if value is None:
return
value = value.lower()
if value in ('90', 'r', 'right'):
return (Image.ROTATE_90, 90)
if value in ('180', '-180'):
return (Image.ROTATE_180, 180)
if value in ('-90', '270', 'l', 'left'):
return (Image.ROTATE_270, 270)
raise click.BadParameter('invalid rotation "%s"' % value)
def convert_flip(ctx, param, value):
if value is None:
return
value = value.lower()
if value in ('lr', 'leftright'):
return (Image.FLIP_LEFT_RIGHT, 'left to right')
if value in ('tb', 'topbottom', 'upsidedown', 'ud'):
return (Image.FLIP_LEFT_RIGHT, 'top to bottom')
raise click.BadParameter('invalid flip "%s"' % value)
@cli.command('transpose')
@click.option('-r', '--rotate', callback=convert_rotation,
help='Rotates the image (in degrees)')
@click.option('-f', '--flip', callback=convert_flip,
help='Flips the image [LR / TB]')
@processor
def transpose_cmd(images, rotate, flip):
"""Transposes an image by either rotating or flipping it."""
for image in images:
if rotate is not None:
mode, degrees = rotate
click.echo('Rotate "%s" by %ddeg' % (image.filename, degrees))
image = copy_filename(image.transpose(mode), image)
if flip is not None:
mode, direction = flip
click.echo('Flip "%s" %s' % (image.filename, direction))
image = copy_filename(image.transpose(mode), image)
yield image
@cli.command('blur')
@click.option('-r', '--radius', default=2, show_default=True,
help='The blur radius.')
@processor
def blur_cmd(images, radius):
"""Applies gaussian blur."""
blur = ImageFilter.GaussianBlur(radius)
for image in images:
click.echo('Blurring "%s" by %dpx' % (image.filename, radius))
yield copy_filename(image.filter(blur), image)
@cli.command('smoothen')
@click.option('-i', '--iterations', default=1, show_default=True,
help='How many iterations of the smoothen filter to run.')
@processor
def smoothen_cmd(images, iterations):
"""Applies a smoothening filter."""
for image in images:
click.echo('Smoothening "%s" %d time%s' %
(image.filename, iterations, iterations != 1 and 's' or '',))
for x in xrange(iterations):
image = copy_filename(image.filter(ImageFilter.BLUR), image)
yield image
@cli.command('emboss')
@processor
def emboss_cmd(images):
"""Embosses an image."""
for image in images:
click.echo('Embossing "%s"' % image.filename)
yield copy_filename(image.filter(ImageFilter.EMBOSS), image)
@cli.command('sharpen')
@click.option('-f', '--factor', default=2.0,
help='Sharpens the image.', show_default=True)
@processor
def sharpen_cmd(images, factor):
"""Sharpens an image."""
for image in images:
click.echo('Sharpen "%s" by %f' % (image.filename, factor))
enhancer = ImageEnhance.Sharpness(image)
yield copy_filename(enhancer.enhance(max(1.0, factor)), image)
@cli.command('paste')
@click.option('-l', '--left', default=0, help='Offset from left.')
@click.option('-r', '--right', default=0, help='Offset from right.')
@processor
def paste_cmd(images, left, right):
"""Pastes the second image on the first image and leaves the rest
unchanged.
"""
imageiter = iter(images)
image = next(imageiter, None)
to_paste = next(imageiter, None)
if to_paste is None:
if image is not None:
yield image
return
click.echo('Paste "%s" on "%s"' %
(to_paste.filename, image.filename))
mask = None
if to_paste.mode == 'RGBA' or 'transparency' in to_paste.info:
mask = to_paste
image.paste(to_paste, (left, right), mask)
image.filename += '+' + to_paste.filename
yield image
for image in imageiter:
yield image
click-6.2/examples/imagepipe/README 0000644 0000765 0000024 00000000466 12372607550 020260 0 ustar mitsuhiko staff 0000000 0000000 $ imagepipe_
imagepipe is an example application that implements some
multi commands that chain image processing instructions
together.
This requires pillow.
Usage:
$ pip install --editable .
$ imagepipe open -i example01.jpg resize -w 128 display
$ imagepipe open -i example02.jpg blur save
click-6.2/examples/imagepipe/setup.py 0000644 0000765 0000024 00000000464 12506476043 021110 0 ustar mitsuhiko staff 0000000 0000000 from setuptools import setup
setup(
name='click-example-imagepipe',
version='1.0',
py_modules=['imagepipe'],
include_package_data=True,
install_requires=[
'click',
'pillow',
],
entry_points='''
[console_scripts]
imagepipe=imagepipe:cli
''',
)
click-6.2/examples/inout/ 0000755 0000765 0000024 00000000000 12626113045 016561 5 ustar mitsuhiko staff 0000000 0000000 click-6.2/examples/inout/inout.py 0000644 0000765 0000024 00000001322 12370501774 020275 0 ustar mitsuhiko staff 0000000 0000000 import click
@click.command()
@click.argument('input', type=click.File('rb'), nargs=-1)
@click.argument('output', type=click.File('wb'))
def cli(input, output):
"""This script works similar to the Unix `cat` command but it writes
into a specific file (which could be the standard output as denoted by
the ``-`` sign).
\b
Copy stdin to stdout:
inout - -
\b
Copy foo.txt and bar.txt to stdout:
inout foo.txt bar.txt -
\b
Write stdin into the file foo.txt
inout - foo.txt
"""
for f in input:
while True:
chunk = f.read(1024)
if not chunk:
break
output.write(chunk)
output.flush()
click-6.2/examples/inout/README 0000644 0000765 0000024 00000000354 12370501774 017451 0 ustar mitsuhiko staff 0000000 0000000 $ inout_
inout is a simple example of an application that
can read from files and write to files but also
accept input from stdin or write to stdout.
Usage:
$ pip install --editable .
$ inout input_file.txt output_file.txt
click-6.2/examples/inout/setup.py 0000644 0000765 0000024 00000000422 12506476043 020300 0 ustar mitsuhiko staff 0000000 0000000 from setuptools import setup
setup(
name='click-example-inout',
version='0.1',
py_modules=['inout'],
include_package_data=True,
install_requires=[
'click',
],
entry_points='''
[console_scripts]
inout=inout:cli
''',
)
click-6.2/examples/naval/ 0000755 0000765 0000024 00000000000 12626113045 016524 5 ustar mitsuhiko staff 0000000 0000000 click-6.2/examples/naval/click_example_naval.egg-info/ 0000755 0000765 0000024 00000000000 12626113045 024177 5 ustar mitsuhiko staff 0000000 0000000 click-6.2/examples/naval/click_example_naval.egg-info/dependency_links.txt 0000644 0000765 0000024 00000000001 12576332105 030251 0 ustar mitsuhiko staff 0000000 0000000
click-6.2/examples/naval/click_example_naval.egg-info/entry_points.txt 0000644 0000765 0000024 00000000067 12576332105 027504 0 ustar mitsuhiko staff 0000000 0000000
[console_scripts]
naval=naval:cli
click-6.2/examples/naval/click_example_naval.egg-info/PKG-INFO 0000644 0000765 0000024 00000000277 12576332105 025306 0 ustar mitsuhiko staff 0000000 0000000 Metadata-Version: 1.0
Name: click-example-naval
Version: 2.0
Summary: UNKNOWN
Home-page: UNKNOWN
Author: UNKNOWN
Author-email: UNKNOWN
License: UNKNOWN
Description: UNKNOWN
Platform: UNKNOWN
click-6.2/examples/naval/click_example_naval.egg-info/requires.txt 0000644 0000765 0000024 00000000005 12576332105 026576 0 ustar mitsuhiko staff 0000000 0000000 click click-6.2/examples/naval/click_example_naval.egg-info/SOURCES.txt 0000644 0000765 0000024 00000000423 12576332105 026066 0 ustar mitsuhiko staff 0000000 0000000 README
naval.py
click_example_naval.egg-info/PKG-INFO
click_example_naval.egg-info/SOURCES.txt
click_example_naval.egg-info/dependency_links.txt
click_example_naval.egg-info/entry_points.txt
click_example_naval.egg-info/requires.txt
click_example_naval.egg-info/top_level.txt click-6.2/examples/naval/click_example_naval.egg-info/top_level.txt 0000644 0000765 0000024 00000000006 12576332105 026731 0 ustar mitsuhiko staff 0000000 0000000 naval
click-6.2/examples/naval/naval.py 0000644 0000765 0000024 00000003344 12370501774 020211 0 ustar mitsuhiko staff 0000000 0000000 import click
@click.group()
@click.version_option()
def cli():
"""Naval Fate.
This is the docopt example adopted to Click but with some actual
commands implemented and not just the empty parsing which really
is not all that interesting.
"""
@cli.group()
def ship():
"""Manages ships."""
@ship.command('new')
@click.argument('name')
def ship_new(name):
"""Creates a new ship."""
click.echo('Created ship %s' % name)
@ship.command('move')
@click.argument('ship')
@click.argument('x', type=float)
@click.argument('y', type=float)
@click.option('--speed', metavar='KN', default=10,
help='Speed in knots.')
def ship_move(ship, x, y, speed):
"""Moves SHIP to the new location X,Y."""
click.echo('Moving ship %s to %s,%s with speed %s' % (ship, x, y, speed))
@ship.command('shoot')
@click.argument('ship')
@click.argument('x', type=float)
@click.argument('y', type=float)
def ship_shoot(ship, x, y):
"""Makes SHIP fire to X,Y."""
click.echo('Ship %s fires to %s,%s' % (ship, x, y))
@cli.group('mine')
def mine():
"""Manages mines."""
@mine.command('set')
@click.argument('x', type=float)
@click.argument('y', type=float)
@click.option('ty', '--moored', flag_value='moored',
default=True,
help='Moored (anchored) mine. Default.')
@click.option('ty', '--drifting', flag_value='drifting',
help='Drifting mine.')
def mine_set(x, y, ty):
"""Sets a mine at a specific coordinate."""
click.echo('Set %s mine at %s,%s' % (ty, x, y))
@mine.command('remove')
@click.argument('x', type=float)
@click.argument('y', type=float)
def mine_remove(x, y):
"""Removes a mine at a specific coordinate."""
click.echo('Removed mine at %s,%s' % (x, y))
click-6.2/examples/naval/README 0000644 0000765 0000024 00000000542 12370501774 017413 0 ustar mitsuhiko staff 0000000 0000000 $ naval_
naval is a simple example of an application that
is ported from the docopt example of the same name.
Unlike the original this one also runs some code and
prints messages and it's command line interface was
changed slightly to make more sense with established
POSIX semantics.
Usage:
$ pip install --editable .
$ naval --help
click-6.2/examples/naval/setup.py 0000644 0000765 0000024 00000000422 12506476043 020243 0 ustar mitsuhiko staff 0000000 0000000 from setuptools import setup
setup(
name='click-example-naval',
version='2.0',
py_modules=['naval'],
include_package_data=True,
install_requires=[
'click',
],
entry_points='''
[console_scripts]
naval=naval:cli
''',
)
click-6.2/examples/README 0000644 0000765 0000024 00000000642 12372607550 016314 0 ustar mitsuhiko staff 0000000 0000000 Click Examples
This folder contains various Click examples. Note that
all of these are not runnable by themselves but should be
installed into a virtualenv.
This is done this way so that scripts also properly work
on Windows and in virtualenvs without accidentally executing
through the wrong interpreter.
For more information about this see the documentation:
http://click.pocoo.org/setuptools/
click-6.2/examples/repo/ 0000755 0000765 0000024 00000000000 12626113045 016370 5 ustar mitsuhiko staff 0000000 0000000 click-6.2/examples/repo/click_example_repo.egg-info/ 0000755 0000765 0000024 00000000000 12626113045 023707 5 ustar mitsuhiko staff 0000000 0000000 click-6.2/examples/repo/click_example_repo.egg-info/dependency_links.txt 0000644 0000765 0000024 00000000001 12576332302 027760 0 ustar mitsuhiko staff 0000000 0000000
click-6.2/examples/repo/click_example_repo.egg-info/entry_points.txt 0000644 0000765 0000024 00000000065 12576332302 027211 0 ustar mitsuhiko staff 0000000 0000000
[console_scripts]
repo=repo:cli
click-6.2/examples/repo/click_example_repo.egg-info/PKG-INFO 0000644 0000765 0000024 00000000276 12576332302 025014 0 ustar mitsuhiko staff 0000000 0000000 Metadata-Version: 1.0
Name: click-example-repo
Version: 0.1
Summary: UNKNOWN
Home-page: UNKNOWN
Author: UNKNOWN
Author-email: UNKNOWN
License: UNKNOWN
Description: UNKNOWN
Platform: UNKNOWN
click-6.2/examples/repo/click_example_repo.egg-info/requires.txt 0000644 0000765 0000024 00000000005 12576332302 026305 0 ustar mitsuhiko staff 0000000 0000000 click click-6.2/examples/repo/click_example_repo.egg-info/SOURCES.txt 0000644 0000765 0000024 00000000414 12576332302 025575 0 ustar mitsuhiko staff 0000000 0000000 README
repo.py
click_example_repo.egg-info/PKG-INFO
click_example_repo.egg-info/SOURCES.txt
click_example_repo.egg-info/dependency_links.txt
click_example_repo.egg-info/entry_points.txt
click_example_repo.egg-info/requires.txt
click_example_repo.egg-info/top_level.txt click-6.2/examples/repo/click_example_repo.egg-info/top_level.txt 0000644 0000765 0000024 00000000005 12576332302 026437 0 ustar mitsuhiko staff 0000000 0000000 repo
click-6.2/examples/repo/README 0000644 0000765 0000024 00000000231 12370501774 017252 0 ustar mitsuhiko staff 0000000 0000000 $ repo_
repo is a simple example of an application that looks
and works similar to hg or git.
Usage:
$ pip install --editable .
$ repo --help
click-6.2/examples/repo/repo.py 0000644 0000765 0000024 00000011302 12370501774 017712 0 ustar mitsuhiko staff 0000000 0000000 import os
import sys
import posixpath
import click
class Repo(object):
def __init__(self, home):
self.home = home
self.config = {}
self.verbose = False
def set_config(self, key, value):
self.config[key] = value
if self.verbose:
click.echo(' config[%s] = %s' % (key, value), file=sys.stderr)
def __repr__(self):
return '' % self.home
pass_repo = click.make_pass_decorator(Repo)
@click.group()
@click.option('--repo-home', envvar='REPO_HOME', default='.repo',
metavar='PATH', help='Changes the repository folder location.')
@click.option('--config', nargs=2, multiple=True,
metavar='KEY VALUE', help='Overrides a config key/value pair.')
@click.option('--verbose', '-v', is_flag=True,
help='Enables verbose mode.')
@click.version_option('1.0')
@click.pass_context
def cli(ctx, repo_home, config, verbose):
"""Repo is a command line tool that showcases how to build complex
command line interfaces with Click.
This tool is supposed to look like a distributed version control
system to show how something like this can be structured.
"""
# Create a repo object and remember it as as the context object. From
# this point onwards other commands can refer to it by using the
# @pass_repo decorator.
ctx.obj = Repo(os.path.abspath(repo_home))
ctx.obj.verbose = verbose
for key, value in config:
ctx.obj.set_config(key, value)
@cli.command()
@click.argument('src')
@click.argument('dest', required=False)
@click.option('--shallow/--deep', default=False,
help='Makes a checkout shallow or deep. Deep by default.')
@click.option('--rev', '-r', default='HEAD',
help='Clone a specific revision instead of HEAD.')
@pass_repo
def clone(repo, src, dest, shallow, rev):
"""Clones a repository.
This will clone the repository at SRC into the folder DEST. If DEST
is not provided this will automatically use the last path component
of SRC and create that folder.
"""
if dest is None:
dest = posixpath.split(src)[-1] or '.'
click.echo('Cloning repo %s to %s' % (src, os.path.abspath(dest)))
repo.home = dest
if shallow:
click.echo('Making shallow checkout')
click.echo('Checking out revision %s' % rev)
@cli.command()
@click.confirmation_option()
@pass_repo
def delete(repo):
"""Deletes a repository.
This will throw away the current repository.
"""
click.echo('Destroying repo %s' % repo.home)
click.echo('Deleted!')
@cli.command()
@click.option('--username', prompt=True,
help='The developer\'s shown username.')
@click.option('--email', prompt='E-Mail',
help='The developer\'s email address')
@click.password_option(help='The login password.')
@pass_repo
def setuser(repo, username, email, password):
"""Sets the user credentials.
This will override the current user config.
"""
repo.set_config('username', username)
repo.set_config('email', email)
repo.set_config('password', '*' * len(password))
click.echo('Changed credentials.')
@cli.command()
@click.option('--message', '-m', multiple=True,
help='The commit message. If provided multiple times each '
'argument gets converted into a new line.')
@click.argument('files', nargs=-1, type=click.Path())
@pass_repo
def commit(repo, files, message):
"""Commits outstanding changes.
Commit changes to the given files into the repository. You will need to
"repo push" to push up your changes to other repositories.
If a list of files is omitted, all changes reported by "repo status"
will be committed.
"""
if not message:
marker = '# Files to be committed:'
hint = ['', '', marker, '#']
for file in files:
hint.append('# U %s' % file)
message = click.edit('\n'.join(hint))
if message is None:
click.echo('Aborted!')
return
msg = message.split(marker)[0].rstrip()
if not msg:
click.echo('Aborted! Empty commit message')
return
else:
msg = '\n'.join(message)
click.echo('Files to be committed: %s' % (files,))
click.echo('Commit message:\n' + msg)
@cli.command(short_help='Copies files.')
@click.option('--force', is_flag=True,
help='forcibly copy over an existing managed file')
@click.argument('src', nargs=-1, type=click.Path())
@click.argument('dst', type=click.Path())
@pass_repo
def copy(repo, src, dst, force):
"""Copies one or multiple files to a new location. This copies all
files from SRC to DST.
"""
for fn in src:
click.echo('Copy from %s -> %s' % (fn, dst))
click-6.2/examples/repo/setup.py 0000644 0000765 0000024 00000000416 12506476043 020112 0 ustar mitsuhiko staff 0000000 0000000 from setuptools import setup
setup(
name='click-example-repo',
version='0.1',
py_modules=['repo'],
include_package_data=True,
install_requires=[
'click',
],
entry_points='''
[console_scripts]
repo=repo:cli
''',
)
click-6.2/examples/termui/ 0000755 0000765 0000024 00000000000 12626113045 016730 5 ustar mitsuhiko staff 0000000 0000000 click-6.2/examples/termui/click_example_termui.egg-info/ 0000755 0000765 0000024 00000000000 12626113045 024607 5 ustar mitsuhiko staff 0000000 0000000 click-6.2/examples/termui/click_example_termui.egg-info/dependency_links.txt 0000644 0000765 0000024 00000000001 12576332567 030675 0 ustar mitsuhiko staff 0000000 0000000
click-6.2/examples/termui/click_example_termui.egg-info/entry_points.txt 0000644 0000765 0000024 00000000071 12576332567 030123 0 ustar mitsuhiko staff 0000000 0000000
[console_scripts]
termui=termui:cli
click-6.2/examples/termui/click_example_termui.egg-info/PKG-INFO 0000644 0000765 0000024 00000000300 12576332567 025715 0 ustar mitsuhiko staff 0000000 0000000 Metadata-Version: 1.0
Name: click-example-termui
Version: 1.0
Summary: UNKNOWN
Home-page: UNKNOWN
Author: UNKNOWN
Author-email: UNKNOWN
License: UNKNOWN
Description: UNKNOWN
Platform: UNKNOWN
click-6.2/examples/termui/click_example_termui.egg-info/requires.txt 0000644 0000765 0000024 00000000016 12576332567 027224 0 ustar mitsuhiko staff 0000000 0000000 click
colorama click-6.2/examples/termui/click_example_termui.egg-info/SOURCES.txt 0000644 0000765 0000024 00000000432 12576332567 026512 0 ustar mitsuhiko staff 0000000 0000000 README
termui.py
click_example_termui.egg-info/PKG-INFO
click_example_termui.egg-info/SOURCES.txt
click_example_termui.egg-info/dependency_links.txt
click_example_termui.egg-info/entry_points.txt
click_example_termui.egg-info/requires.txt
click_example_termui.egg-info/top_level.txt click-6.2/examples/termui/click_example_termui.egg-info/top_level.txt 0000644 0000765 0000024 00000000007 12576332567 027356 0 ustar mitsuhiko staff 0000000 0000000 termui
click-6.2/examples/termui/README 0000644 0000765 0000024 00000000217 12372607550 017617 0 ustar mitsuhiko staff 0000000 0000000 $ termui_
termui showcases the different terminal UI helpers that
Click provides.
Usage:
$ pip install --editable .
$ termui --help
click-6.2/examples/termui/setup.py 0000644 0000765 0000024 00000000533 12506476043 020452 0 ustar mitsuhiko staff 0000000 0000000 from setuptools import setup
setup(
name='click-example-termui',
version='1.0',
py_modules=['termui'],
include_package_data=True,
install_requires=[
'click',
# Colorama is only required for Windows.
'colorama',
],
entry_points='''
[console_scripts]
termui=termui:cli
''',
)
click-6.2/examples/termui/termui.py 0000644 0000765 0000024 00000010354 12626112446 020616 0 ustar mitsuhiko staff 0000000 0000000 # coding: utf-8
import click
import math
import time
import random
try:
range_type = xrange
except NameError:
range_type = range
@click.group()
def cli():
"""This script showcases different terminal UI helpers in Click."""
pass
@cli.command()
def colordemo():
"""Demonstrates ANSI color support."""
for color in 'red', 'green', 'blue':
click.echo(click.style('I am colored %s' % color, fg=color))
click.echo(click.style('I am background colored %s' % color, bg=color))
@cli.command()
def pager():
"""Demonstrates using the pager."""
lines = []
for x in range_type(200):
lines.append('%s. Hello World!' % click.style(str(x), fg='green'))
click.echo_via_pager('\n'.join(lines))
@cli.command()
@click.option('--count', default=8000, type=click.IntRange(1, 100000),
help='The number of items to process.')
def progress(count):
"""Demonstrates the progress bar."""
items = range_type(count)
def process_slowly(item):
time.sleep(0.002 * random.random())
def filter(items):
for item in items:
if random.random() > 0.3:
yield item
with click.progressbar(items, label='Processing accounts',
fill_char=click.style('#', fg='green')) as bar:
for item in bar:
process_slowly(item)
def show_item(item):
if item is not None:
return 'Item #%d' % item
with click.progressbar(filter(items), label='Committing transaction',
fill_char=click.style('#', fg='yellow'),
item_show_func=show_item) as bar:
for item in bar:
process_slowly(item)
with click.progressbar(length=count, label='Counting',
bar_template='%(label)s %(bar)s | %(info)s',
fill_char=click.style(u'â–ˆ', fg='cyan'),
empty_char=' ') as bar:
for item in bar:
process_slowly(item)
with click.progressbar(length=count, width=0, show_percent=False,
show_eta=False,
fill_char=click.style('#', fg='magenta')) as bar:
for item in bar:
process_slowly(item)
# 'Non-linear progress bar'
steps = [math.exp( x * 1. / 20) - 1 for x in range(20)]
count = int(sum(steps))
with click.progressbar(length=count, show_percent=False,
label='Slowing progress bar',
fill_char=click.style(u'â–ˆ', fg='green')) as bar:
for item in steps:
time.sleep(item)
bar.update(item)
@cli.command()
@click.argument('url')
def open(url):
"""Opens a file or URL In the default application."""
click.launch(url)
@cli.command()
@click.argument('url')
def locate(url):
"""Opens a file or URL In the default application."""
click.launch(url, locate=True)
@cli.command()
def edit():
"""Opens an editor with some text in it."""
MARKER = '# Everything below is ignored\n'
message = click.edit('\n\n' + MARKER)
if message is not None:
msg = message.split(MARKER, 1)[0].rstrip('\n')
if not msg:
click.echo('Empty message!')
else:
click.echo('Message:\n' + msg)
else:
click.echo('You did not enter anything!')
@cli.command()
def clear():
"""Clears the entire screen."""
click.clear()
@cli.command()
def pause():
"""Waits for the user to press a button."""
click.pause()
@cli.command()
def menu():
"""Shows a simple menu."""
menu = 'main'
while 1:
if menu == 'main':
click.echo('Main menu:')
click.echo(' d: debug menu')
click.echo(' q: quit')
char = click.getchar()
if char == 'd':
menu = 'debug'
elif char == 'q':
menu = 'quit'
else:
click.echo('Invalid input')
elif menu == 'debug':
click.echo('Debug menu')
click.echo(' b: back')
char = click.getchar()
if char == 'b':
menu = 'main'
else:
click.echo('Invalid input')
elif menu == 'quit':
return
click-6.2/examples/validation/ 0000755 0000765 0000024 00000000000 12626113045 017555 5 ustar mitsuhiko staff 0000000 0000000 click-6.2/examples/validation/README 0000644 0000765 0000024 00000000361 12370501774 020443 0 ustar mitsuhiko staff 0000000 0000000 $ validation_
validation is a simple example of an application that
performs custom validation of parameters in different
ways.
This example requires Click 2.0 or higher.
Usage:
$ pip install --editable .
$ validation --help
click-6.2/examples/validation/setup.py 0000644 0000765 0000024 00000000446 12506476043 021302 0 ustar mitsuhiko staff 0000000 0000000 from setuptools import setup
setup(
name='click-example-validation',
version='1.0',
py_modules=['validation'],
include_package_data=True,
install_requires=[
'click',
],
entry_points='''
[console_scripts]
validation=validation:cli
''',
)
click-6.2/examples/validation/validation.py 0000644 0000765 0000024 00000002624 12370501774 022273 0 ustar mitsuhiko staff 0000000 0000000 import click
try:
from urllib import parser as urlparse
except ImportError:
import urlparse
def validate_count(ctx, param, value):
if value < 0 or value % 2 != 0:
raise click.BadParameter('Should be a positive, even integer.')
return value
class URL(click.ParamType):
name = 'url'
def convert(self, value, param, ctx):
if not isinstance(value, tuple):
value = urlparse.urlparse(value)
if value.scheme not in ('http', 'https'):
self.fail('invalid URL scheme (%s). Only HTTP URLs are '
'allowed' % value.scheme, param, ctx)
return value
@click.command()
@click.option('--count', default=2, callback=validate_count,
help='A positive even number.')
@click.option('--foo', help='A mysterious parameter.')
@click.option('--url', help='A URL', type=URL())
@click.version_option()
def cli(count, foo, url):
"""Validation.
This example validates parameters in different ways. It does it
through callbacks, through a custom type as well as by validating
manually in the function.
"""
if foo is not None and foo != 'wat':
raise click.BadParameter('If a value is provided it needs to be the '
'value "wat".', param_hint=['--foo'])
click.echo('count: %s' % count)
click.echo('foo: %s' % foo)
click.echo('url: %s' % repr(url))
click-6.2/LICENSE 0000644 0000765 0000024 00000003374 12370501774 014627 0 ustar mitsuhiko staff 0000000 0000000 Copyright (c) 2014 by Armin Ronacher.
Click uses parts of optparse written by Gregory P. Ward and maintained by the
Python software foundation. This is limited to code in the parser.py
module:
Copyright (c) 2001-2006 Gregory P. Ward. All rights reserved.
Copyright (c) 2002-2006 Python Software Foundation. All rights reserved.
Some rights reserved.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are
met:
* Redistributions of source code must retain the above copyright
notice, this list of conditions and the following disclaimer.
* Redistributions in binary form must reproduce the above
copyright notice, this list of conditions and the following
disclaimer in the documentation and/or other materials provided
with the distribution.
* The names of the contributors may not be used to endorse or
promote products derived from this software without specific
prior written permission.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
click-6.2/Makefile 0000644 0000765 0000024 00000000374 12576124406 015260 0 ustar mitsuhiko staff 0000000 0000000 test:
@cd tests; PYTHONPATH=.. py.test --tb=short
upload-docs:
$(MAKE) -C docs dirhtml
rsync -a docs/_build/dirhtml/* flow.srv.pocoo.org:/srv/websites/click.pocoo.org/static/
release:
python setup.py sdist bdist_wheel upload
.PHONY: upload-docs
click-6.2/MANIFEST.in 0000644 0000765 0000024 00000000527 12370501774 015355 0 ustar mitsuhiko staff 0000000 0000000 include Makefile CHANGES LICENSE
recursive-include artwork *
recursive-include tests *
recursive-include examples *
recursive-include docs *
recursive-exclude docs *.pyc
recursive-exclude docs *.pyo
recursive-exclude tests *.pyc
recursive-exclude tests *.pyo
recursive-exclude examples *.pyc
recursive-exclude examples *.pyo
prune docs/_build
click-6.2/PKG-INFO 0000644 0000765 0000024 00000000662 12626113045 014706 0 ustar mitsuhiko staff 0000000 0000000 Metadata-Version: 1.1
Name: click
Version: 6.2
Summary: A simple wrapper around optparse for powerful command line utilities.
Home-page: http://github.com/mitsuhiko/click
Author: Armin Ronacher
Author-email: armin.ronacher@active-4.com
License: UNKNOWN
Description: UNKNOWN
Platform: UNKNOWN
Classifier: License :: OSI Approved :: BSD License
Classifier: Programming Language :: Python
Classifier: Programming Language :: Python :: 3
click-6.2/README 0000644 0000765 0000024 00000001303 12560614006 014462 0 ustar mitsuhiko staff 0000000 0000000 $ click_
Click is a Python package for creating beautiful command line interfaces
in a composable way with as little code as necessary. It's the "Command
Line Interface Creation Kit". It's highly configurable but comes with
sensible defaults out of the box.
It aims to make the process of writing command line tools quick and fun
while also preventing any frustration caused by the inability to implement
an intended CLI API.
Click in three points:
- arbitrary nesting of commands
- automatic help page generation
- supports lazy loading of subcommands at runtime
Read the docs at http://click.pocoo.org/
This library is stable and active. Feedback is always welcome!
click-6.2/setup.cfg 0000644 0000765 0000024 00000000122 12626113045 015421 0 ustar mitsuhiko staff 0000000 0000000 [wheel]
universal = 1
[egg_info]
tag_build =
tag_date = 0
tag_svn_revision = 0
click-6.2/setup.py 0000644 0000765 0000024 00000001315 12370501774 015325 0 ustar mitsuhiko staff 0000000 0000000 import re
import ast
from setuptools import setup
_version_re = re.compile(r'__version__\s+=\s+(.*)')
with open('click/__init__.py', 'rb') as f:
version = str(ast.literal_eval(_version_re.search(
f.read().decode('utf-8')).group(1)))
setup(
name='click',
author='Armin Ronacher',
author_email='armin.ronacher@active-4.com',
version=version,
url='http://github.com/mitsuhiko/click',
packages=['click'],
description='A simple wrapper around optparse for '
'powerful command line utilities.',
classifiers=[
'License :: OSI Approved :: BSD License',
'Programming Language :: Python',
'Programming Language :: Python :: 3',
],
)
click-6.2/tests/ 0000755 0000765 0000024 00000000000 12626113045 014747 5 ustar mitsuhiko staff 0000000 0000000 click-6.2/tests/conftest.py 0000644 0000765 0000024 00000000203 12532047612 017143 0 ustar mitsuhiko staff 0000000 0000000 from click.testing import CliRunner
import pytest
@pytest.fixture(scope='function')
def runner(request):
return CliRunner()
click-6.2/tests/test_arguments.py 0000644 0000765 0000024 00000016266 12625116421 020400 0 ustar mitsuhiko staff 0000000 0000000 # -*- coding: utf-8 -*-
import click
from click._compat import PY2
def test_nargs_star(runner):
@click.command()
@click.argument('src', nargs=-1)
@click.argument('dst')
def copy(src, dst):
click.echo('src=%s' % '|'.join(src))
click.echo('dst=%s' % dst)
result = runner.invoke(copy, ['foo.txt', 'bar.txt', 'dir'])
assert not result.exception
assert result.output.splitlines() == [
'src=foo.txt|bar.txt',
'dst=dir',
]
def test_nargs_default(runner):
try:
@click.command()
@click.argument('src', nargs=-1, default=42)
def copy(src):
pass
except TypeError as e:
assert 'nargs=-1' in str(e)
else:
assert False
def test_nargs_tup(runner):
@click.command()
@click.argument('name', nargs=1)
@click.argument('point', nargs=2, type=click.INT)
def copy(name, point):
click.echo('name=%s' % name)
click.echo('point=%d/%d' % point)
result = runner.invoke(copy, ['peter', '1', '2'])
assert not result.exception
assert result.output.splitlines() == [
'name=peter',
'point=1/2',
]
def test_nargs_tup_composite(runner):
variations = [
dict(type=(str, int)),
dict(type=click.Tuple([str, int])),
dict(nargs=2, type=click.Tuple([str, int])),
dict(nargs=2, type=(str, int)),
]
for opts in variations:
@click.command()
@click.argument('item', **opts)
def copy(item):
click.echo('name=%s id=%d' % item)
result = runner.invoke(copy, ['peter', '1'])
assert not result.exception
assert result.output.splitlines() == [
'name=peter id=1',
]
def test_nargs_err(runner):
@click.command()
@click.argument('x')
def copy(x):
click.echo(x)
result = runner.invoke(copy, ['foo'])
assert not result.exception
assert result.output == 'foo\n'
result = runner.invoke(copy, ['foo', 'bar'])
assert result.exit_code == 2
assert 'Got unexpected extra argument (bar)' in result.output
def test_file_args(runner):
@click.command()
@click.argument('input', type=click.File('rb'))
@click.argument('output', type=click.File('wb'))
def inout(input, output):
while True:
chunk = input.read(1024)
if not chunk:
break
output.write(chunk)
with runner.isolated_filesystem():
result = runner.invoke(inout, ['-', 'hello.txt'], input='Hey!')
assert result.output == ''
assert result.exit_code == 0
with open('hello.txt', 'rb') as f:
assert f.read() == b'Hey!'
result = runner.invoke(inout, ['hello.txt', '-'])
assert result.output == 'Hey!'
assert result.exit_code == 0
def test_file_atomics(runner):
@click.command()
@click.argument('output', type=click.File('wb', atomic=True))
def inout(output):
output.write(b'Foo bar baz\n')
output.flush()
with open(output.name, 'rb') as f:
old_content = f.read()
assert old_content == b'OLD\n'
with runner.isolated_filesystem():
with open('foo.txt', 'wb') as f:
f.write(b'OLD\n')
result = runner.invoke(inout, ['foo.txt'], input='Hey!',
catch_exceptions=False)
assert result.output == ''
assert result.exit_code == 0
with open('foo.txt', 'rb') as f:
assert f.read() == b'Foo bar baz\n'
def test_stdout_default(runner):
@click.command()
@click.argument('output', type=click.File('w'), default='-')
def inout(output):
output.write('Foo bar baz\n')
output.flush()
result = runner.invoke(inout, [])
assert not result.exception
assert result.output == 'Foo bar baz\n'
def test_nargs_envvar(runner):
@click.command()
@click.option('--arg', nargs=2)
def cmd(arg):
click.echo('|'.join(arg))
result = runner.invoke(cmd, [], auto_envvar_prefix='TEST',
env={'TEST_ARG': 'foo bar'})
assert not result.exception
assert result.output == 'foo|bar\n'
@click.command()
@click.option('--arg', envvar='X', nargs=2)
def cmd(arg):
click.echo('|'.join(arg))
result = runner.invoke(cmd, [], env={'X': 'foo bar'})
assert not result.exception
assert result.output == 'foo|bar\n'
def test_empty_nargs(runner):
@click.command()
@click.argument('arg', nargs=-1)
def cmd(arg):
click.echo('arg:' + '|'.join(arg))
result = runner.invoke(cmd, [])
assert result.exit_code == 0
assert result.output == 'arg:\n'
@click.command()
@click.argument('arg', nargs=-1, required=True)
def cmd2(arg):
click.echo('arg:' + '|'.join(arg))
result = runner.invoke(cmd2, [])
assert result.exit_code == 2
assert 'Missing argument "arg"' in result.output
def test_missing_arg(runner):
@click.command()
@click.argument('arg')
def cmd(arg):
click.echo('arg:' + arg)
result = runner.invoke(cmd, [])
assert result.exit_code == 2
assert 'Missing argument "arg".' in result.output
def test_implicit_non_required(runner):
@click.command()
@click.argument('f', default='test')
def cli(f):
click.echo(f)
result = runner.invoke(cli, [])
assert result.exit_code == 0
assert result.output == 'test\n'
def test_eat_options(runner):
@click.command()
@click.option('-f')
@click.argument('files', nargs=-1)
def cmd(f, files):
for filename in files:
click.echo(filename)
click.echo(f)
result = runner.invoke(cmd, ['--', '-foo', 'bar'])
assert result.output.splitlines() == [
'-foo',
'bar',
'',
]
result = runner.invoke(cmd, ['-f', '-x', '--', '-foo', 'bar'])
assert result.output.splitlines() == [
'-foo',
'bar',
'-x',
]
def test_nargs_star_ordering(runner):
@click.command()
@click.argument('a', nargs=-1)
@click.argument('b')
@click.argument('c')
def cmd(a, b, c):
for arg in (a, b, c):
click.echo(arg)
result = runner.invoke(cmd, ['a', 'b', 'c'])
assert result.output.splitlines() == [
PY2 and "(u'a',)" or "('a',)",
'b',
'c',
]
def test_nargs_specified_plus_star_ordering(runner):
@click.command()
@click.argument('a', nargs=-1)
@click.argument('b')
@click.argument('c', nargs=2)
def cmd(a, b, c):
for arg in (a, b, c):
click.echo(arg)
result = runner.invoke(cmd, ['a', 'b', 'c', 'd', 'e', 'f'])
assert result.output.splitlines() == [
PY2 and "(u'a', u'b', u'c')" or "('a', 'b', 'c')",
'd',
PY2 and "(u'e', u'f')" or "('e', 'f')",
]
def test_defaults_for_nargs(runner):
@click.command()
@click.argument('a', nargs=2, type=int, default=(1, 2))
def cmd(a):
x, y = a
click.echo(x + y)
result = runner.invoke(cmd, [])
assert result.output.strip() == '3'
result = runner.invoke(cmd, ['3', '4'])
assert result.output.strip() == '7'
result = runner.invoke(cmd, ['3'])
assert result.exception is not None
assert 'argument a takes 2 values' in result.output
click-6.2/tests/test_basic.py 0000644 0000765 0000024 00000027320 12372607550 017454 0 ustar mitsuhiko staff 0000000 0000000 # -*- coding: utf-8 -*-
import os
import uuid
import click
def test_basic_functionality(runner):
@click.command()
def cli():
"""Hello World!"""
click.echo('I EXECUTED')
result = runner.invoke(cli, ['--help'])
assert not result.exception
assert 'Hello World!' in result.output
assert 'Show this message and exit.' in result.output
assert result.exit_code == 0
assert 'I EXECUTED' not in result.output
result = runner.invoke(cli, [])
assert not result.exception
assert 'I EXECUTED' in result.output
assert result.exit_code == 0
def test_return_values():
@click.command()
def cli():
return 42
with cli.make_context('foo', []) as ctx:
rv = cli.invoke(ctx)
assert rv is 42
def test_basic_group(runner):
@click.group()
def cli():
"""This is the root."""
click.echo('ROOT EXECUTED')
@cli.command()
def subcommand():
"""This is a subcommand."""
click.echo('SUBCOMMAND EXECUTED')
result = runner.invoke(cli, ['--help'])
assert not result.exception
assert 'COMMAND [ARGS]...' in result.output
assert 'This is the root' in result.output
assert 'This is a subcommand.' in result.output
assert result.exit_code == 0
assert 'ROOT EXECUTED' not in result.output
result = runner.invoke(cli, ['subcommand'])
assert not result.exception
assert result.exit_code == 0
assert 'ROOT EXECUTED' in result.output
assert 'SUBCOMMAND EXECUTED' in result.output
def test_basic_option(runner):
@click.command()
@click.option('--foo', default='no value')
def cli(foo):
click.echo('FOO:[%s]' % foo)
result = runner.invoke(cli, [])
assert not result.exception
assert 'FOO:[no value]' in result.output
result = runner.invoke(cli, ['--foo=42'])
assert not result.exception
assert 'FOO:[42]' in result.output
result = runner.invoke(cli, ['--foo'])
assert result.exception
assert '--foo option requires an argument' in result.output
result = runner.invoke(cli, ['--foo='])
assert not result.exception
assert 'FOO:[]' in result.output
result = runner.invoke(cli, [u'--foo=\N{SNOWMAN}'])
assert not result.exception
assert u'FOO:[\N{SNOWMAN}]' in result.output
def test_int_option(runner):
@click.command()
@click.option('--foo', default=42)
def cli(foo):
click.echo('FOO:[%s]' % (foo * 2))
result = runner.invoke(cli, [])
assert not result.exception
assert 'FOO:[84]' in result.output
result = runner.invoke(cli, ['--foo=23'])
assert not result.exception
assert 'FOO:[46]' in result.output
result = runner.invoke(cli, ['--foo=bar'])
assert result.exception
assert 'Invalid value for "--foo": bar is not a valid integer' \
in result.output
def test_uuid_option(runner):
@click.command()
@click.option('--u', default='ba122011-349f-423b-873b-9d6a79c688ab',
type=click.UUID)
def cli(u):
assert type(u) is uuid.UUID
click.echo('U:[%s]' % u)
result = runner.invoke(cli, [])
assert not result.exception
assert 'U:[ba122011-349f-423b-873b-9d6a79c688ab]' in result.output
result = runner.invoke(cli, ['--u=821592c1-c50e-4971-9cd6-e89dc6832f86'])
assert not result.exception
assert 'U:[821592c1-c50e-4971-9cd6-e89dc6832f86]' in result.output
result = runner.invoke(cli, ['--u=bar'])
assert result.exception
assert 'Invalid value for "--u": bar is not a valid UUID value' \
in result.output
def test_float_option(runner):
@click.command()
@click.option('--foo', default=42, type=click.FLOAT)
def cli(foo):
assert type(foo) is float
click.echo('FOO:[%s]' % foo)
result = runner.invoke(cli, [])
assert not result.exception
assert 'FOO:[42.0]' in result.output
result = runner.invoke(cli, ['--foo=23.5'])
assert not result.exception
assert 'FOO:[23.5]' in result.output
result = runner.invoke(cli, ['--foo=bar'])
assert result.exception
assert 'Invalid value for "--foo": bar is not a valid float' \
in result.output
def test_boolean_option(runner):
for default in True, False:
@click.command()
@click.option('--with-foo/--without-foo', default=default)
def cli(with_foo):
click.echo(with_foo)
result = runner.invoke(cli, ['--with-foo'])
assert not result.exception
assert result.output == 'True\n'
result = runner.invoke(cli, ['--without-foo'])
assert not result.exception
assert result.output == 'False\n'
result = runner.invoke(cli, [])
assert not result.exception
assert result.output == '%s\n' % default
for default in True, False:
@click.command()
@click.option('--flag', is_flag=True, default=default)
def cli(flag):
click.echo(flag)
result = runner.invoke(cli, ['--flag'])
assert not result.exception
assert result.output == '%s\n' % (not default)
result = runner.invoke(cli, [])
assert not result.exception
assert result.output == '%s\n' % (default)
def test_file_option(runner):
@click.command()
@click.option('--file', type=click.File('w'))
def input(file):
file.write('Hello World!\n')
@click.command()
@click.option('--file', type=click.File('r'))
def output(file):
click.echo(file.read())
with runner.isolated_filesystem():
result_in = runner.invoke(input, ['--file=example.txt'])
result_out = runner.invoke(output, ['--file=example.txt'])
assert not result_in.exception
assert result_in.output == ''
assert not result_out.exception
assert result_out.output == 'Hello World!\n\n'
def test_file_lazy_mode(runner):
do_io = False
@click.command()
@click.option('--file', type=click.File('w'))
def input(file):
if do_io:
file.write('Hello World!\n')
@click.command()
@click.option('--file', type=click.File('r'))
def output(file):
pass
with runner.isolated_filesystem():
os.mkdir('example.txt')
do_io = True
result_in = runner.invoke(input, ['--file=example.txt'])
assert result_in.exit_code == 1
do_io = False
result_in = runner.invoke(input, ['--file=example.txt'])
assert result_in.exit_code == 0
result_out = runner.invoke(output, ['--file=example.txt'])
assert result_out.exception
@click.command()
@click.option('--file', type=click.File('w', lazy=False))
def input_non_lazy(file):
file.write('Hello World!\n')
with runner.isolated_filesystem():
os.mkdir('example.txt')
result_in = runner.invoke(input_non_lazy, ['--file=example.txt'])
assert result_in.exit_code == 2
assert 'Invalid value for "--file": Could not open file: example.txt' \
in result_in.output
def test_path_option(runner):
@click.command()
@click.option('-O', type=click.Path(file_okay=False, exists=True,
writable=True))
def write_to_dir(o):
with open(os.path.join(o, 'foo.txt'), 'wb') as f:
f.write(b'meh\n')
with runner.isolated_filesystem():
os.mkdir('test')
result = runner.invoke(write_to_dir, ['-O', 'test'])
assert not result.exception
with open('test/foo.txt', 'rb') as f:
assert f.read() == b'meh\n'
result = runner.invoke(write_to_dir, ['-O', 'test/foo.txt'])
assert 'Invalid value for "-O": Directory "test/foo.txt" is a file.' \
in result.output
@click.command()
@click.option('-f', type=click.Path(exists=True))
def showtype(f):
click.echo('is_file=%s' % os.path.isfile(f))
click.echo('is_dir=%s' % os.path.isdir(f))
with runner.isolated_filesystem():
result = runner.invoke(showtype, ['-f', 'xxx'])
assert 'Error: Invalid value for "-f": Path "xxx" does not exist' \
in result.output
result = runner.invoke(showtype, ['-f', '.'])
assert 'is_file=False' in result.output
assert 'is_dir=True' in result.output
@click.command()
@click.option('-f', type=click.Path())
def exists(f):
click.echo('exists=%s' % os.path.exists(f))
with runner.isolated_filesystem():
result = runner.invoke(exists, ['-f', 'xxx'])
assert 'exists=False' in result.output
result = runner.invoke(exists, ['-f', '.'])
assert 'exists=True' in result.output
def test_choice_option(runner):
@click.command()
@click.option('--method', type=click.Choice(['foo', 'bar', 'baz']))
def cli(method):
click.echo(method)
result = runner.invoke(cli, ['--method=foo'])
assert not result.exception
assert result.output == 'foo\n'
result = runner.invoke(cli, ['--method=meh'])
assert result.exit_code == 2
assert 'Invalid value for "--method": invalid choice: meh. ' \
'(choose from foo, bar, baz)' in result.output
result = runner.invoke(cli, ['--help'])
assert '--method [foo|bar|baz]' in result.output
def test_int_range_option(runner):
@click.command()
@click.option('--x', type=click.IntRange(0, 5))
def cli(x):
click.echo(x)
result = runner.invoke(cli, ['--x=5'])
assert not result.exception
assert result.output == '5\n'
result = runner.invoke(cli, ['--x=6'])
assert result.exit_code == 2
assert 'Invalid value for "--x": 6 is not in the valid range of 0 to 5.\n' \
in result.output
@click.command()
@click.option('--x', type=click.IntRange(0, 5, clamp=True))
def clamp(x):
click.echo(x)
result = runner.invoke(clamp, ['--x=5'])
assert not result.exception
assert result.output == '5\n'
result = runner.invoke(clamp, ['--x=6'])
assert not result.exception
assert result.output == '5\n'
result = runner.invoke(clamp, ['--x=-1'])
assert not result.exception
assert result.output == '0\n'
def test_required_option(runner):
@click.command()
@click.option('--foo', required=True)
def cli(foo):
click.echo(foo)
result = runner.invoke(cli, [])
assert result.exit_code == 2
assert 'Missing option "--foo"' in result.output
def test_evaluation_order(runner):
called = []
def memo(ctx, value):
called.append(value)
return value
@click.command()
@click.option('--missing', default='missing',
is_eager=False, callback=memo)
@click.option('--eager-flag1', flag_value='eager1',
is_eager=True, callback=memo)
@click.option('--eager-flag2', flag_value='eager2',
is_eager=True, callback=memo)
@click.option('--eager-flag3', flag_value='eager3',
is_eager=True, callback=memo)
@click.option('--normal-flag1', flag_value='normal1',
is_eager=False, callback=memo)
@click.option('--normal-flag2', flag_value='normal2',
is_eager=False, callback=memo)
@click.option('--normal-flag3', flag_value='normal3',
is_eager=False, callback=memo)
def cli(**x):
pass
result = runner.invoke(cli, ['--eager-flag2',
'--eager-flag1',
'--normal-flag2',
'--eager-flag3',
'--normal-flag3',
'--normal-flag3',
'--normal-flag1',
'--normal-flag1'])
assert not result.exception
assert called == [
'eager2',
'eager1',
'eager3',
'normal2',
'normal3',
'normal1',
'missing',
]
click-6.2/tests/test_chain.py 0000644 0000765 0000024 00000013112 12626037411 017442 0 ustar mitsuhiko staff 0000000 0000000 import sys
import click
import pytest
def debug():
click.echo('%s=%s' % (
sys._getframe(1).f_code.co_name,
'|'.join(click.get_current_context().args),
))
def test_basic_chaining(runner):
@click.group(chain=True)
def cli():
pass
@cli.command('sdist')
def sdist():
click.echo('sdist called')
@cli.command('bdist')
def bdist():
click.echo('bdist called')
result = runner.invoke(cli, ['bdist', 'sdist', 'bdist'])
assert not result.exception
assert result.output.splitlines() == [
'bdist called',
'sdist called',
'bdist called',
]
def test_chaining_help(runner):
@click.group(chain=True)
def cli():
"""ROOT HELP"""
pass
@cli.command('sdist')
def sdist():
"""SDIST HELP"""
click.echo('sdist called')
@cli.command('bdist')
def bdist():
"""BDIST HELP"""
click.echo('bdist called')
result = runner.invoke(cli, ['--help'])
assert not result.exception
assert 'COMMAND1 [ARGS]... [COMMAND2 [ARGS]...]...' in result.output
assert 'ROOT HELP' in result.output
result = runner.invoke(cli, ['sdist', '--help'])
assert not result.exception
assert 'SDIST HELP' in result.output
result = runner.invoke(cli, ['bdist', '--help'])
assert not result.exception
assert 'BDIST HELP' in result.output
result = runner.invoke(cli, ['bdist', 'sdist', '--help'])
assert not result.exception
assert 'SDIST HELP' in result.output
def test_chaining_with_options(runner):
@click.group(chain=True)
def cli():
pass
@cli.command('sdist')
@click.option('--format')
def sdist(format):
click.echo('sdist called %s' % format)
@cli.command('bdist')
@click.option('--format')
def bdist(format):
click.echo('bdist called %s' % format)
result = runner.invoke(cli, ['bdist', '--format=1', 'sdist', '--format=2'])
assert not result.exception
assert result.output.splitlines() == [
'bdist called 1',
'sdist called 2',
]
def test_chaining_with_arguments(runner):
@click.group(chain=True)
def cli():
pass
@cli.command('sdist')
@click.argument('format')
def sdist(format):
click.echo('sdist called %s' % format)
@cli.command('bdist')
@click.argument('format')
def bdist(format):
click.echo('bdist called %s' % format)
result = runner.invoke(cli, ['bdist', '1', 'sdist', '2'])
assert not result.exception
assert result.output.splitlines() == [
'bdist called 1',
'sdist called 2',
]
def test_pipeline(runner):
@click.group(chain=True, invoke_without_command=True)
@click.option('-i', '--input', type=click.File('r'))
def cli(input):
pass
@cli.resultcallback()
def process_pipeline(processors, input):
iterator = (x.rstrip('\r\n') for x in input)
for processor in processors:
iterator = processor(iterator)
for item in iterator:
click.echo(item)
@cli.command('uppercase')
def make_uppercase():
def processor(iterator):
for line in iterator:
yield line.upper()
return processor
@cli.command('strip')
def make_strip():
def processor(iterator):
for line in iterator:
yield line.strip()
return processor
result = runner.invoke(cli, ['-i', '-'], input='foo\nbar')
assert not result.exception
assert result.output.splitlines() == [
'foo',
'bar',
]
result = runner.invoke(cli, ['-i', '-', 'strip'], input='foo \n bar')
assert not result.exception
assert result.output.splitlines() == [
'foo',
'bar',
]
result = runner.invoke(cli, ['-i', '-', 'strip', 'uppercase'],
input='foo \n bar')
assert not result.exception
assert result.output.splitlines() == [
'FOO',
'BAR',
]
def test_args_and_chain(runner):
@click.group(chain=True)
def cli():
debug()
@cli.command()
def a():
debug()
@cli.command()
def b():
debug()
@cli.command()
def c():
debug()
result = runner.invoke(cli, ['a', 'b', 'c'])
assert not result.exception
assert result.output.splitlines() == [
'cli=',
'a=',
'b=',
'c=',
]
def test_multicommand_arg_behavior(runner):
with pytest.raises(RuntimeError):
@click.group(chain=True)
@click.argument('forbidden', required=False)
def bad_cli():
pass
with pytest.raises(RuntimeError):
@click.group(chain=True)
@click.argument('forbidden', nargs=-1)
def bad_cli2():
pass
@click.group(chain=True)
@click.argument('arg')
def cli(arg):
click.echo('cli:%s' % arg)
@cli.command()
def a():
click.echo('a')
result = runner.invoke(cli, ['foo', 'a'])
assert not result.exception
assert result.output.splitlines() == [
'cli:foo',
'a',
]
@pytest.mark.xfail
def test_multicommand_chaining(runner):
@click.group(chain=True)
def cli():
debug()
@cli.group()
def l1a():
debug()
@l1a.command()
def l2a():
debug()
@l1a.command()
def l2b():
debug()
@cli.command()
def l1b():
debug()
result = runner.invoke(cli, ['l1a', 'l2a', 'l1b'])
assert not result.exception
assert result.output.splitlines() == [
'cli=',
'l1a=',
'l2a=',
'l1b=',
]
click-6.2/tests/test_commands.py 0000644 0000765 0000024 00000015712 12532050116 020162 0 ustar mitsuhiko staff 0000000 0000000 # -*- coding: utf-8 -*-
import re
import click
def test_other_command_invoke(runner):
@click.command()
@click.pass_context
def cli(ctx):
return ctx.invoke(other_cmd, arg=42)
@click.command()
@click.argument('arg', type=click.INT)
def other_cmd(arg):
click.echo(arg)
result = runner.invoke(cli, [])
assert not result.exception
assert result.output == '42\n'
def test_other_command_forward(runner):
cli = click.Group()
@cli.command()
@click.option('--count', default=1)
def test(count):
click.echo('Count: %d' % count)
@cli.command()
@click.option('--count', default=1)
@click.pass_context
def dist(ctx, count):
ctx.forward(test)
ctx.invoke(test, count=42)
result = runner.invoke(cli, ['dist'])
assert not result.exception
assert result.output == 'Count: 1\nCount: 42\n'
def test_auto_shorthelp(runner):
@click.group()
def cli():
pass
@cli.command()
def short():
"""This is a short text."""
@cli.command()
def special_chars():
"""Login and store the token in ~/.netrc."""
@cli.command()
def long():
"""This is a long text that is too long to show as short help
and will be truncated instead."""
result = runner.invoke(cli, ['--help'])
assert re.search(
r'Commands:\n\s+'
r'long\s+This is a long text that is too long to show\.\.\.\n\s+'
r'short\s+This is a short text\.\n\s+'
r'special_chars\s+Login and store the token in ~/.netrc\.\s*',
result.output) is not None
def test_default_maps(runner):
@click.group()
def cli():
pass
@cli.command()
@click.option('--name', default='normal')
def foo(name):
click.echo(name)
result = runner.invoke(cli, ['foo'], default_map={
'foo': {'name': 'changed'}
})
assert not result.exception
assert result.output == 'changed\n'
def test_group_with_args(runner):
@click.group()
@click.argument('obj')
def cli(obj):
click.echo('obj=%s' % obj)
@cli.command()
def move():
click.echo('move')
result = runner.invoke(cli, [])
assert result.exit_code == 0
assert 'Show this message and exit.' in result.output
result = runner.invoke(cli, ['obj1'])
assert result.exit_code == 2
assert 'Error: Missing command.' in result.output
result = runner.invoke(cli, ['obj1', '--help'])
assert result.exit_code == 0
assert 'Show this message and exit.' in result.output
result = runner.invoke(cli, ['obj1', 'move'])
assert result.exit_code == 0
assert result.output == 'obj=obj1\nmove\n'
def test_base_command(runner):
import optparse
@click.group()
def cli():
pass
class OptParseCommand(click.BaseCommand):
def __init__(self, name, parser, callback):
click.BaseCommand.__init__(self, name)
self.parser = parser
self.callback = callback
def parse_args(self, ctx, args):
try:
opts, args = parser.parse_args(args)
except Exception as e:
ctx.fail(str(e))
ctx.args = args
ctx.params = vars(opts)
def get_usage(self, ctx):
return self.parser.get_usage()
def get_help(self, ctx):
return self.parser.format_help()
def invoke(self, ctx):
ctx.invoke(self.callback, ctx.args, **ctx.params)
parser = optparse.OptionParser(usage='Usage: foo test [OPTIONS]')
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")
def test_callback(args, filename, verbose):
click.echo(' '.join(args))
click.echo(filename)
click.echo(verbose)
cli.add_command(OptParseCommand('test', parser, test_callback))
result = runner.invoke(cli, ['test', '-f', 'test.txt', '-q',
'whatever.txt', 'whateverelse.txt'])
assert not result.exception
assert result.output.splitlines() == [
'whatever.txt whateverelse.txt',
'test.txt',
'False',
]
result = runner.invoke(cli, ['test', '--help'])
assert not result.exception
assert result.output.splitlines() == [
'Usage: foo test [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',
]
def test_object_propagation(runner):
for chain in False, True:
@click.group(chain=chain)
@click.option('--debug/--no-debug', default=False)
@click.pass_context
def cli(ctx, debug):
if ctx.obj is None:
ctx.obj = {}
ctx.obj['DEBUG'] = debug
@cli.command()
@click.pass_context
def sync(ctx):
click.echo('Debug is %s' % (ctx.obj['DEBUG'] and 'on' or 'off'))
result = runner.invoke(cli, ['sync'])
assert result.exception is None
assert result.output == 'Debug is off\n'
def test_other_command_invoke_with_defaults(runner):
@click.command()
@click.pass_context
def cli(ctx):
return ctx.invoke(other_cmd)
@click.command()
@click.option('--foo', type=click.INT, default=42)
@click.pass_context
def other_cmd(ctx, foo):
assert ctx.info_name == 'other_cmd'
click.echo(foo)
result = runner.invoke(cli, [])
assert not result.exception
assert result.output == '42\n'
def test_invoked_subcommand(runner):
@click.group(invoke_without_command=True)
@click.pass_context
def cli(ctx):
if ctx.invoked_subcommand is None:
click.echo('no subcommand, use default')
ctx.invoke(sync)
else:
click.echo('invoke subcommand')
@cli.command()
def sync():
click.echo('in subcommand')
result = runner.invoke(cli, ['sync'])
assert not result.exception
assert result.output == 'invoke subcommand\nin subcommand\n'
result = runner.invoke(cli)
assert not result.exception
assert result.output == 'no subcommand, use default\nin subcommand\n'
def test_unprocessed_options(runner):
@click.command(context_settings=dict(
ignore_unknown_options=True
))
@click.argument('args', nargs=-1, type=click.UNPROCESSED)
@click.option('--verbose', '-v', count=True)
def cli(verbose, args):
click.echo('Verbosity: %s' % verbose)
click.echo('Args: %s' % '|'.join(args))
result = runner.invoke(cli, ['-foo', '-vvvvx', '--muhaha', 'x', 'y', '-x'])
assert not result.exception
assert result.output.splitlines() == [
'Verbosity: 4',
'Args: -foo|-x|--muhaha|x|y|-x',
]
click-6.2/tests/test_compat.py 0000644 0000765 0000024 00000001400 12506470624 017644 0 ustar mitsuhiko staff 0000000 0000000 import click
if click.__version__ >= '3.0':
def test_legacy_callbacks(runner):
def legacy_callback(ctx, value):
return value.upper()
@click.command()
@click.option('--foo', callback=legacy_callback)
def cli(foo):
click.echo(foo)
result = runner.invoke(cli, ['--foo', 'wat'])
assert result.exit_code == 0
assert 'WAT' in result.output
assert 'Invoked legacy parameter callback' in result.output
def test_bash_func_name():
from click._bashcomplete import get_completion_script
script = get_completion_script('foo-bar baz_blah', '_COMPLETE_VAR').strip()
assert script.startswith('_foo_barbaz_blah_completion()')
assert '_COMPLETE_VAR=complete $1' in script
click-6.2/tests/test_context.py 0000644 0000765 0000024 00000010530 12576130134 020045 0 ustar mitsuhiko staff 0000000 0000000 # -*- coding: utf-8 -*-
import click
def test_ensure_context_objects(runner):
class Foo(object):
def __init__(self):
self.title = 'default'
pass_foo = click.make_pass_decorator(Foo, ensure=True)
@click.group()
@pass_foo
def cli(foo):
pass
@cli.command()
@pass_foo
def test(foo):
click.echo(foo.title)
result = runner.invoke(cli, ['test'])
assert not result.exception
assert result.output == 'default\n'
def test_get_context_objects(runner):
class Foo(object):
def __init__(self):
self.title = 'default'
pass_foo = click.make_pass_decorator(Foo, ensure=True)
@click.group()
@click.pass_context
def cli(ctx):
ctx.obj = Foo()
ctx.obj.title = 'test'
@cli.command()
@pass_foo
def test(foo):
click.echo(foo.title)
result = runner.invoke(cli, ['test'])
assert not result.exception
assert result.output == 'test\n'
def test_get_context_objects_no_ensuring(runner):
class Foo(object):
def __init__(self):
self.title = 'default'
pass_foo = click.make_pass_decorator(Foo)
@click.group()
@click.pass_context
def cli(ctx):
ctx.obj = Foo()
ctx.obj.title = 'test'
@cli.command()
@pass_foo
def test(foo):
click.echo(foo.title)
result = runner.invoke(cli, ['test'])
assert not result.exception
assert result.output == 'test\n'
def test_get_context_objects_missing(runner):
class Foo(object):
pass
pass_foo = click.make_pass_decorator(Foo)
@click.group()
@click.pass_context
def cli(ctx):
pass
@cli.command()
@pass_foo
def test(foo):
click.echo(foo.title)
result = runner.invoke(cli, ['test'])
assert result.exception is not None
assert isinstance(result.exception, RuntimeError)
assert "Managed to invoke callback without a context object " \
"of type 'Foo' existing" in str(result.exception)
def test_multi_enter(runner):
called = []
@click.command()
@click.pass_context
def cli(ctx):
def callback():
called.append(True)
ctx.call_on_close(callback)
with ctx:
pass
assert not called
result = runner.invoke(cli, [])
assert result.exception is None
assert called == [True]
def test_global_context_object(runner):
@click.command()
@click.pass_context
def cli(ctx):
assert click.get_current_context() is ctx
ctx.obj = 'FOOBAR'
assert click.get_current_context().obj == 'FOOBAR'
assert click.get_current_context(silent=True) is None
runner.invoke(cli, [], catch_exceptions=False)
assert click.get_current_context(silent=True) is None
def test_context_meta(runner):
LANG_KEY = __name__ + '.lang'
def set_language(value):
click.get_current_context().meta[LANG_KEY] = value
def get_language():
return click.get_current_context().meta.get(LANG_KEY, 'en_US')
@click.command()
@click.pass_context
def cli(ctx):
assert get_language() == 'en_US'
set_language('de_DE')
assert get_language() == 'de_DE'
runner.invoke(cli, [], catch_exceptions=False)
def test_context_pushing():
rv = []
@click.command()
def cli():
pass
ctx = click.Context(cli)
@ctx.call_on_close
def test_callback():
rv.append(42)
with ctx.scope(cleanup=False):
# Internal
assert ctx._depth == 2
assert rv == []
with ctx.scope():
# Internal
assert ctx._depth == 1
assert rv == [42]
def test_pass_obj(runner):
@click.group()
@click.pass_context
def cli(ctx):
ctx.obj = 'test'
@cli.command()
@click.pass_obj
def test(obj):
click.echo(obj)
result = runner.invoke(cli, ['test'])
assert not result.exception
assert result.output == 'test\n'
def test_close_before_pop(runner):
called = []
@click.command()
@click.pass_context
def cli(ctx):
ctx.obj = 'test'
@ctx.call_on_close
def foo():
assert click.get_current_context().obj == 'test'
called.append(True)
click.echo('aha!')
result = runner.invoke(cli, [])
assert not result.exception
assert result.output == 'aha!\n'
assert called == [True]
click-6.2/tests/test_defaults.py 0000644 0000765 0000024 00000002175 12372607550 020203 0 ustar mitsuhiko staff 0000000 0000000 import click
def test_basic_defaults(runner):
@click.command()
@click.option('--foo', default=42, type=click.FLOAT)
def cli(foo):
assert type(foo) is float
click.echo('FOO:[%s]' % foo)
result = runner.invoke(cli, [])
assert not result.exception
assert 'FOO:[42.0]' in result.output
def test_multiple_defaults(runner):
@click.command()
@click.option('--foo', default=[23, 42], type=click.FLOAT,
multiple=True)
def cli(foo):
for item in foo:
assert type(item) is float
click.echo(item)
result = runner.invoke(cli, [])
assert not result.exception
assert result.output.splitlines() == [
'23.0',
'42.0',
]
def test_nargs_plus_multiple(runner):
@click.command()
@click.option('--arg', default=((1, 2), (3, 4)),
nargs=2, multiple=True, type=click.INT)
def cli(arg):
for item in arg:
click.echo('<%d|%d>' % item)
result = runner.invoke(cli, [])
assert not result.exception
assert result.output.splitlines() == [
'<1|2>',
'<3|4>',
]
click-6.2/tests/test_formatting.py 0000644 0000765 0000024 00000006736 12551270727 020556 0 ustar mitsuhiko staff 0000000 0000000 # -*- coding: utf-8 -*-
import click
def test_basic_functionality(runner):
@click.command()
def cli():
"""First paragraph.
This is a very long second
paragraph and not correctly
wrapped but it will be rewrapped.
\b
This is
a paragraph
without rewrapping.
\b
1
2
3
And this is a paragraph
that will be rewrapped again.
"""
result = runner.invoke(cli, ['--help'], terminal_width=60)
assert not result.exception
assert result.output.splitlines() == [
'Usage: cli [OPTIONS]',
'',
' First paragraph.',
'',
' This is a very long second paragraph and not correctly',
' wrapped but it will be rewrapped.',
'',
' This is',
' a paragraph',
' without rewrapping.',
'',
' 1',
' 2',
' 3',
'',
' And this is a paragraph that will be rewrapped again.',
'',
'Options:',
' --help Show this message and exit.',
]
def test_wrapping_long_options_strings(runner):
@click.group()
def cli():
"""Top level command
"""
@cli.group()
def a_very_long():
"""Second level
"""
@a_very_long.command()
@click.argument('first')
@click.argument('second')
@click.argument('third')
@click.argument('fourth')
@click.argument('fifth')
@click.argument('sixth')
def command():
"""A command.
"""
# 54 is chosen as a length where the second line is one character
# longer than the maximum length.
result = runner.invoke(cli, ['a_very_long', 'command', '--help'],
terminal_width=54)
assert not result.exception
assert result.output.splitlines() == [
'Usage: cli a_very_long command [OPTIONS] FIRST SECOND',
' THIRD FOURTH FIFTH',
' SIXTH',
'',
' A command.',
'',
'Options:',
' --help Show this message and exit.',
]
def test_wrapping_long_command_name(runner):
@click.group()
def cli():
"""Top level command
"""
@cli.group()
def a_very_very_very_long():
"""Second level
"""
@a_very_very_very_long.command()
@click.argument('first')
@click.argument('second')
@click.argument('third')
@click.argument('fourth')
@click.argument('fifth')
@click.argument('sixth')
def command():
"""A command.
"""
result = runner.invoke(cli, ['a_very_very_very_long', 'command', '--help'],
terminal_width=54)
assert not result.exception
assert result.output.splitlines() == [
'Usage: cli a_very_very_very_long command ',
' [OPTIONS] FIRST SECOND THIRD FOURTH FIFTH',
' SIXTH',
'',
' A command.',
'',
'Options:',
' --help Show this message and exit.',
]
def test_formatting_empty_help_lines(runner):
@click.command()
def cli():
"""Top level command
"""
result = runner.invoke(cli, ['--help'])
assert not result.exception
assert result.output.splitlines() == [
'Usage: cli [OPTIONS]',
'',
' Top level command',
'',
'',
'',
'Options:',
' --help Show this message and exit.',
]
click-6.2/tests/test_imports.py 0000644 0000765 0000024 00000002613 12617110030 020046 0 ustar mitsuhiko staff 0000000 0000000 import sys
import json
import subprocess
from click._compat import WIN
IMPORT_TEST = b'''\
try:
import __builtin__ as builtins
except ImportError:
import builtins
found_imports = set()
real_import = builtins.__import__
import sys
def tracking_import(module, locals=None, globals=None, fromlist=None,
level=0):
rv = real_import(module, locals, globals, fromlist, level)
if globals and globals['__name__'].startswith('click') and level == 0:
found_imports.add(module)
return rv
builtins.__import__ = tracking_import
import click
rv = list(found_imports)
import json
click.echo(json.dumps(rv))
'''
ALLOWED_IMPORTS = set([
'weakref', 'os', 'struct', 'collections', 'sys', 'contextlib',
'functools', 'stat', 're', 'codecs', 'inspect', 'itertools', 'io',
'threading', 'colorama'
])
if WIN:
ALLOWED_IMPORTS.update(['ctypes', 'ctypes.wintypes', 'msvcrt', 'time',
'zlib'])
def test_light_imports():
c = subprocess.Popen([sys.executable, '-'], stdin=subprocess.PIPE,
stdout=subprocess.PIPE)
rv = c.communicate(IMPORT_TEST)[0]
if sys.version_info[0] != 2:
rv = rv.decode('utf-8')
imported = json.loads(rv)
print(imported)
for module in imported:
if module == 'click' or module.startswith('click.'):
continue
assert module in ALLOWED_IMPORTS
click-6.2/tests/test_normalization.py 0000644 0000765 0000024 00000001673 12370501774 021263 0 ustar mitsuhiko staff 0000000 0000000 import click
CONTEXT_SETTINGS = dict(token_normalize_func=lambda x: x.lower())
def test_option_normalization(runner):
@click.command(context_settings=CONTEXT_SETTINGS)
@click.option('--foo')
@click.option('-x')
def cli(foo, x):
click.echo(foo)
click.echo(x)
result = runner.invoke(cli, ['--FOO', '42', '-X', 23])
assert result.output == '42\n23\n'
def test_choice_normalization(runner):
@click.command(context_settings=CONTEXT_SETTINGS)
@click.option('--choice', type=click.Choice(['Foo', 'Bar']))
def cli(choice):
click.echo('Foo')
result = runner.invoke(cli, ['--CHOICE', 'FOO'])
assert result.output == 'Foo\n'
def test_command_normalization(runner):
@click.group(context_settings=CONTEXT_SETTINGS)
def cli():
pass
@cli.command()
def foo():
click.echo('here!')
result = runner.invoke(cli, ['FOO'])
assert result.output == 'here!\n'
click-6.2/tests/test_options.py 0000644 0000765 0000024 00000023711 12616641542 020066 0 ustar mitsuhiko staff 0000000 0000000 # -*- coding: utf-8 -*-
import re
import os
import click
import pytest
from click._compat import text_type
def test_prefixes(runner):
@click.command()
@click.option('++foo', is_flag=True, help='das foo')
@click.option('--bar', is_flag=True, help='das bar')
def cli(foo, bar):
click.echo('foo=%s bar=%s' % (foo, bar))
result = runner.invoke(cli, ['++foo', '--bar'])
assert not result.exception
assert result.output == 'foo=True bar=True\n'
result = runner.invoke(cli, ['--help'])
assert re.search(r'\+\+foo\s+das foo', result.output) is not None
assert re.search(r'--bar\s+das bar', result.output) is not None
def test_invalid_option(runner):
try:
@click.command()
@click.option('foo')
def cli(foo):
pass
except TypeError as e:
assert 'No options defined but a name was passed (foo).' \
in str(e)
else:
assert False, 'Expected a type error because of an invalid option.'
def test_invalid_nargs(runner):
try:
@click.command()
@click.option('--foo', nargs=-1)
def cli(foo):
pass
except TypeError as e:
assert 'Options cannot have nargs < 0' in str(e)
else:
assert False, 'Expected a type error because of an invalid option.'
def test_nargs_tup_composite_mult(runner):
@click.command()
@click.option('--item', type=(str, int), multiple=True)
def copy(item):
for item in item:
click.echo('name=%s id=%d' % item)
result = runner.invoke(copy, ['--item', 'peter', '1', '--item', 'max', '2'])
assert not result.exception
assert result.output.splitlines() == [
'name=peter id=1',
'name=max id=2',
]
def test_counting(runner):
@click.command()
@click.option('-v', count=True, help='Verbosity',
type=click.IntRange(0, 3))
def cli(v):
click.echo('verbosity=%d' % v)
result = runner.invoke(cli, ['-vvv'])
assert not result.exception
assert result.output == 'verbosity=3\n'
result = runner.invoke(cli, ['-vvvv'])
assert result.exception
assert 'Invalid value for "-v": 4 is not in the valid range of 0 to 3.' \
in result.output
result = runner.invoke(cli, [])
assert not result.exception
assert result.output == 'verbosity=0\n'
result = runner.invoke(cli, ['--help'])
assert re.search('-v\s+Verbosity', result.output) is not None
@pytest.mark.parametrize('unknown_flag', ['--foo', '-f'])
def test_unknown_options(runner, unknown_flag):
@click.command()
def cli():
pass
result = runner.invoke(cli, [unknown_flag])
assert result.exception
assert 'no such option: {0}'.format(unknown_flag) in result.output
def test_multiple_required(runner):
@click.command()
@click.option('-m', '--message', multiple=True, required=True)
def cli(message):
click.echo('\n'.join(message))
result = runner.invoke(cli, ['-m', 'foo', '-mbar'])
assert not result.exception
assert result.output == 'foo\nbar\n'
result = runner.invoke(cli, [])
assert result.exception
assert 'Error: Missing option "-m" / "--message".' in result.output
def test_multiple_envvar(runner):
@click.command()
@click.option('--arg', multiple=True)
def cmd(arg):
click.echo('|'.join(arg))
result = runner.invoke(cmd, [], auto_envvar_prefix='TEST',
env={'TEST_ARG': 'foo bar baz'})
assert not result.exception
assert result.output == 'foo|bar|baz\n'
@click.command()
@click.option('--arg', multiple=True, envvar='X')
def cmd(arg):
click.echo('|'.join(arg))
result = runner.invoke(cmd, [], env={'X': 'foo bar baz'})
assert not result.exception
assert result.output == 'foo|bar|baz\n'
@click.command()
@click.option('--arg', multiple=True, type=click.Path())
def cmd(arg):
click.echo('|'.join(arg))
result = runner.invoke(cmd, [], auto_envvar_prefix='TEST',
env={'TEST_ARG': 'foo%sbar' % os.path.pathsep})
assert not result.exception
assert result.output == 'foo|bar\n'
def test_multiple_default_help(runner):
@click.command()
@click.option('--arg1', multiple=True, default=('foo', 'bar'),
show_default=True)
@click.option('--arg2', multiple=True, default=(1, 2), type=int,
show_default=True)
def cmd(arg, arg2):
pass
result = runner.invoke(cmd, ['--help'])
assert not result.exception
assert 'foo, bar' in result.output
assert '1, 2' in result.output
def test_multiple_default_type(runner):
@click.command()
@click.option('--arg1', multiple=True, default=('foo', 'bar'))
@click.option('--arg2', multiple=True, default=(1, 'a'))
def cmd(arg1, arg2):
assert all(isinstance(e[0], text_type) for e in arg1)
assert all(isinstance(e[1], text_type) for e in arg1)
assert all(isinstance(e[0], int) for e in arg2)
assert all(isinstance(e[1], text_type) for e in arg2)
result = runner.invoke(cmd, '--arg1 a b --arg1 test 1 --arg2 2 '
'two --arg2 4 four'.split())
assert not result.exception
def test_nargs_envvar(runner):
@click.command()
@click.option('--arg', nargs=2)
def cmd(arg):
click.echo('|'.join(arg))
result = runner.invoke(cmd, [], auto_envvar_prefix='TEST',
env={'TEST_ARG': 'foo bar'})
assert not result.exception
assert result.output == 'foo|bar\n'
@click.command()
@click.option('--arg', nargs=2, multiple=True)
def cmd(arg):
for item in arg:
click.echo('|'.join(item))
result = runner.invoke(cmd, [], auto_envvar_prefix='TEST',
env={'TEST_ARG': 'x 1 y 2'})
assert not result.exception
assert result.output == 'x|1\ny|2\n'
def test_custom_validation(runner):
def validate_pos_int(ctx, value):
if value < 0:
raise click.BadParameter('Value needs to be positive')
return value
@click.command()
@click.option('--foo', callback=validate_pos_int, default=1)
def cmd(foo):
click.echo(foo)
result = runner.invoke(cmd, ['--foo', '-1'])
assert 'Invalid value for "--foo": Value needs to be positive' \
in result.output
result = runner.invoke(cmd, ['--foo', '42'])
assert result.output == '42\n'
def test_winstyle_options(runner):
@click.command()
@click.option('/debug;/no-debug', help='Enables or disables debug mode.')
def cmd(debug):
click.echo(debug)
result = runner.invoke(cmd, ['/debug'], help_option_names=['/?'])
assert result.output == 'True\n'
result = runner.invoke(cmd, ['/no-debug'], help_option_names=['/?'])
assert result.output == 'False\n'
result = runner.invoke(cmd, [], help_option_names=['/?'])
assert result.output == 'False\n'
result = runner.invoke(cmd, ['/?'], help_option_names=['/?'])
assert '/debug; /no-debug Enables or disables debug mode.' in result.output
assert '/? Show this message and exit.' in result.output
def test_legacy_options(runner):
@click.command()
@click.option('-whatever')
def cmd(whatever):
click.echo(whatever)
result = runner.invoke(cmd, ['-whatever', '42'])
assert result.output == '42\n'
result = runner.invoke(cmd, ['-whatever=23'])
assert result.output == '23\n'
def test_missing_choice(runner):
@click.command()
@click.option('--foo', type=click.Choice(['foo', 'bar']),
required=True)
def cmd(foo):
click.echo(foo)
result = runner.invoke(cmd)
assert result.exit_code == 2
assert 'Error: Missing option "--foo". Choose from foo, bar.' \
in result.output
def test_multiline_help(runner):
@click.command()
@click.option('--foo', help="""
hello
i am
multiline
""")
def cmd(foo):
click.echo(foo)
result = runner.invoke(cmd, ['--help'])
assert result.exit_code == 0
out = result.output.splitlines()
assert ' --foo TEXT hello' in out
assert ' i am' in out
assert ' multiline' in out
def test_argument_custom_class(runner):
class CustomArgument(click.Argument):
def get_default(self, ctx):
'''a dumb override of a default value for testing'''
return 'I am a default'
@click.command()
@click.argument('testarg', cls=CustomArgument, default='you wont see me')
def cmd(testarg):
click.echo(testarg)
result = runner.invoke(cmd)
assert 'I am a default' in result.output
assert 'you wont see me' not in result.output
def test_option_custom_class(runner):
class CustomOption(click.Option):
def get_help_record(self, ctx):
'''a dumb override of a help text for testing'''
return ('--help', 'I am a help text')
@click.command()
@click.option('--testoption', cls=CustomOption, help='you wont see me')
def cmd(testoption):
click.echo(testoption)
result = runner.invoke(cmd, ['--help'])
assert 'I am a help text' in result.output
assert 'you wont see me' not in result.output
def test_aliases_for_flags(runner):
@click.command()
@click.option('--warnings/--no-warnings', ' /-W', default=True)
def cli(warnings):
click.echo(warnings)
result = runner.invoke(cli, ['--warnings'])
assert result.output == 'True\n'
result = runner.invoke(cli, ['--no-warnings'])
assert result.output == 'False\n'
result = runner.invoke(cli, ['-W'])
assert result.output == 'False\n'
@click.command()
@click.option('--warnings/--no-warnings', '-w', default=True)
def cli_alt(warnings):
click.echo(warnings)
result = runner.invoke(cli_alt, ['--warnings'])
assert result.output == 'True\n'
result = runner.invoke(cli_alt, ['--no-warnings'])
assert result.output == 'False\n'
result = runner.invoke(cli_alt, ['-w'])
assert result.output == 'True\n'
click-6.2/tests/test_termui.py 0000644 0000765 0000024 00000000612 12372607550 017673 0 ustar mitsuhiko staff 0000000 0000000 import click
def test_progressbar_strip_regression(runner, monkeypatch):
label = ' padded line'
@click.command()
def cli():
with click.progressbar(tuple(range(10)), label=label) as progress:
for thing in progress:
pass
monkeypatch.setattr(click._termui_impl, 'isatty', lambda _: True)
assert label in runner.invoke(cli, []).output
click-6.2/tests/test_testing.py 0000644 0000765 0000024 00000011071 12616754233 020046 0 ustar mitsuhiko staff 0000000 0000000 import sys
import pytest
import click
from click.testing import CliRunner
from click._compat import PY2, WIN
# Use the most reasonable io that users would use for the python version.
if PY2:
from cStringIO import StringIO as ReasonableBytesIO
else:
from io import BytesIO as ReasonableBytesIO
def test_runner():
@click.command()
def test():
i = click.get_binary_stream('stdin')
o = click.get_binary_stream('stdout')
while 1:
chunk = i.read(4096)
if not chunk:
break
o.write(chunk)
o.flush()
runner = CliRunner()
result = runner.invoke(test, input='Hello World!\n')
assert not result.exception
assert result.output == 'Hello World!\n'
runner = CliRunner(echo_stdin=True)
result = runner.invoke(test, input='Hello World!\n')
assert not result.exception
assert result.output == 'Hello World!\nHello World!\n'
def test_runner_with_stream():
@click.command()
def test():
i = click.get_binary_stream('stdin')
o = click.get_binary_stream('stdout')
while 1:
chunk = i.read(4096)
if not chunk:
break
o.write(chunk)
o.flush()
runner = CliRunner()
result = runner.invoke(test, input=ReasonableBytesIO(b'Hello World!\n'))
assert not result.exception
assert result.output == 'Hello World!\n'
runner = CliRunner(echo_stdin=True)
result = runner.invoke(test, input=ReasonableBytesIO(b'Hello World!\n'))
assert not result.exception
assert result.output == 'Hello World!\nHello World!\n'
def test_prompts():
@click.command()
@click.option('--foo', prompt=True)
def test(foo):
click.echo('foo=%s' % foo)
runner = CliRunner()
result = runner.invoke(test, input='wau wau\n')
assert not result.exception
assert result.output == 'Foo: wau wau\nfoo=wau wau\n'
@click.command()
@click.option('--foo', prompt=True, hide_input=True)
def test(foo):
click.echo('foo=%s' % foo)
runner = CliRunner()
result = runner.invoke(test, input='wau wau\n')
assert not result.exception
assert result.output == 'Foo: \nfoo=wau wau\n'
def test_getchar():
@click.command()
def continue_it():
click.echo(click.getchar())
runner = CliRunner()
result = runner.invoke(continue_it, input='y')
assert not result.exception
assert result.output == 'y\n'
def test_catch_exceptions():
class CustomError(Exception):
pass
@click.command()
def cli():
raise CustomError(1)
runner = CliRunner()
result = runner.invoke(cli)
assert isinstance(result.exception, CustomError)
assert type(result.exc_info) is tuple
assert len(result.exc_info) == 3
with pytest.raises(CustomError):
runner.invoke(cli, catch_exceptions=False)
CustomError = SystemExit
result = runner.invoke(cli)
assert result.exit_code == 1
@pytest.mark.skipif(WIN, reason='Test does not make sense on Windows.')
def test_with_color():
@click.command()
def cli():
click.secho('hello world', fg='blue')
runner = CliRunner()
result = runner.invoke(cli)
assert result.output == 'hello world\n'
assert not result.exception
result = runner.invoke(cli, color=True)
assert result.output == click.style('hello world', fg='blue') + '\n'
assert not result.exception
def test_with_color_but_pause_not_blocking():
@click.command()
def cli():
click.pause()
runner = CliRunner()
result = runner.invoke(cli, color=True)
assert not result.exception
assert result.output == ''
def test_exit_code_and_output_from_sys_exit():
# See issue #362
@click.command()
def cli_string():
click.echo('hello world')
sys.exit('error')
@click.command()
def cli_int():
click.echo('hello world')
sys.exit(1)
@click.command()
def cli_float():
click.echo('hello world')
sys.exit(1.0)
@click.command()
def cli_no_error():
click.echo('hello world')
runner = CliRunner()
result = runner.invoke(cli_string)
assert result.exit_code == 1
assert result.output == 'hello world\nerror\n'
result = runner.invoke(cli_int)
assert result.exit_code == 1
assert result.output == 'hello world\n'
result = runner.invoke(cli_float)
assert result.exit_code == 1
assert result.output == 'hello world\n1.0\n'
result = runner.invoke(cli_no_error)
assert result.exit_code == 0
assert result.output == 'hello world\n'
click-6.2/tests/test_utils.py 0000644 0000765 0000024 00000021347 12616755760 017546 0 ustar mitsuhiko staff 0000000 0000000 import os
import sys
import pytest
import click
import click.utils
import click._termui_impl
from click._compat import WIN, PY2
def test_echo(runner):
with runner.isolation() as out:
click.echo(u'\N{SNOWMAN}')
click.echo(b'\x44\x44')
click.echo(42, nl=False)
click.echo(b'a', nl=False)
click.echo('\x1b[31mx\x1b[39m', nl=False)
bytes = out.getvalue().replace(b'\r\n', b'\n')
assert bytes == b'\xe2\x98\x83\nDD\n42ax'
# If we are in Python 2, we expect that writing bytes into a string io
# does not do anything crazy. In Python 3
if sys.version_info[0] == 2:
import StringIO
sys.stdout = x = StringIO.StringIO()
try:
click.echo('\xf6')
finally:
sys.stdout = sys.__stdout__
assert x.getvalue() == '\xf6\n'
# And in any case, if wrapped, we expect bytes to survive.
@click.command()
def cli():
click.echo(b'\xf6')
result = runner.invoke(cli, [])
assert result.output_bytes == b'\xf6\n'
# Ensure we do not strip for bytes.
with runner.isolation() as out:
click.echo(bytearray(b'\x1b[31mx\x1b[39m'), nl=False)
assert out.getvalue() == b'\x1b[31mx\x1b[39m'
def test_echo_custom_file():
import io
f = io.StringIO()
click.echo(u'hello', file=f)
assert f.getvalue() == u'hello\n'
def test_styling():
examples = [
('x', dict(fg='black'), '\x1b[30mx\x1b[0m'),
('x', dict(fg='red'), '\x1b[31mx\x1b[0m'),
('x', dict(fg='green'), '\x1b[32mx\x1b[0m'),
('x', dict(fg='yellow'), '\x1b[33mx\x1b[0m'),
('x', dict(fg='blue'), '\x1b[34mx\x1b[0m'),
('x', dict(fg='magenta'), '\x1b[35mx\x1b[0m'),
('x', dict(fg='cyan'), '\x1b[36mx\x1b[0m'),
('x', dict(fg='white'), '\x1b[37mx\x1b[0m'),
('x', dict(bg='black'), '\x1b[40mx\x1b[0m'),
('x', dict(bg='red'), '\x1b[41mx\x1b[0m'),
('x', dict(bg='green'), '\x1b[42mx\x1b[0m'),
('x', dict(bg='yellow'), '\x1b[43mx\x1b[0m'),
('x', dict(bg='blue'), '\x1b[44mx\x1b[0m'),
('x', dict(bg='magenta'), '\x1b[45mx\x1b[0m'),
('x', dict(bg='cyan'), '\x1b[46mx\x1b[0m'),
('x', dict(bg='white'), '\x1b[47mx\x1b[0m'),
('foo bar', dict(blink=True), '\x1b[5mfoo bar\x1b[0m'),
('foo bar', dict(underline=True), '\x1b[4mfoo bar\x1b[0m'),
('foo bar', dict(bold=True), '\x1b[1mfoo bar\x1b[0m'),
('foo bar', dict(dim=True), '\x1b[2mfoo bar\x1b[0m'),
]
for text, styles, ref in examples:
assert click.style(text, **styles) == ref
assert click.unstyle(ref) == text
def test_filename_formatting():
assert click.format_filename(b'foo.txt') == 'foo.txt'
assert click.format_filename(b'/x/foo.txt') == '/x/foo.txt'
assert click.format_filename(u'/x/foo.txt') == '/x/foo.txt'
assert click.format_filename(u'/x/foo.txt', shorten=True) == 'foo.txt'
# filesystem encoding on windows permits this.
if not WIN:
assert click.format_filename(b'/x/foo\xff.txt', shorten=True) \
== u'foo\ufffd.txt'
def test_prompts(runner):
@click.command()
def test():
if click.confirm('Foo'):
click.echo('yes!')
else:
click.echo('no :(')
result = runner.invoke(test, input='y\n')
assert not result.exception
assert result.output == 'Foo [y/N]: y\nyes!\n'
result = runner.invoke(test, input='\n')
assert not result.exception
assert result.output == 'Foo [y/N]: \nno :(\n'
result = runner.invoke(test, input='n\n')
assert not result.exception
assert result.output == 'Foo [y/N]: n\nno :(\n'
@click.command()
def test_no():
if click.confirm('Foo', default=True):
click.echo('yes!')
else:
click.echo('no :(')
result = runner.invoke(test_no, input='y\n')
assert not result.exception
assert result.output == 'Foo [Y/n]: y\nyes!\n'
result = runner.invoke(test_no, input='\n')
assert not result.exception
assert result.output == 'Foo [Y/n]: \nyes!\n'
result = runner.invoke(test_no, input='n\n')
assert not result.exception
assert result.output == 'Foo [Y/n]: n\nno :(\n'
@pytest.mark.skipif(WIN, reason='Different behavior on windows.')
def test_prompts_abort(monkeypatch, capsys):
def f(_):
raise KeyboardInterrupt()
monkeypatch.setattr('click.termui.hidden_prompt_func', f)
try:
click.prompt('Password', hide_input=True)
except click.Abort:
click.echo('Screw you.')
out, err = capsys.readouterr()
assert out == 'Password: \nScrew you.\n'
@pytest.mark.skipif(WIN, reason='Different behavior on windows.')
@pytest.mark.parametrize('cat', ['cat', 'cat ', 'cat '])
def test_echo_via_pager(monkeypatch, capfd, cat):
monkeypatch.setitem(os.environ, 'PAGER', cat)
monkeypatch.setattr(click._termui_impl, 'isatty', lambda x: True)
click.echo_via_pager('haha')
out, err = capfd.readouterr()
assert out == 'haha\n'
@pytest.mark.skipif(WIN, reason='Test does not make sense on Windows.')
def test_echo_color_flag(monkeypatch, capfd):
isatty = True
monkeypatch.setattr(click._compat, 'isatty', lambda x: isatty)
text = 'foo'
styled_text = click.style(text, fg='red')
assert styled_text == '\x1b[31mfoo\x1b[0m'
click.echo(styled_text, color=False)
out, err = capfd.readouterr()
assert out == text + '\n'
click.echo(styled_text, color=True)
out, err = capfd.readouterr()
assert out == styled_text + '\n'
isatty = True
click.echo(styled_text)
out, err = capfd.readouterr()
assert out == styled_text + '\n'
isatty = False
click.echo(styled_text)
out, err = capfd.readouterr()
assert out == text + '\n'
@pytest.mark.skipif(WIN, reason='Test too complex to make work windows.')
def test_echo_writing_to_standard_error(capfd, monkeypatch):
def emulate_input(text):
"""Emulate keyboard input."""
if sys.version_info[0] == 2:
from StringIO import StringIO
else:
from io import StringIO
monkeypatch.setattr(sys, 'stdin', StringIO(text))
click.echo('Echo to standard output')
out, err = capfd.readouterr()
assert out == 'Echo to standard output\n'
assert err == ''
click.echo('Echo to standard error', err=True)
out, err = capfd.readouterr()
assert out == ''
assert err == 'Echo to standard error\n'
emulate_input('asdlkj\n')
click.prompt('Prompt to stdin')
out, err = capfd.readouterr()
assert out == 'Prompt to stdin: '
assert err == ''
emulate_input('asdlkj\n')
click.prompt('Prompt to stderr', err=True)
out, err = capfd.readouterr()
assert out == ''
assert err == 'Prompt to stderr: '
emulate_input('y\n')
click.confirm('Prompt to stdin')
out, err = capfd.readouterr()
assert out == 'Prompt to stdin [y/N]: '
assert err == ''
emulate_input('y\n')
click.confirm('Prompt to stderr', err=True)
out, err = capfd.readouterr()
assert out == ''
assert err == 'Prompt to stderr [y/N]: '
monkeypatch.setattr(click.termui, 'isatty', lambda x: True)
monkeypatch.setattr(click.termui, 'getchar', lambda: ' ')
click.pause('Pause to stdout')
out, err = capfd.readouterr()
assert out == 'Pause to stdout\n'
assert err == ''
click.pause('Pause to stderr', err=True)
out, err = capfd.readouterr()
assert out == ''
assert err == 'Pause to stderr\n'
def test_open_file(runner):
with runner.isolated_filesystem():
with open('hello.txt', 'w') as f:
f.write('Cool stuff')
@click.command()
@click.argument('filename')
def cli(filename):
with click.open_file(filename) as f:
click.echo(f.read())
click.echo('meep')
result = runner.invoke(cli, ['hello.txt'])
assert result.exception is None
assert result.output == 'Cool stuff\nmeep\n'
result = runner.invoke(cli, ['-'], input='foobar')
assert result.exception is None
assert result.output == 'foobar\nmeep\n'
@pytest.mark.xfail(WIN and not PY2, reason='God knows ...')
def test_iter_keepopenfile(tmpdir):
expected = list(map(str, range(10)))
p = tmpdir.mkdir('testdir').join('testfile')
p.write(os.linesep.join(expected))
f = p.open()
for e_line, a_line in zip(expected, click.utils.KeepOpenFile(f)):
assert e_line == a_line.strip()
@pytest.mark.xfail(WIN and not PY2, reason='God knows ...')
def test_iter_lazyfile(tmpdir):
expected = list(map(str, range(10)))
p = tmpdir.mkdir('testdir').join('testfile')
p.write(os.linesep.join(expected))
f = p.open()
for e_line, a_line in zip(expected, click.utils.LazyFile(f.name)):
assert e_line == a_line.strip()
 }})