Provided by: fades_9.0.1-2_all bug

NAME

       fades  -  A  system that automatically handles the virtualenvs in the cases normally found
       when writing scripts and simple programs, and even helps to administer big projects.

SYNOPSIS

       fades   [-h][--help]   [-V][--version]   [-v][--verbose]   [-q][--quiet]   [-i][--ipython]
       [-d][--dependency]   [-r][--requirement]   [-x][--exec]   [-p   version][--python=version]
       [--rm=UUID]      [--system-site-packages]      [--virtualenv-options=options]      [--pip-
       options=options]     [--python-options=options]     [--check-updates]     [--clean-unused-
       venvs=max_days_to_keep] [--get-venv-dir]  [--no-precheck-availability]  [-a][--autoimport]
       [--freeze] [-m][--module] [--avoid-pip-upgrade] [child_program [child_options]]

       fades  can  be  used to execute directly your script, or put it with a #! at your script's
       beginning.

DESCRIPTION

       fades will automagically create a new  virtualenv  (or  reuse  a  previous  created  one),
       installing  the  necessary  dependencies,  and execute your script inside that virtualenv,
       with the only requirement of executing the script with fades and also marking the required
       dependencies.

       The  first  non-option  parameter (if any) would be then the child program to execute, and
       any other parameters after that are passed as is to that child script.

       fades can also be executed without passing a child script to execute: in this mode it will
       open  a  Python  interactive  interpreter  inside  the  created/reused  virtualenv (taking
       dependencies from --dependency or --requirement options). If  --autoimport  is  given,  it
       will automatically import all the installed dependencies.

       If  the  child_program  parameter  is  really  an  URL,  the  script will be automatically
       downloaded from there (supporting also  the  most  common  pastebins  URLs:  pastebin.com,
       linkode.org, gist, etc.).

OPTIONS

       -h, --help
              Show help about all the parameters and options, and quit.

       -V, --version
              Show the program version and info about the system, and quit.

       -v, --verbose
              Send  all  internal  debugging  lines  to  stderr,  which may be very useful if any
              problem arises.

       -q, --quiet
              Don't show anything (unless it has a real problem), so the original  script  stderr
              is not polluted at all.

       -i, --ipython
              Runs IPython shell instead of python ones.

       -d, --dependency
              Specify  dependencies  through  command line. This option can be specified multiple
              times (once per dependency), and each time the  format  is  repository::dependency.
              The dependency may have versions specifications, and the repository is optional (it
              will infer it). Examples:

                  requests
                  pypi::requests > 2.3
                  requests<=3
                  git+https://github.com/kennethreitz/requests.git#egg=requests
                  vcs::git+https://github.com/kennethreitz/requests.git#egg=requests

              See more examples below for real command line usage explanations.

       -r, --requirement
              Read the  dependencies  from  a  file.  Format  in  each  line  is  the  same  than
              dependencies  specified  with  --dependency.  This option can be specified multiple
              times.

       -p version, --python=version
              Select which Python version to be used; the argument can be just the number  (2.7),
              the  whole name (python2.7) or the whole path (/usr/bin/python2.7).  Of course, the
              corresponding version of Python needs to be installed in your system.

              The dependencies can be indicated in multiple places (in the  Python  source  file,
              with  a  comment  besides the import, in a requirementsfile, and/or through command
              line. In case  of  multiple  definitions  of  the  same  dependency,  command  line
              overrides everything else, and requirements file overrides what is specified in the
              source code.

       -x, --exec
              Execute the child_program in the context  of  the  virtualenv.  The  child_program,
              which  in  this case becomes a mandatory parameter, can be just the executable name
              (relative to the venv's bin directory) or an absolute path.

       --rm UUID
              Remove a virtualenv by UUID.  See --get-venv-dir option  to  easily  find  out  the
              UUID.

       --system-site-packages
              Give the virtual environment access to thesystem site-packages dir

       --virtualenv-options=VIRTUALENV_OPTION
              Extra  options  to  be  supplied  to  virtualenv. (this option can be used multiple
              times)

       --pip-options=PIP_OPTION
              Extra options to be supplied to pip. (this option can be used multiple times)

       --python-options=PYTHON_OPTION
              Extra options to be supplied to python. (this option can be used multiple times)

       --check-updates
              Will check for updates in PyPI  to  verify  if  there  are  new  versions  for  the
              requested dependencies. If a new version is available for a dependency, it will use
              it (if the dependency was requested without  version)  or  just  inform  which  new
              version is available (if the dependency was requested with a specific version).

       --clean-unused-venvs=MAX_DAYS_TO_KEEP
              Will  remove  all virtualenvs that haven't been used for more than MAX_DAYS_TO_KEEP
              days.

       --get-venv-dir
              Show the virtualenv base directory (which includes the virtualenv UUID) and quit.

       --no-precheck-availability
              Don't check if the packages exists in PyPI before actually try to install them.

       -a, --autoimport
              Automatically import the dependencies when in interactive interpreter mode (ignored
              otherwise).

       --freeze FILEPATH
              Will operate exactly as without the command, but also it will dump the revisions of
              installed dependencies to the given filepath.

       -m, --module
              Run library module as a script (same behaviour than Python's -m parameter).

       --avoid-pip-upgrade
              Disable the automatic pip upgrade that happens after the virtualenv is created  and
              before the dependencies begin to be installed.

EXAMPLES

       fades foo.py --bar

              Executes foo.py under fades, passing the --bar parameter to the child program, in a
              virtualenv with the dependencies indicated in the source code.

       fades -v foo.py

              Executes foo.py under fades, showing all the fades messages (verbose mode).

       fades -d dependency1 -d dependency2>3.2 foo.py --bar

              Executes foo.py under fades (passing the --bar parameter to it),  in  a  virtualenv
              with  the  dependencies  indicated  in  the  source  code  and also dependency1 and
              dependency2 (any version > 3.2).

       fades -d dependency1

              Executes the Python  interactive  interpreter  in  a  virtualenv  with  dependency1
              installed.

       fades -r requirements.txt

              Executes  the Python interactive interpreter in a virtualenv after installing there
              all dependencies taken from the requirements.txt file.

       fades -r requirements.txt -r requirements_devel.txt

              Executes the Python interactive interpreter in a virtualenv after installing  there
              all dependencies taken from files requirements.txt and requirements_devel.txt.

USING CONFIGURATION FILES

       You  can  also  configure fades using .ini config files. fades will search config files in
       /etc/fades/fades.ini,  the  path  indicated  by  xdg  for   your   system   (for   example
       ~/config/fades/fades.ini)  and  .fades.ini.  So you can have different settings at system,
       user and project level.

       The config files are in .ini format. (configparser) and fades will search  for  a  [fades]
       section.   You have to use the same configurations that in the CLI. The only difference is
       with the config options with a dash, it has to be replaced with a underscore.

       Check     http://fades.readthedocs.org/en/latest/readme.html#setting-options-using-config-
       files for full examples.

SEE ALSO

       Development is centralized in https://github.com/PyAr/fades

       Check that site for a better explanation of fades usage.

AUTHORS

       Facundo Batista, Nicolás Demarchi (see development page for contact info).

LICENSING

       This program is free software: you can redistribute it and/or modify it under the terms of
       the GNU General Public License version 3, as published by the Free Software Foundation.

                                                                                         FADES(1)