semvec/pypi-packages huggingface dataset:
nlglib 0.2.1
Natural Language Generation library for Python
License: MIT
Keywords: natural language generation,NLG,text generation,nlglib,library

Current Status |build|
======================

.. |build| image:: https://travis-ci.org/roman-kutlak/nlglib.svg?branch=master
    :target: https://travis-ci.org/roman-kutlak/nlglib

This is just a starting point - an alpha version - mainly a wrapper
around SimpleNLG_.

Although it is possible to go from first order logic to text,
there is no sophistication in how things are processed.
The library is still missing basics like aggregation or referring expression generation.


Installation
============

Either download the code from the repository and run `python setup.py install` or use pip:
`pip install nlglib`.


Intro
=====

NLGlib is a library for natural language generation (NLG) written in Python.
It seeks to fill a gap in the NLG field. There are currently no off-the-shelf
libraries that one could take and incorporate into other projects.
The aim of this library is to be useful for general projects that would like
to add a bit of text generation to their capabilities.


Audience
========

The library should be usable by programmers with no prior linguistic knowledge.
Given that the aim of the library is language generation,
some linguistic knowledge is necessary but you should be able to pick it up
from the examples.


Scope
=====

The aim of the library is to create a base for NLG system starting from content
selection all the way to realisation. The library will cover document structuring
tools, lexicalisation, referring expression generation and aggregation.
Realisation will be done using other realisation libraries (SimpleNLG_ or pynlg_).


History
=======

NLGlib started as a part of the EPSRC project
Scrutable Autonomous Systems (SAsSy): www.scrutable-systems.org
When the project finished, the code was moved to this repository to create
a stand-alone re-usable library.


Example
=======

.. code-block:: python

    from nlglib.realisation.simplenlg.realisation import Realiser
    from nlglib.microplanning import *

    realise_en = Realiser(host='nlg.kutlak.info', port=40000)
    realise_es = Realiser(host='nlg.kutlak.info', port=40001)


    def main():
        p = Clause("María", "perseguir", "un mono")
        p['TENSE'] = 'PAST'
        # expected = 'María persigue un mono.'
        print(realise_es(p))
        p = Clause(NP("la", "rápida", "corredora"), VP("perseguir"), NP("un", "mono"))
        subject = NP("la", "corredora")
        objekt = NP("un", "mono")
        verb = VP("perseguir")
        subject.premodifiers.append("rápida")
        p.subject = subject
        p.predicate = verb
        p.object = objekt
        # expected = 'La rápida corredora persigue un mono.'
        print(realise_es(p))
        p = Clause(NP('this', 'example'), VP('show', 'how cool simplenlg is'))
        # expected = This example shows how cool simplenlg is.
        print(realise_en(p))


    if __name__ == '__main__':
        main()


.. _SimpleNLG: https://github.com/simplenlg/simplenlg
.. _pynlg: https://github.com/mapado/pynlg
readableID 0.0.4
Transform integer ids into readable, nonconsecutive ids
License: MIT

# Readable ID
[![CircleCI](https://circleci.com/gh/nziehn/readableID.svg?style=svg)](https://circleci.com/gh/nziehn/readableID)

Use readableID to transform integer item ids to readable, nonconsecutive ids

Criteria for a good readable id:
- as short as possible
- should contain only numbers and characters that are easy to distinguish regardless of font, e.g. no `0` vs `O`.
- not create any duplicates with increase number of items!
- consecutive numbers should not create consecutive ids

```python
id_generator.generate_id(0)  # returns 9MBE
id_generator.generate_id(1)  # returns QCAH
```

This library does not use any dependencies outside of the python std lib!


### Installing

Just install using `pip`:
```
pip install readableID
```


### Usage

Usage is very simple after creating an object, just call the `generate_id` method:
```python
import readableID

id_generator = readableID.ReadableID()

for x in range(1000):
    readable_id = id_generator.generate_id(x)
    print(readable_id)
```

Generally it is easiest to use this library in conjunction with a database that allows auto-incrementing ids 
which you use as input for the generate_id method. 


### Adapting parameters to your needs

To create your own unique numbers, you can salt them using the following parameters:

```python
import readableID
id_generator = readableID.ReadableID(
    charset=readableID.DEFAULT_CHARSET, 
    min_length=readableID.DEFAULT_MINIMAL_LENGTH,
    prime=readableID.DEFAULT_PRIME, 
    xor=readableID.DEFAULT_XOR
)
```

#### `charset`:

The `charset` controls the allowed characters. There are 2 criteria for this string:
1. characters must be unique
2. length of string must be a power of 2, e.g. 8, 16, 32, 64

The default charset is chosen to create minimal confusion for readers, since only very distinct chars were chosen.

#### `min_length`:

The `min_length` controls the length of the generated ids. The library will fit as many item ids into the given `min_length` as possible,
but if your number of items grows beyond this number, the ids will automatically get longer!

Example: with the default parameters, you can fit `32 ^ 4` item ids into 4 characters.
So if you call `generate_id` with any number `0 <= x < 32^4` it will produce a id with length of 4.
Starting at `32^4`, you will see ids with length of 5! Starting at `32^5` you will see ids with length of 6 and so on.

#### `prime`:

The `prime` parameter allows you to change how the next number is chosen. It is critical that this is a `prime number > 2` if you want to avoid duplicates!

If you are unsure - you can skip changing this parameter and rather chose a different `xor` value!

#### `xor`:

The `xor` value allows you to create different sequences of numbers, you can chose `any integer >= 0`, 
but generally it makes more since to pick a number:
`100 < x < len(charset) ^ min_length`. Changing `xor` will not have as big of an effect as changing the `prime` value, 
but will still create reasonably different sequences of numbers/
renogy-rover 0.0.1
MODBUS Driver for the Renogy Rover 20A/40A Charge Controller
License: MIT

renogy_rover
------------
Python MODBUS Driver for the Renogy Rover 20A/40A Charge Controller

.. image:: https://travis-ci.org/KyleJamesWalker/renogy_rover.svg?branch=master
    :target: https://travis-ci.org/KyleJamesWalker/renogy_rover

.. image:: https://codecov.io/gh/KyleJamesWalker/renogy_rover/branch/master/graph/badge.svg
  :target: https://codecov.io/gh/KyleJamesWalker/renogy_rover

This is currently a work in progress library, expect the interface and
structure to change on newer releases.