Commit 1912bd40 by Eric Coissac

--no commit message

parent 49104d21
......@@ -80,7 +80,7 @@ def install_requirements(skip_virtualenv=True,pip=None):
if pip is None:
pip = get_a_pip_module()
requirements = open('requirements.txt').readlines()
requirements = [x.strip() for x in requirements]
......@@ -161,6 +161,9 @@ def pip_install_package(package,directory=None,pip=None):'installing %s in directory %s' % (package,str(directory)))
if 'http_proxy' in os.environ and 'https_proxy' not in os.environ:
if pip is None:
pip = get_a_pip_module()
......@@ -21,29 +21,50 @@ from obidistutils.serenity.globals import PIP_MINVERSION, \
from obidistutils.serenity.util import get_serenity_dir
import sys
import pkgutil
def is_pip_installed(minversion=PIP_MINVERSION):
import pip # @UnresolvedImport
ok = LooseVersion(pip.__version__) >= LooseVersion(minversion)"Try to load pip module...")
pipmodule = importlib.import_module('pip')
if hasattr(pipmodule,'__version__'):
ok = LooseVersion(pipmodule.__version__) >= LooseVersion(minversion)"Pip installed version %s" % pipmodule.__version__)
ok = False"A too old version of pip is installed on your system")
# We clean up the imported pip module for test purpose
for m in [x for x in sys.modules if x.startswith('pip.')]:
del sys.modules[m]
del sys.modules['pip']
ok = False"No pip installed on your system")
return ok
def get_a_pip_module(minversion=PIP_MINVERSION):
global local_pip
tmpdir = get_serenity_dir()
if not local_pip:
if not is_pip_installed(minversion):
if 'http_proxy' in os.environ and 'https_proxy' not in os.environ:
pipinstallscript = urllib2.urlopen('')
raise DistutilsError,"Pip (>=%s) is not install on your system and I cannot install it" % PIP_MINVERSION
script =
tmpdir = get_serenity_dir()
getpip_py = os.path.join(tmpdir, "")
with open(getpip_py, "wb") as fp:"Downloading temporary pip...")
......@@ -59,18 +80,29 @@ def get_a_pip_module(minversion=PIP_MINVERSION):
fp.write(base64.decodestring(ZIPFILE))" done.")
zipmodule = zipimport.zipimporter(pip_zip)
pipmodule = zipmodule.load_module("pip")
assert LooseVersion(pipmodule.__version__) >= minversion, \
"Unable to find suitable version of pip get %s instead of %s" % (pipmodule.__version__,
# Add the zipfile to sys.path so that we can import it
zi = zipimport.zipimporter(pip_zip)
pip = zi.load_module("pip")
pipmodule = importlib.import_module('pip')
pip = importlib.import_module('pip')
# Prepare the CERT certificat for https download
cert_path = os.path.join(tmpdir, "cacert.pem")
certificate = pkgutil.get_data("pip._vendor.requests", "cacert.pem")
with open(cert_path, "wb") as cert:
os.environ.setdefault("PIP_CERT", cert_path)
assert hasattr(pip,'__version__') and LooseVersion(pip.__version__) >= LooseVersion(minversion), \
"Unable to find suitable version of pip"
return local_pip[0]
......@@ -11,8 +11,9 @@ Contents:
.. toctree::
:maxdepth: 2
Algorithms <algorithms>
The ORGanelle ASeMbler ``oa`` command line tool <oa>
Assembling a mitochondrion genome <mitochondrion>
Algorithms <algorithms>
User API <userapi>
The organelle assembler indexer <orgasmi>
......@@ -7,7 +7,8 @@ Step 1 : indexing the reads
To assemble a genome from sequence reads, you need first to index them. This step allows an efficient access
to the reads during the assembling process. The organel assembler only works with pair ended reads of equal length.
to the reads during the assembling process. The organelle assembler is optimized for running with paired end
Illumina reads. It can also works, but less efficiently, with single reads, and 454 or Ion Torrent reads.
Considering two fastq files ``forward.fastq`` and ``reverse.fastq`` containing respectively the forward and the
reverse reads of the paired reads, to build the index named ``readindex`` from a UNIX terminal you have to run the
......@@ -15,19 +16,19 @@ reverse reads of the paired reads, to build the index named ``readindex`` from a
.. code-block:: bash
orgasmi -o readindex forward.fastq reverse.fastq
$ oa index readindex forward.fastq reverse.fastq
If the ``forward.fastq`` and ``reverse.fastq`` files are compressed using ``gzip`` (``forward.fastq.gz`` and ``reverse.fastq.gz``)
you can index them without uncompressed both the files on you disk. To achieve that you have to run the following commands :
the ``oa`` command is able to manage with compressed read files :
- by ``gzip`` if the file name ends by ``'.gz'``
- by ``bzip2``if the file name ends by ``'.bz2'``
.. code-block:: bash
$ mkfifo forward
$ mkfifo reverse
$ gzip -dc forward.fastq.gz > forward &
$ gzip -dc reverse.fastq.gz > reverse &
$ orgasmi -o readindex -M 30 -l 100 forward reverse
$ rm forward reverse
$ oa index readindex forward.fastq.gz reverse.fastq.bz2
This will index the 30 first millions of reads stored in the ``forward.fastq.gz`` and ``reverse.fastq.gz`` files over their first 100bp.
This source diff could not be displayed because it is too large. You can view the blob instead.
#!/usr/bin/env python
import os
import optparse
import sys
import re
from pip.exceptions import InstallationError, CommandError, PipError
from pip.log import logger
from pip.util import get_installed_distributions, get_prog
from pip.vcs import git, mercurial, subversion, bazaar # noqa
from pip.baseparser import ConfigOptionParser, UpdatingDefaultsHelpFormatter
from pip.commands import commands, get_summaries, get_similar_commands
# This fixes a peculiarity when importing via __import__ - as we are
# initialising the pip module, "from pip import cmdoptions" is recursive
# and appears not to work properly in that situation.
import pip.cmdoptions
cmdoptions = pip.cmdoptions
# The version as used in the and the docs
__version__ = "1.5.6"
def autocomplete():
"""Command and option completion for the main option parser (and options)
and its subcommands (and options).
Enable by sourcing one of the completion shell scripts (bash or zsh).
# Don't complete if user hasn't sourced bash_completion file.
if 'PIP_AUTO_COMPLETE' not in os.environ:
cwords = os.environ['COMP_WORDS'].split()[1:]
cword = int(os.environ['COMP_CWORD'])
current = cwords[cword - 1]
except IndexError:
current = ''
subcommands = [cmd for cmd, summary in get_summaries()]
options = []
# subcommand
subcommand_name = [w for w in cwords if w in subcommands][0]
except IndexError:
subcommand_name = None
parser = create_main_parser()
# subcommand options
if subcommand_name:
# special case: 'help' subcommand has no options
if subcommand_name == 'help':
# special case: list locally installed dists for uninstall command
if subcommand_name == 'uninstall' and not current.startswith('-'):
installed = []
lc = current.lower()
for dist in get_installed_distributions(local_only=True):
if dist.key.startswith(lc) and dist.key not in cwords[1:]:
# if there are no dists installed, fall back to option completion
if installed:
for dist in installed:
subcommand = commands[subcommand_name]()
options += [(opt.get_opt_string(), opt.nargs)
for opt in subcommand.parser.option_list_all
if != optparse.SUPPRESS_HELP]
# filter out previously specified options from available options
prev_opts = [x.split('=')[0] for x in cwords[1:cword - 1]]
options = [(x, v) for (x, v) in options if x not in prev_opts]
# filter options by current input
options = [(k, v) for k, v in options if k.startswith(current)]
for option in options:
opt_label = option[0]
# append '=' to options which require args
if option[1]:
opt_label += '='
# show main parser options only when necessary
if current.startswith('-') or current.startswith('--'):
opts = [i.option_list for i in parser.option_groups]
opts = (o for it in opts for o in it)
subcommands += [i.get_opt_string() for i in opts
if != optparse.SUPPRESS_HELP]
print(' '.join([x for x in subcommands if x.startswith(current)]))
def create_main_parser():
parser_kw = {
'usage': '\n%prog <command> [options]',
'add_help_option': False,
'formatter': UpdatingDefaultsHelpFormatter(),
'name': 'global',
'prog': get_prog(),
parser = ConfigOptionParser(**parser_kw)
pip_pkg_dir = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
parser.version = 'pip %s from %s (python %s)' % (
__version__, pip_pkg_dir, sys.version[:3])
# add the general options
gen_opts = cmdoptions.make_option_group(cmdoptions.general_group, parser)
parser.main = True # so the help formatter knows
# create command listing for description
command_summaries = get_summaries()
description = [''] + ['%-27s %s' % (i, j) for i, j in command_summaries]
parser.description = '\n'.join(description)
return parser
def parseopts(args):
parser = create_main_parser()
# Note: parser calls disable_interspersed_args(), so the result of this call
# is to split the initial args into the general options before the
# subcommand and everything else.
# For example:
# args: ['--timeout=5', 'install', '--user', 'INITools']
# general_options: ['--timeout==5']
# args_else: ['install', '--user', 'INITools']
general_options, args_else = parser.parse_args(args)
# --version
if general_options.version:
# pip || pip help -> print_help()
if not args_else or (args_else[0] == 'help' and len(args_else) == 1):
# the subcommand name
cmd_name = args_else[0].lower()
#all the args without the subcommand
cmd_args = args[:]
if cmd_name not in commands:
guess = get_similar_commands(cmd_name)
msg = ['unknown command "%s"' % cmd_name]
if guess:
msg.append('maybe you meant "%s"' % guess)
raise CommandError(' - '.join(msg))
return cmd_name, cmd_args
def main(initial_args=None):
if initial_args is None:
initial_args = sys.argv[1:]
cmd_name, cmd_args = parseopts(initial_args)
except PipError:
e = sys.exc_info()[1]
sys.stderr.write("ERROR: %s" % e)
command = commands[cmd_name]()
return command.main(cmd_args)
def bootstrap():
Bootstrapping function to be called from script.
pkgs = ['pip']
import setuptools
except ImportError:
return main(['install', '--upgrade'] + pkgs + sys.argv[1:])
## Writing freeze files
class FrozenRequirement(object):
def __init__(self, name, req, editable, comments=()): = name
self.req = req
self.editable = editable
self.comments = comments
_rev_re = re.compile(r'-r(\d+)$')
_date_re = re.compile(r'-(20\d\d\d\d\d\d)$')
def from_dist(cls, dist, dependency_links, find_tags=False):
location = os.path.normcase(os.path.abspath(dist.location))
comments = []
from pip.vcs import vcs, get_src_requirement
if vcs.get_backend_name(location):
editable = True
req = get_src_requirement(dist, location, find_tags)
except InstallationError:
ex = sys.exc_info()[1]
logger.warn("Error when trying to get requirement for VCS system %s, falling back to uneditable format" % ex)
req = None
if req is None:
logger.warn('Could not determine repository location of %s' % location)
comments.append('## !! Could not determine repository location')
req = dist.as_requirement()
editable = False
editable = False
req = dist.as_requirement()
specs = req.specs
assert len(specs) == 1 and specs[0][0] == '=='
version = specs[0][1]
ver_match =
date_match =
if ver_match or date_match:
svn_backend = vcs.get_backend('svn')
if svn_backend:
svn_location = svn_backend(
).get_location(dist, dependency_links)
if not svn_location:
'Warning: cannot find svn location for %s' % req)
comments.append('## FIXME: could not find svn URL in dependency_links for this package:')
comments.append('# Installing as editable to satisfy requirement %s:' % req)
if ver_match:
rev =
rev = '{%s}' %
editable = True
req = '%s@%s#egg=%s' % (svn_location, rev, cls.egg_name(dist))
return cls(dist.project_name, req, editable, comments)
def egg_name(dist):
name = dist.egg_name()
match ='-py\d\.\d$', name)
if match:
name = name[:match.start()]
return name
def __str__(self):
req = self.req
if self.editable:
req = '-e %s' % req
return '\n'.join(list(self.comments) + [str(req)]) + '\n'
if __name__ == '__main__':
exit = main()
if exit:
import sys
from .runner import run
if __name__ == '__main__':
exit = run()
if exit:
pip._vendor is for vendoring dependencies of pip to prevent needing pip to
depend on something external.
Files inside of pip._vendor should be considered immutable and should only be
updated to versions from upstream.
from __future__ import absolute_import
import ast
from pip._vendor._markerlib.markers import default_environment, compile, interpret
except ImportError:
if 'ast' in globals():
def default_environment():
return {}
def compile(marker):
def marker_fn(environment=None, override=None):
# 'empty markers are True' heuristic won't install extra deps.
return not marker.strip()
marker_fn.__doc__ = marker
return marker_fn
def interpret(marker, environment=None, override=None):
return compile(marker)()
# -*- coding: utf-8 -*-
"""Interpret PEP 345 environment markers.
EXPR [in|==|!=|not in] EXPR [or|and] ...
where EXPR belongs to any of those:
python_version = '%s.%s' % (sys.version_info[0], sys.version_info[1])
python_full_version = sys.version.split()[0] =
sys.platform = sys.platform
platform.version = platform.version()
platform.machine = platform.machine()
platform.python_implementation = platform.python_implementation()
a free string, like '2.6', or 'win32'
__all__ = ['default_environment', 'compile', 'interpret']
import ast
import os
import platform
import sys
import weakref
_builtin_compile = compile
from platform import python_implementation
except ImportError:
if == "java":
# Jython 2.5 has ast module, but not platform.python_implementation() function.
def python_implementation():
return "Jython"
# restricted set of variables
_VARS = {'sys.platform': sys.platform,
'python_version': '%s.%s' % sys.version_info[:2],
# FIXME parsing sys.platform is not reliable, but there is no other
# way to get e.g. 2.7.2+, and the PEP is defined with sys.version
'python_full_version': sys.version.split(' ', 1)[0],
'platform.version': platform.version(),
'platform.machine': platform.machine(),
'platform.python_implementation': python_implementation(),
'extra': None # wheel extension
for var in list(_VARS.keys()):
if '.' in var:
_VARS[var.replace('.', '_')] = _VARS[var]
def default_environment():
"""Return copy of default PEP 385 globals dictionary."""
return dict(_VARS)
class ASTWhitelist(ast.NodeTransformer):
def __init__(self, statement):
self.statement = statement # for error messages
ALLOWED = (ast.Compare, ast.BoolOp, ast.Attribute, ast.Name, ast.Load, ast.Str)
# Bool operations
ALLOWED += (ast.And, ast.Or)
# Comparison operations
ALLOWED += (ast.Eq, ast.Gt, ast.GtE, ast.In, ast.Is, ast.IsNot, ast.Lt, ast.LtE, ast.NotEq, ast.NotIn)
def visit(self, node):
"""Ensure statement only contains allowed nodes."""
if not isinstance(node, self.ALLOWED):
raise SyntaxError('Not allowed in environment markers.\n%s\n%s' %
(' ' * node.col_offset) + '^'))
return ast.NodeTransformer.visit(self, node)
def visit_Attribute(self, node):
"""Flatten one level of attribute access."""
new_node = ast.Name("%s.%s" % (, node.attr), node.ctx)
return ast.copy_location(new_node, node)
def parse_marker(marker):
tree = ast.parse(marker, mode='eval')
new_tree = ASTWhitelist(marker).generic_visit(tree)
return new_tree
def compile_marker(parsed_marker):
return _builtin_compile(parsed_marker, '<environment marker>', 'eval',
_cache = weakref.WeakValueDictionary()
def compile(marker):
"""Return compiled marker as a function accepting an environment dict."""
return _cache[marker]
except KeyError:
if not marker.strip():
def marker_fn(environment=None, override=None):
return True
compiled_marker = compile_marker(parse_marker(marker))
def marker_fn(environment=None, override=None):
"""override updates environment"""
if override is None:
override = {}
if environment is None:
environment = default_environment()
return eval(compiled_marker, environment)
marker_fn.__doc__ = marker
_cache[marker] = marker_fn
return _cache[marker]
def interpret(marker, environment=None):
return compile(marker)(environment)
# Copyright Jonathan Hartley 2013. BSD 3-Clause license, see LICENSE file.
from .initialise import init, deinit, reinit
from .ansi import Fore, Back, Style
from .ansitowin32 import AnsiToWin32
__version__ = '0.3.1'
# Copyright Jonathan Hartley 2013. BSD 3-Clause license, see LICENSE file.
This module generates ANSI character codes to printing colors to terminals.
CSI = '\033['