Pyfilefixity

First stable release of the new v2 branch! New (major) features since beta include:
- 2 new applications: `replication_repair.py` and `resiliency_tester.py`.
- More robust ecc files decoding (filesize intra-field is now protected by an ecc, etc.)
- Enhanced filetamper.py (more stats, more robust tampering, etc.)
- Better packaging (pyFileFixity is standalone, you just need a native Python interpreter and nosetests and you can run the tests and any script!).

Major features since v1 branch:
- Unit test, with branch coverage!
- More powerful Reed-Solomon libraries, with support for universal decoding/encoding and erasures (doubles the number of errors that can be corrected)!
- Crossplatform fix
- Various fixes, making the scripts a lot more robust against errors and exceptions.
- GUI support for all scripts
- And various other changes that I forgot...

Feel free to feedback with your experiences using pyFileFixity!

Major milestone again, the codebase is now branch covered at more than 80%, which is honestly a great deal more than what I thought was possible to do for a first coverage. This score means that all core functions are covered, only a few specific arguments (like skipping missing files and such) are not (yet) tested, but apart from that, you can assume that files generated by this app are safe and stable.

This means that the application is now a lot more stable (and more crossplatform: files generated on one platform can now be used on any other platform, at least theoretically, but it's safe to say that files generated on Linux and Windows are totally compatible, for other platforms we need testers!), but this also means that some big changes had to be done in the inner workings of the app. Normally, ecc files generated with v2.0.0 beta 1 should still be compatible with beta 2, but if you have generated such ecc files, you should try them with beta 2 to ensure they still work, and if not, regenerate new ones.

From now on, the code should stay pretty much stable, and the high coverage score is here to ensure that.there won't be any regression.

Before the stable release, only a few new scripts need to be developped, like replication_repair.py (see TODO.md for more info).

Major new codebase for pyFileFixity. The project is now most likely stable, and speed enhancements are enough to make the usage practical, and the Reed-Solomon ecc libraries are [rock solid](https://coveralls.io/github/lrq3000/unireedsolomon?branch=master) (unit tested at [more than 85%](https://coveralls.io/github/lrq3000/reedsolomon?branch=master), these are the most unit tested reed solomon libraries in the open source world currently).

The file formats for the ecc files should be frozen now (there won't be any change), so you can already generate your ecc files now, you will be able to use them with later versions of pyFileFixity without a problem. CAUTION: the format has changed since the last releases, so do not try to use old ecc files with this release, you should generate a new ecc file!

There are a few enhancements at repair and some additional tools I'd like to make before tagging this project as stable. These planned enhancements are described in TODO.md, such as the replication repair tool. The enhancements will be exclusively be done on repairing processes, not on generation, so that's why the ecc file format won't change (and you will benefit of the future repairing enhancements even if you generate your ecc files now).

This release fixes the issues of pyFileFixity v1.3. This release is stable.

IMPORTANT: Note that this release is incompatible with previously generated ecc files. You should regenerate all your ecc files with this new version!

Huge update, with lots of new features. First, there is a huge speedup improvement, about 100x (expect an encoding rate of more than 1MB/s), which is really really good and makes the usage of header_ecc.py and structural_adaptive_ecc.py possible in concrete, real world scenarios.

Another important improvement is in the resilience rate calculation: the old one was off, it protected the files more that you specified. This is fixed, so that you will know exactly how much your files are protected.

Another huge improvement is the reliability of the correction using ecc files: now even if the hash is corrupted, the blocks can still be checked by the ecc directly to see if the correction was successful.

Also, intra-ecc was added so that filepath are now protected by ecc too! This means that generated ecc files do not have a critical spot anymore, they should work flawlessly even if tampered (up to the resilience rate that you have set). However, adding intra-ecc broke compatibility with previous releases, so that you cannot decode old ecc files generated with previous versions of pyFileFixity. You should regenerate all your ecc files with this new release.

A last improvement is with rfigc.py, which now has a --filescraping_recovery option to use a database file to recover the filenames and directory tree structures of files that you data scraped on your disks following a data disaster (for example using Photorec).

The project is stable now. The main thing I still would like to improve on is a bit more speed in the RS library (I would like to reach over 10MB/s). If you can help with the Cython or Boost Python implementation, send me a pull request please! There are other features waiting to be implemented, but they aren't necessary for now (such as updating an ecc file, meanwhile you can just regenerate one).

Big update with very fast Reed-Solomon encoders.

IMPORTANT: do NOT use --ecc_algo 3 with this release, the resulting ecc can't be decoded because of a bug at generation time.

Fully working and stable version with fast encoders. This is the last version compatible with the old-style ecc files (without intra-ecc and with the wrong resilience rate calculation). If you have old ecc files that you want to maintain, use this version.