def assert_hg_count(count, rev=None):
    """Assuming you are in an hg repository, assert that ``count`` commits
    have been made to that repo."""
    if rev:
        assert sh.grep(sh.hg.log(rev=rev), "changeset:").stdout.count(b"\n") == count
    else:
        assert sh.grep(sh.hg.log(), "changeset:").stdout.count(b"\n") == count

def check_upgrade():
        server_file = curl(PIFM_HOST + '/client_agent/pifm_agent.py')
        server_sum = awk(
                        md5sum(
                            grep(server_file, '-v', '^PIFM_HOST')
                        ), '{print $1}'
        )

        local_sum = awk(
                        md5sum(
                            grep('-v', '^PIFM_HOST', OUR_SCRIPT)
                        ), '{print $1}'
        )

        if str(server_sum) != str(local_sum):
            logging.info(
                "server: {server}, local: {local}, should update.".format(
                    server=server_sum,
                    local=local_sum
                )
            )
            with open(TMP_SCRIPT, 'w') as f:
                f.write(str(server_file))
            sed('-i',
                "0,/def/ s#http://pi_director#{myhost}#".format(myhost=PIFM_HOST),
                OUR_SCRIPT
                )
            status = python('-m', 'py_compile', TMP_SCRIPT)
            if (status.exit_code == 0):
                shutil.copy(TMP_SCRIPT, OUR_SCRIPT)
                os.chmod(OUR_SCRIPT, 0755)
                sys.exit(0)

def assert_hg_count(count, rev=None):
    '''Assuming you are in an hg repository, assert that ``count`` commits
    have been made to that repo.'''
    if rev:
        assert sh.grep(sh.hg.log(rev=rev), 'changeset:').stdout.count(b'\n') == count
    else:
        assert sh.grep(sh.hg.log(), 'changeset:').stdout.count(b'\n') == count

 def make_stats(self, rerun = False):
     self.stats = {}
     if os.path.exists(self.out_dir + "mapper/"):
         if os.path.exists(self.out_dir + self.name + "_stats.json") and not rerun:
             print "Loading stats for", self.name
             with open(self.out_dir + self.name + "_stats.json") as handle:
                 self.stats = json.load(handle)
         else:
             print "Computing stats for", self.name
             self.stats['raw_reads'] = self.pairs
             self.stats['output'] = self.out_dir
             print "Computing raw number of paired-reads"
             self.stats['read_count'] = int(sh.zgrep("-Ec", "$", self.reads))/4 
             print "Computing clean number of paired-reads"
             self.stats['clean_read_count'] = int(sh.grep("-Ec", "$", self.reads.replace("fastq.gz","clean.fastq")))/4
             self.stats['ratios'] = float(self.stats['clean_read_count'])/float(self.stats['read_count'])
             for k in tqdm(self.success_ks):
                 self.stats[k] = {}
                 self.stats[k]['Success'] =  os.path.exists(self.out_dir + "ray_" + str(k) + "/Contigs.fasta")
                 if self.stats[k]['Success']:
                     t=sh.assemstats(0,self.out_dir + "ray_" + str(k) + "/Contigs.fasta" )
                     self.stats[k]['Assembly'] = {a:b for a,b in  zip(*[[w.strip() for w in  l.split("\t")][1:] for l in str(t).split("\n")[0:2]])}
                     self.stats[k]['mapped_frac'] = float(sh.grep("overall",  self.out_dir + "map_" + str(k) + ".err").split(" ")[0][0:-1])/100
                     self.stats[k]['dupli_frac'] = float(sh.grep("Unknown", self.out_dir + "mapper/ray_" +str(k)+ "_" + self.name+ "-smd.metrics").split("\t")[7])
         
     with open(self.out_dir + self.name + "_stats.json", 'w') as handle:
         json.dump(self.stats, handle)

def check_if_running_polkit_auth():
    """
    check if polkit authentication agent is running
    and launch it if it is not
    """
    try:
        grep(ps('aux'), '[p]olkit-gnome-authentication-agent-1')
    except sh.ErrorReturnCode_1:
        logger.debug('polkit auth agent not found, trying to launch it...')
        run_polkit_auth_agent()

    def parse_rdf(self):
        """ cat|grep's the rdf file for minimum metadata
        """
        # FIXME: make this an rdf parser if I can
        _title = sh.grep(sh.cat(self.rdf_path), 'dcterms:title', _tty_out=False)
        try:
            _author = sh.grep(sh.cat(self.rdf_path), 'name', _tty_out=False)
            self.author = self._clean_properties(_author)
        except sh.ErrorReturnCode_1:
            self.author = "Various"

        self.title = self._clean_properties(_title)

    def _info_celery(self):
        d = {}

        try:
            lines = sh.grep(
                sh.grep(self._ps(), "celery"), "worker").split("\n")[:-1]
            for line in lines:
                (pid, command) = line.lstrip().split(" ", 1)
                d[pid] = line
        except:
            pass
        return d

