semvec/pypi-packages huggingface dataset:
iodata 1.0.0a1
Python Input and Output Library for Quantum Chemistry.

..
    : IODATA is an input and output module for quantum chemistry.
    :
    : Copyright (C) 2011-2019 The IODATA Development Team
    :
    : This file is part of IODATA.
    :
    : IODATA is free software; you can redistribute it and/or
    : modify it under the terms of the GNU General Public License
    : as published by the Free Software Foundation; either version 3
    : of the License, or (at your option) any later version.
    :
    : IODATA is distributed in the hope that it will be useful,
    : but WITHOUT ANY WARRANTY; without even the implied warranty of
    : MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    : GNU General Public License for more details.
    :
    : You should have received a copy of the GNU General Public License
    : along with this program; if not, see <http://www.gnu.org/licenses/>
    :
    : --

IOData
======
|Travis|
|Conda|
|Pypi|
|Codecov|
|Version|
|CondaVersion|


About
-----
IOData is a HORTON 3 module for input/output of quantum chemistry file formats. Documentation is
here: https://iodata.readthedocs.io/en/latest/index.html


License
-------

IOData is distributed under GPL License version 3 (GPLv3).


Dependencies
------------

The following dependencies will be necessary for IOData to build properly,

* Python >= 3.6: http://www.python.org/
* SciPy >= 0.11.0: http://www.scipy.org/
* NumPy >= 1.9.1: http://www.numpy.org/
* pytest >= 4.2.0: https://docs.pytest.org/
* Cython
* gcc/clang


Installation
------------

To install IOData using a conda environment:

* Install miniconda: https://conda.io/miniconda.html
* OR anaconda: https://www.anaconda.com/download

.. code-block:: bash

    $ conda create -n iodata_env
    $ source activate iodata_env
    (iodata_env) $ conda install -c theochem iodata

See https://iodata.readthedocs.io/en/latest/install.html for full details.

.. |Travis| image:: https://travis-ci.org/theochem/iodata.svg?branch=master
    :target: https://travis-ci.org/theochem/iodata
.. |Version| image:: https://img.shields.io/pypi/pyversions/iodata.svg
.. |Pypi| image:: https://img.shields.io/pypi/v/iodata.svg
    :target: https://pypi.python.org/pypi/iodata/0.1.3
.. |Codecov| image:: https://img.shields.io/codecov/c/github/theochem/iodata/master.svg
    :target: https://codecov.io/gh/theochem/iodata
.. |Conda| image:: https://img.shields.io/conda/v/theochem/iodata.svg
    :target: https://anaconda.org/theochem/iodata
.. |CondaVersion| image:: https://img.shields.io/conda/pn/theochem/iodata.svg
    :target: https://anaconda.org/theochem/iodata
fsort 0.1.2
Cli util to sort large files
Requires Python: >=3.5

# Cli util to sort large file.

# Installation

```bash
$ python3 -m pip install fsort
```

# Usage

### Create file

```python
fsort.py create-file --filename largefile.txt
```

### Sort file

```python
fsort.py external-sort --filename largefile.txt --size 20
```
Result would be `output.txt` sorted file
Also you will notice files chunk_* to be aware of how a large file was splitted into small ones.

# Source code

