semvec/pypi-packages huggingface dataset:
fileshash 0.1.1
Module and command-line tool that wraps around hashlib and zlib to facilitate generating checksums / hashes of files.
License: MIT

``fileshash``
============

.. image:: https://img.shields.io/pypi/v/fileshash.svg
        :target: https://pypi.python.org/pypi/fileshash

.. image:: https://img.shields.io/travis/mmore500/fileshash.svg
        :target: https://travis-ci.org/mmore500/fileshash

Python module to facilitate calculating the hash of multiple files.
Tested against Python 2.7, Python 3.6, PyPy 2.7 and PyPy 3.5.
Currently supports `Adler-32 <https://en.wikipedia.org/wiki/Adler-32>`_, `CRC32 <https://en.wikipedia.org/wiki/Cyclic_redundancy_check>`_, `MD5 <https://en.wikipedia.org/wiki/MD5>`_, `SHA-1 <https://en.wikipedia.org/wiki/SHA-1>`_, `SHA-256 and SHA-512 <https://en.wikipedia.org/wiki/SHA-2>`_, and `xxHash-32 and xxHash-64 <https://xxhash.com>`_.

Forked from Leonides T. Saguisag Jr.'s `FileHash <https://github.com/leonidessaguisagjr/filehash>`_.

``FilesHash`` class
------------------

The ``FilesHash`` class wraps around the ``hashlib`` (provides hashing for MD5, SHA-1, SHA-256 and SHA-512) and ``zlib`` (provides checksums for Adler-32 and CRC32) modules and contains the following methods:

- ``hash_file(filename)`` - Calculate the file hash for a single file.  Returns a string with the hex digest.
- ``cathash_files(filenames)`` - TODO
- ``hophash_files(filenames)`` - TODO

The ``FileHash`` constructor has two optional arguments:

- ``hash_algorithm='sha256'`` - Specifies the hashing algorithm to use.
See ``filehash.SUPPORTED_ALGORITHMS`` for the list of supported hash / checksum algorithms.
Defaults to SHA256.
- ``chunk_size=262144`` - Integer specifying the chunk size to use (in bytes) when reading the file.
This comes in useful when processing very large files to avoid having to read the entire file into memory all at once.  Default chunk size is 262144 bytes.

Example usage
-------------

The library can be used as follows::

   >>> import os
   >>> from fileshash import FilesHash
   >>> TODO


``fileshash`` command line tool
---------------------------------

A command-line tool called ``fileshash`` is also included with the ``fileshash`` package.
Here is an example of how the tool can be used::

   $ TODO

Run the tool without any parameters or with the ``-h`` / ``--help`` switch to get a usage screen.

License
-------

This is released under an MIT license.
See the ``LICENSE`` file in this repository for more information.
expressionable 1.2
A tool for managing large datasets
License: MIT

# expressionable Python Module
The official repository for the expressionable Python module, which allows for:
* Transforming tabular data sets from one format to another.
* Querying large data sets to filter out useful data.
* Selecting additional columns/features to include in the resulting data set.
* Merging data sets of various formats into a single file.
* Gzipping resulting data sets, as well as the ability to read gzipped files.

Click for information on the [ExpressionAble command-line tool](https://github.com/srp33/ShapeShifter-CLI), which combines
the features of ExpressionAble with the ease and speed of the command-line!

Basic use is described below, but see the full documentation on [Read the Docs](https://shapeshifter.readthedocs.io/en/latest/).  
## Install
`pip install expressionable`

## Basic Use
After installing, import the ExpressionAble class with `from expressionable import ExpressionAble`. An ExpressionAble object 
represents the file to be transformed. It is then transformed using the `export_filter_results` method. Here is a simple
example of file called `input_file.tsv` being transformed into an HDF5 file called `output_file.h5`, while filtering 
the data on sex and age:
```python
from expressionable import ExpressionAble

my_expressionable = ExpressionAble("input_file.tsv")
my_expressionable.export_filter_results("output_file.h5", filters="Sex == 'M' and Age > 40")
```
Note that the type of file being read and exported to were not stated explicitly but inferred by ExpressionAble based on
the file extensions provided. If necessary, `input_file_type` and `output_file_type` can be named explicitly.


## Contributing
We welcome contributions that help expand ExpressionAble to be compatible with additional file formats. If you are 
interested in contributing, please follow the instructions [here](https://github.com/srp33/ExpressionAble/wiki/Adding-Support-for-Additional-File-Types-in-ExpressionAble).
## Currently Supported Formats
#### Input Formats:
* CSV
* TSV
* JSON
* Excel
* HDF5
* Parquet
* MsgPack
* Stata
* Pickle
* SQLite
* ARFF
* GCT
* GCTX
* PDF
* Kallisto
* GEO
* StarReads

#### Output Formats:
* CSV 
* TSV
* JSON
* Excel
* HDF5
* Parquet
* MsgPack
* Stata 
* Pickle
* SQLite 
* ARFF 
* GCT 
* RMarkdown 
* JupyterNotebook

## Future Formats to Support
We are working hard to expand ExpressionAble to work with even more file formats! Expect the following formats to be 
included in future releases:
* Fixed-width files (fwf)
* Genomic Data Commons clinical XML
mystracher 0.2
A structure / Grammar checker for English - a Python wrapper 3.7 for ATD (After The Dateline)
License: MIT
Keywords: praat speech signal processing phonetics

*** scoring bug fixed ***

This library is a language checker for English with:

--Contextual Spell Checking
--Advanced Style Checking
--Intelligent Grammar Checking

and built for Python 3.7. 
It uses artificial intelligence and natural language processing technology to find your writing errors
and offer smart suggestions. The technology was developed by After the Deadline http://www.afterthedeadline.com/ 
and is available under the GNU General Public License. 
After the Deadline is available on WordPress.com as well as in libraries, plugins, add-ons, and 
extensions for a variety of platforms. See the Download or Developers page for more information on 
extensions and libraries.