companion

KO | EN

gitlite — search

#javascript #python #hacktoberfest #react #typescript #golang #android #rust #linux #nodejs #windows #awesome-list #pytorch #mcp

(★ 13)

A genome annotation tool for more than just protists

companion 최신버젼 다운로드

최종 버전 다운로드 (.zip)

// repository documentation

Was this content helpful?

★ 0 (0 ratings)

# Companion
A portable, scalable eukaryotic genome annotation pipeline implemented in Nextflow.

![Tests](https://github.com/sii-companion/companion/actions/workflows/test-on-pr.yml/badge.svg)
[![License: ISC](https://img.shields.io/badge/License-ISC-brightgreen.svg)](https://github.com/sii-companion/companion/blob/master/LICENSE)
[![status](https://img.shields.io/badge/NAR-10.1093%2Fnar.gkw292-brightgreen.svg)](https://doi.org/10.1093/nar/gkae378)
[![DOI](https://zenodo.org/badge/376799286.svg)](https://zenodo.org/badge/latestdoi/376799286)

This software is a comprehensive computational pipeline for the annotation of eukaryotic genomes (like protozoan parasites). It performs the following tasks:

- Fast generation of pseudomolecules from scaffolds by ordering and orientating against a reference
  - Accurate transfer of highly conserved gene models from the reference
  - _De novo_ gene finding as a complement to the gene transfer
  - Non-coding RNA detection (tRNA, rRNA, sn(o)RNA, ...)
  - Pseudogene detection
  - Functional annotation (GO, products, ...)
    - ...by transferring reference annotations to the target genome
    - ...by inferring GO terms and products from Pfam pHMM matches
  - Consistent gene ID assignment
  - Preparation of validated GFF3, GAF and EMBL output files for jump-starting manual curation and quick turnaround time to submission

It supports parallelized execution on a single machine as well as on large cluster platforms (LSF, SGE, ...).

## Contents

* [Quick start](#quick-start)
 * [1. Install dependencies](#1-install-dependencies)
 * [2. Install Companion](#2-install-companion)
 * [3. Run Companion test job](#3-run-companion-test-job)
 * [4. Configure Companion for your annotation run](#4-configure-companion-for-your-annotation-run)
 * [5. Prepare reference annotations](#5-prepare-reference-annotations)
 * [6. Run it!](#6-run-it)
 * [Further technical information](#further-technical-information)
 * [Dependencies](#dependencies)
 * [Java](#java)
 * [Nextflow](#nextflow)
 * [Docker](#docker)
 * [Installation](#installation)
 * [Usage](#usage)
 * [Local copy of Companion](#local-copy-of-companion)
 * [Running Companion direct from a repository](#running-companion-direct-from-a-repository)
 * [Preparing reference annotations](#preparing-reference-annotations)
 * [License](#license)
 * [Feedback/Issues](#feedbackissues)
 * [Citation](#citation)

## Quick start

This should get you up & running on an Ubuntu system, but please read the full documentation before before doing any work "for real".

### 1. Install dependencies

Execute these commands as root, e.g. using `sudo`
```
apt-get install openjdk-17-jre
curl -fsSL get.nextflow.io | bash && \
   mv nextflow /usr/local/bin
curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo apt-key add - && \
   add-apt-repository "deb [arch=amd64] https://download.docker.com/linux/ubuntu $(lsb_release -cs) stable" && \
   apt-get update && \
   apt-cache policy docker-ce && \
   apt-get install --yes docker-ce && \
   systemctl enable docker
```

To enable you to use docker with your normal user account (i.e. without being root or needing to use sudo),
run the following command, with your username in place of `<username>`.
```
usermod -aG docker <username>
```
Log out and log back in again for this to take effect.

On Linux, you can also run the following command to activate the changes to groups:
```
 newgrp docker
```

#### Checks

- `java -version` should say you have Java 1.8 or greater
  - `nextflow info` will print system information if nextflow has been installed successfully
  - `systemctl status docker` will tell you if docker is active (running)
  - `docker info` will print information if docker has been installed successfully, and you have permission to use it

### 2. Install _Companion_

Execute these commands in the directory you want to keep your _Companion_ work in. Do this as a normal user, i.e. not as root or using sudo.
Use a name that is meaningful to you in place of `<my-companion-project>`
```
curl -L -o companion-master.zip https://github.com/sii-companion/companion/archive/master.zip && \
 unzip companion-master.zip && \
 mv companion-master <my-companion-project>
docker pull uofgiii/companion
```

### 3. Run _Companion_ test job

_Companion_ is distributed with configuration and data (including a few pregenerated reference annotations) for a small test run.  Run
the following command (using the name you chose for your project directory in place of `my-companion-project`).
```
NXF_VER=21.10.6 nextflow run my-companion-project -profile docker
```
This will create a directory `my-companion-project/example-output` with the results of the run.

### 4. Configure _Companion_ for your annotation run

The file `params_default.config` configures the pipeline, and will need to be edited for your annotation run.  You will probably need to change at least the following parameters:

*inseq*  Your input FASTA file  (`${baseDir}/example-data/L_donovani.1.fasta` in the example parameter file included wirth the distribution)

*ref_dir* The directory containing your reference genomes (`${baseDir}/example-data/references` in the example file)

*ref_species* The "short name" for your reference species (`LmjF.1` in the example file)

*dist_dir* The directory that will contain the newly created output files (`${baseDir}/example-data-output` in the example file)

*GENOME_PREFIX* Text pattern matching your genome prefix (`LDON` in the example file)

*CHR_PATTERN* Pattern matching your chromosome names (`LDON_(%w+)` in the example file, where `%w+` matches one or more letters or numbers)

*ABACAS_BIN_CHR* Abacas bin chromosome (`LDON_0` in the example file)

*EMBL_AUTHORS* etc.; please provide suitable EMBL metadata (dummy values in the example file)

*TAXON_ID* Please provide suitable value for the GAF output (`4711` in the example file)

### 5. Prepare reference annotations

The reference annotations used in the pipeline need to be pre-processed before they can be used.  To add a reference organism, you will need:

- a descriptive name of the organism
- a short abbreviation for the organism
- the genome sequence in a single FASTA file
- a structural gene annotation in GFF3 format (see below for details)
- functional GO annotation in GAF 1.0 format, on the gene level
- a pattern matching chromosome headers, describing how to extract chromosome numbers from them
- an [AUGUSTUS](http://bioinf.uni-greifswald.de/augustus/) model, trained on reference genes

Insert these file names, etc., where `<placeholders>` appear in the steps below:

1. Create a new data directory (i.e. the equivalent of the `example-data` directory included in the distribution)
1. Edit `nextflow.config` (and any config files that are referenced) and change parameters such as
`inseq` and `ref_dir` to your new data directory.
1. Copy the new reference genome (FASTA) into `<new_data_dir>/genomes`
1. Copy GFF3 and GAF files into `<new_data_dir>/genomes`
1. Copy Augustus model files into `data/augustus/species/<species_name>/`
1. Create new directory `<new_data_dir>/references/<short_name>/`
1. Add new section to `<new_data_dir>/references/references-in.json`, using the
short name (same as the directory name in the previous step); in this section add
the names/paths of the files copied (above), a descriptive name, and
a pattern for matching chromosomes in the FASTA files (in this example, <short_name>_<n>, where _n_ in any integer).
```
"<short_name>" : { "gff" : "../genomes/<gff3_filename>.gff3",
 "genome" : "../genomes/<ref_genome_name>.fasta",
 "gaf" : "../genomes/<ref_annot_filename>.gaf",
 "name" : "<Descriptive Name of Reference Genome>",
 "augustus_model" : "../../data/augustus/species/<species_name>/",
 "chromosome_pattern" : "<short_name>_(%d+)"
 }
```
8. Finally, change directory to `<new_data_dir>/references` (you _must_ execute the following command in this directory)
and run `../../bin/update_references.lua`. This writes the file `<new_data_dir>/references/references.json`.

### 6. Run it!

The following command (using the name you chose for your project directory in place of `my-companion-project`) will
start your annotation run:
```
nextflow run my-companion-project -profile docker
```

## Further technical information

### Dependencies

Companion has the following dependencies:

- [Java](https://openjdk.java.net/) 8 to 17
  - [Nextflow](http://nextflow.io)
  - [Docker](https://www.docker.com/) (if using the Docker image to satisfy dependencies)

#### Java

To check if you have Java installed, and the version, use the command `java -version`.  Note that this will give you a version number
of 1.8 for Java 8, 1.9 for Java 9, etc.

To install Java 8 on an Ubuntu or Debian system, run:
```
apt-get install openjdk-8-jre
```
On Fedora, Centos or Red Hat (etc.) systems:
```
yum install java-1.8.0-openjdk
```

The latest version of Java we recommend installing is 17, i.e.:
```
apt-get install openjdk-17-jre
```

#### Nextflow

To install Nextflow, run:
```
curl -fsSL get.nextflow.io | bash
```
This will create an executable called 'nextflow', which should be moved to a suitable directory, for example:
```
mv nextflow /usr/local/bin/
```
Use the command `which nextflow` to check that it is found in your path.

By default, when running Nextflow the latest stable version will be used. It is important to note that since Nextflow v23 all support
for DSL1 (which the Companion pipeline uses) has been dropped in favour of DSL2. Therefore when running Nextflow locally, it is best
to set the environment variable NXF_VER to a version < 23 explicitly beforehand, e.g.:
```
NXF_VER=21.10.6 nextflow run ...
```

#### Docker

Docker is required if you intended to use the Docker image, as recommended below, to satisfy the dependencies.

To install Docker, see the installation guide for
[Ubuntu](https://docs.docker.com/install/linux/docker-ce/ubuntu/),
[Centos](https://docs.docker.com/install/linux/docker-ce/centos/),
[Debian](https://docs.docker.com/install/linux/docker-ce/debian/) or
[Fedora](https://docs.docker.com/install/linux/docker-ce/fedora/).

Users running Companion with Docker will need to be added to the `docker` group (unix users can belong to one or more groups, which determine
whether they can peform certain actions; adding a user to the docker group allows them to execute docker commands). To add the user with
username `<username>`, to the docker group, run:
```
usermod -aG docker <username>
```

> _Some Linux systems may not have_ `usermod` _installed, as there are different programs that can be used to change user settings;_
> _please consult your Linux distribution documentation if necessary._

### Installation

There are a number of ways to install Companion; details for an installation using Docker are described below. If you encounter an issue when installing Companion please contact your local system administrator. If you encounter a bug please log it [here](https://github.com/sii-companion/companion/issues) or email us at sii-companion@glasgow.ac.uk.

The easiest way to use the pipeline is to use the prepared [Docker image](https://hub.docker.com/repository/docker/uofgiii/companion/) which contains all external dependencies.
```
docker pull uofgiii/companion
```

### Usage

#### Local copy of Companion

To create a local copy of companion, you can download this repo from github (if you are familiar with github, you may
of course prefer to _clone_ or _fork_ it).
```
curl -L -o companion-master.zip https://github.com/sii-companion/companion/archive/master.zip  # or click the green button on the guthub web page
unzip companion-master.zip
mv companion-master my-companion-project # renaming it to something meaningful to you is a good idea
```

Now you can run Companion.   There is an example dataset and parameterization included in the distribution, so
to get started just run:
```
nextflow run my-companion-project -profile docker
```
The argument `-profile docker` instructs nextflow to run the uofgiii/companion docker image for the dependencies;
the `nextflow.config` file (and files referenced within it) define the docker profile and the docker image to be used.

#### Running Companion direct from a repository

If you run nextflow with the name of a github repository, it will pull (download) the contents of the repository and run with those.
For example, the following command will do the same as the "local copy" example above:
```
nextflow run sii-companion/companion -profile docker
```
It is best to use this with some caution.  After the command above is
run, nextflow will have stored a local copy of the repository in `.nextflow/assets/sii-companion`
(note that `.nextflow` is a hidden directory, and will not usually be visible; use the command `ls -la .nextflow` to see it).

If you run the same command again it will this time use the _local_ copy instead of pulling a copy from the repository.  You can
edit the files in your local copy, and nextflow will work from your (now different) version of sanger-pathogens/companion.

If you are familiar with repositories, and the workflow appropriate to using them, this can be a very convenient way of
working.  You can create your own github repository to store and share your work, and track versions.

If you are not familiar with git repositories, it can become quite confusing, and you should probably work with a simple local copy.

#### Preparing reference annotations

Further documentation on preparing reference data can be found in the
[GitHub wiki](https://github.com/sii-companion/companion/wiki/Preparing-reference-data-sets).

## License
Companion is free software, licensed under [ISC](https://github.com/sii-companion/companion/blob/master/LICENSE).

## Feedback/Issues
Please report any issues to the [issues page](https://github.com/sii-companion/companion/issues)
## Citation
If you use this software please cite:
__Annotation and visualization of parasite, fungi and arthropod genomes with Companion__.
William Haese-Hill, Kathryn Crouch, Thomas D Otto.
Nucleic Acids Research, 2024; gkae378,
DOI: [10.1093/nar/gkae378](https://doi.org/10.1093/nar/gkae378)

companion

companion 최신버젼 다운로드

오늘의 추천 프로젝트

Was this content helpful?

Recent Feedback

companion

companion 최신버젼 다운로드

오늘의 추천 프로젝트

Was this content helpful?

Recent Feedback

Download README