```python
import string

from contextlib import ExitStack
from heapq import merge
from itertools import count, islice
from random import choice, randint

import click

chunk_names = []


@click.group()
def cli():
    pass


@cli.command()
@click.option('--filename', help='File to sort')
@click.option('--size', default=50000, help='Size of each chunk')
def external_sort(filename, size):
    """
    Sort file large file by chunks storing these chunks
    into separate files with the given size – 50K by default.

    Result would be `output.txt` file with a sorted text.
    """
    with open(filename) as f:
        for c in count(1):
            sorted_chunk = sorted(islice(f, size))
            if not sorted_chunk:
                break

            chunk_name = f'chunk_{c}.txt'
            chunk_names.append(chunk_name)
            with open(chunk_name, 'w') as chunk_file:
                chunk_file.writelines(sorted_chunk)

    with ExitStack() as stack, open('output.txt', 'w') as of:
        files = (
            stack.enter_context(open(chunk))
            for chunk
            in chunk_names
        )
        of.writelines(merge(*files))


def generate_text(length=None):
    word_length = randint(8, length or 45)
    return ''.join(choice(string.printable) for i in range(length))


@cli.command()
@click.option('--filename', default='large_file.txt', help="File's name")
@click.option('--lines', default=100, help='Rows in a file')
@click.option('--line-length', default=45, help="Max line length")
def create_file(filename, lines, line_length):
    with open(filename, 'w') as f:
        for i in range(lines):
            f.write(f'{generate_text(line_length)}\n')
```
strbalance 0.3.1
A package to check whether a string is balanced
Requires Python: >=3

# strbalance

This small Python library provides functionality to check whether brackets, quotation marks, tags etc. inside the string are balanced, i.e. whether each of them is opened and closed properly with respect to other punctuation.

## Installation

Use the package manager [pip](https://pip.pypa.io/en/stable/) to install `strbalance`:

```bash
pip install strbalance
```

## Usage

If the punctuation in the string is not balanced, the result is an Unbalanced object, `None` otherwise:

```python
import strbalance

balance = strbalance.Balance()
print(balance.is_unbalanced('{[]}[()]'))  # outputs None
print(balance.is_unbalanced('abc(def"gh"ijkl)'))  # outputs None

unbalanced = balance.is_unbalanced('abcdefgh(ijkl]mnopqrst')
print(unbalanced.unclosed, unbalanced.short_summary, 
        unbalanced.long_summary)  # outputs ( ...fgh(ijk... ...fgh(ijkl]mno...
print(unbalanced.opening_position, unbalanced.opening_length,
        unbalanced.closing_position, unbalanced.closing_length)  # outputs 8 1 13 1
```

Istead of

```python
import strbalance
balance = strbalance.Balance()
balance.is_unbalanced('{[]}[()]')
```

one can simply write

```python
import strbalance
strbalance.is_unbalanced('{[]}[()]')
```

Apart from the string to check, `strbalance.is_unbalanced()` accepts all the optional parameters which can be passed to `Balance` constructor:

- `pairs` and `symmetrical` are lists of additional characters (or lines) to match; they default to `None`:
    - `pairs` – a list containing pairs of strings in the following format: 
    
        `[['a-opening'], ['a-closing'], ['b-opening', 'b-closing'] ...]`
    
    - `symmetrical` – a list of strings representing characters (or their sequences) which have identical opening and closing forms.
- All other parameters are boolean and default to `False`:
    - `tags` – match HTML (XML) paired tags (case sensitive).
    - `ignore_case` – ignore case in tags.
    - `cjk` – include CJK brackets and quotation signs: ｢…｣, 「…」, 〈…〉, 《…》, 『…』, （…）, ［…］, ＜…＞, ｛…｝, ｟…｠, 【…】, 〔…〕, 〖…〗, 〘…〙, 〚…〛.
    - `straight` – include straight quotation marks (single and double).
    - `custom` - balance only custom characters and character sequences (listed in `pairs` and `symmetrical` and/or added with other parameters).
    - `german` - use German quoting convention: „…“, ‚…‘, »…«, ›…‹ instead of “…”, ‘…’, «…», ‹…›.
    - `math` - match parentheses with brackets in order to include mathematical [a,c) notation.
    
The pairs of characters matched by default:
 - (…)  parentheses
 - […]  brackets
 - {…}  braces
 - “…”  double quotes
 - ‘…’  single quotes
 - «…»  double angle quotes
 - ‹…›  single angle quotes

## License
This project is licensed under the [MIT License](https://choosealicense.com/licenses/mit/).