Ubuntu Manpage: fades - A system that automatically handles the virtualenvs in the cases normally found

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.

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)