Metadata-Version: 2.1
Name: rnafbinv
Version: 2.0b21
Summary: Fragment based RNA designer
Home-page: https://github.com/matandro/RNAsfbinv
Author: Matan Drory Retwitzer
Author-email: matandro@post.bgu.ac.il
License: UNKNOWN
Platform: UNKNOWN
Classifier: Programming Language :: Python :: 3
Classifier: License :: OSI Approved :: MIT License
Classifier: Operating System :: OS Independent
Classifier: Topic :: Scientific/Engineering :: Bio-Informatics
Classifier: Intended Audience :: Science/Research
Description-Content-Type: text/markdown

# RNAfbinv 2.0

RNAfbinv is a fragment based RNA design tool. It uses a simulated annealing process to optimize a 2D RNA structure.<br/>
The similarity is based on fragment based design. A tree alignment is done based on nodes (structural motifs).<br/>
Nodes are comparable if they are both bounded motifs (stems) or unbounded motifs (multi loop, interior loops, bulges ect...).<br/>
Each iteration the target motif tree will be aligned to the current candidate tree.<br/>
The best alignment with the addition of other valuable features will generate a design score.<br/>
Design score of 0 is exact fit but even higher scores can generate a good candidate.

## Attaching Vienna RNA

[Vienna RNA package](https://www.tbi.univie.ac.at/RNA/ "Vienna RNA home") is required for RNAfbinv to work. This must be installed separately.<br/>
Current version was tested with Vienna 2.4 and above. RNAfbinv will identify Vienna package if it's bin directory is in PATH.<br/>
If you wish to link a specific installation of Vienna set the VIENNA_PATH environment variable to the correct bin directory.

You can set Vienna location in python
```python
import os
os.environ['VIENNA_PATH'] = "VIENNA_BIN_DIR_PATH"
```

or directly via the vienna script
```python
from rnafbinv import vienna
vienna.set_vienna_path("VIENNA_BIN_DIR_PATH")
```

## Usage

The design process can be ran using the following code:
```python
from rnafbinv import RNAfbinvCL
RNAfbinvCL.main(command_line_arguments)
```

To generate a tree for a specific sequence / structure:<br/>
Structure is a dot bracket notation structure and sequence is an IUPAC string with the same length
```python
from rnafbinv import shapiro_tree_aligner
shapiro_tree_aligner.get_tree(sructure, sequence)
```

To compare two trees and score them:
alignment_rules has a default value and is optional
```python
from rnafbinv import shapiro_tree_aligner
shapiro_tree_aligner.align_trees(source_tree, tree_target, alignment_rules)
```

### Command line arguments:

```
Usage: python3 RNAsfbinvCL [Options]
    -h : Shows usage text
    -i <number of iterations> : sets the number of simulated annealing iterations (default is 100)
    --seed <random number generator seed> : a long number that is used by the random number generator
    -t <number of look ahead attempts> : number of look head mutation attempts for each iteration (default is 4)
    -e : designs a circular RNA (default is False)
    -m <motif[,...]> : comma separated list of motifs to preserve
                       motif: <motif No>[M|H|E|I|S|B]<motif No of bases>
                       Use ListMotifs.listMotif(structure) to retrieve a list of legal motifs for a given structure,  
    -s <starting sequence> : the initial sequence for the simulated annealing process
    -r : force starting simulated annealing with a random sequence
    -p <MFE|centroid> : uses RNAfold centroid or MFE folding. (default is MFE)
    --verbose : Additional info message on simulation process
    --debug : Debug information
    -l <log file path> : Logging information will be written to a given file path (rewrites file if exists)
    --length <length diff> : The resulting sequence size is target structure length +- length diff (default it 0)

    -f <input file path> : Path of ini file that includes mandatory information. Some options can also be set via file.
                           command line options take precedence.
    List of available configurations (* are mandetory and will be requested via command line if not inserted):
    *TARGET_STRUCTURE=<target structure>
    *TARGET_SEQUENCE=<target sequence>
    TARGET_ENERGY=<target energy>
    TARGET_MR=<target mutational robustness>
    SEED=<random seed>
    STARTING_SEQUENCE=<starting sequence>
    ITERATION=<number of simulated annealing iterations>
```

### File input:

```
# mandatory
TARGET_STRUCTURE=<target structure>
TARGET_SEQUENCE=<target sequence>
# optional
TARGET_ENERGY=<target energy>
TARGET_MR=<target mutational robustness>
SEED=<random seed>
STARTING_SEQUENCE=<starting sequence>
ITERATION=<number of simulated annealing iterations>
```

## GUI / Command line

You can download the RNAfbinv wrapper from [RNAfbinv2.0 user application]()<br/>
It includes python code to run the GUI / command line and the [VARNA](http://varna.lri.fr/ "VARNA rna homepage") java package to generate 2D images.<br/>
If you remove the VARNA jar or do not have java installed, images will not be generated but the design process will proceed normally.<br/><br/>

To run command line just use the '-cl' flag for RNAfbinv.py. by default a GUI version will run.

To specify Vienna package location please update the 'VIENNA' parameter in config.ini (or set VIENNA_PATH environment variable)<br/>
To specify Java location please update the 'JAVA' parameter in config.ini (or set JAVA_PATH environment variable)<br/>
In both cases you need to specify the folder where the binary file sits. Only needed if not specified in PATH.

## Webserver

RNAfbinv2.0 can be found in a web server combined with incaRNAtion. The webserver generates starting seeds using incaRNAtion global sampling algorithm.<br/>
Te seed sequences are then sent to RNAfbinv2.0 for design. [incaRNAfbinv web server](https://www.cs.bgu.ac.il/incaRNAfbinv/ "incaRNAtion & RNAfbinv")