def find_process_pid(process_line, child_process=False):
    ps_opts = 'auxww' if not child_process else 'auxfww'
    try:
        pid = sh.awk(
            sh.grep(
                sh.grep(sh.ps(ps_opts, _piped=True, _tty_out=False), "-ie", process_line),
                '-v', 'grep'),
            "{print $2}",
        )
    except sh.ErrorReturnCode:
        raise AssertionError("Cannot find process pid")

    return pid.strip()

def cache_ssh_key(hostname):
    """
    Request the host's key and cache it in .ssh/known_hosts

    http://serverfault.com/questions/321167/add-correct-host-key-in-known-hosts-multiple-ssh-host-keys-per-hostname
    """

    try:
        sh.grep('-q', hostname, SSH_KNOWN_HOSTS)
    except sh.ErrorReturnCode:
        with open(SSH_KNOWN_HOSTS, 'ab') as known_hosts_file:
            known_hosts_file.write('\n')

            keyscan = sh.Command('ssh-keyscan')
            keyscan('-t', 'rsa', hostname, _out=known_hosts_file)

def findImage(repository, tag):
    container=""
    try:
        container = sh.awk("{print $3}", _in=sh.head("-n 1", _in=sh.grep(tag, _in=sh.docker("images", repository))))
    except:
        print "container not available"
    return container.rstrip()

def get_free_mb(folder):
    df_result = grep(df("-k", folder), "/")

    kb_sizes = map(int, filter(is_int, df_result.split(" ")))
    available_mb = kb_sizes[2] / 1024

    return available_mb

    def get(self):
        query = unquote(self.get_argument('q'))
        try:
            results = str(grep('-R', '--exclude-dir', '.git', query,
                               self.settings.repo))
        except ErrorReturnCode_1 as e:
            results = ''

        try:
            results += str(find(self.settings.repo, '-type', 'f', '-name',
                                '*' + query + '*', '-not', '(', '-path',
                                '%s/%s/*' % (self.settings.repo, '.git') ))
        except ErrorReturnCode_1 as e:
            pass

        results = results.replace(self.settings.repo, '').split('\n')[:-1]
        formatted_results = []
        for result in results:
            if 'Binary file' in result or result == '':
                continue

            # TODO this doesn't play well with colons in filenames
            stuff = result.split(':')
            filename = stuff[0]
            if path.basename(filename).startswith('.'):
                filename = path.join(path.dirname(filename),
                                     path.basename(filename)[1:])
            string = ''.join(stuff[1:])
            string = self._highlight(string, query)
            formatted_results.append({'filename': filename, 'string': string})
        self.render('search.html', query=query, results=formatted_results)

def findContainer(name):
    container=""
    try:
        container = sh.awk("{print $1}", _in=sh.head("-n 1", _in=sh.grep(name, _in=sh.docker.ps())))
    except:
        print "container not available"
    return container.rstrip()

def ip_adresses():
    """
    IP Host und Device auslesen bzw setzen
    """
    check = sh.ifconfig
    check = sh.grep("inet")
    print check

def check_if_needed(path):
    if path[-6:] == '_r.MOV':
        return False

    file_name, ext = os.path.splitext(path)

    conv_name = os.path.join(WORKDIR, file_name + '_r' + ext)

    if os.path.isfile(conv_name):
        return False

    try:
        result = grep(grep(mediainfo(path), i='Rotation'), '180')
    except sh.ErrorReturnCode_1 as e:
        return False

    return True

def _get_last_two_deploys(environment):
    import sh
    git = sh.git.bake(_tty_out=False)
    pipe = git('tag')
    pipe = sh.grep(pipe, environment)
    pipe = sh.sort(pipe, '-rn')
    pipe = sh.head(pipe, '-n2')
    return pipe.strip().split('\n')

def force_push(git, branch):
    try:
        git.push('origin', branch, '--force')
    except sh.ErrorReturnCode_128 as e:
        # oops we're using a read-only URL, so change to the suggested url
        line = sh.grep('  Use ', _in=e.stderr)
        edit_url = line.strip().split()[1]
        git.remote('set-url', 'origin', edit_url)
        git.push('origin', branch, '--force')

def get_vendor(mac):
    if not mac:
        return None
    grepped = grep(
        mac.upper().replace(':','')[:6],
        OUI_FILE,
        _ok_code=[0,1]
    )
    return str(grepped)[7:] or '<unknown vendor>'

def get_remote_branches(origin, git=None):
    git = git or get_git()
    branches = [
        line.strip().replace('origin/HEAD -> ', '')[len(origin) + 1:]
        for line in
        sh.grep(
            git.branch('--remote'), r'^  {}'.format(origin)
        ).strip().split('\n')
    ]
    return branches

def get_node_ip():
        """Returns the node's IP, for the interface
        that is being used as the default gateway.
        This should work on both MacOS X and Linux."""
        try:
            default_interface = grep(netstat('-nr'), '-e', '^default', '-e' '^0.0.0.0').split()[-1]
            my_ip = ifaddresses(default_interface)[2][0]['addr']
            return my_ip
        except:
            raise Exception("Unable to resolve local IP address.")