semvec/pypi-packages huggingface dataset:
modbus-solar 1.0.3
A small package to pull stats from a Renogy Solar Charge Controller
License: MIT
Requires Python: >=3.8
Keywords: modbus, renogy, solar

# Modbus Solar

[![pypi](https://img.shields.io/pypi/v/modbus-solar.svg)](https://pypi.org/project/modbus-solar/)
[![python](https://img.shields.io/pypi/pyversions/modbus-solar.svg)](https://pypi.org/project/modbus-solar/)
[![built with nix](https://builtwithnix.org/badge.svg)](https://builtwithnix.org)

## Intro

This project is to pull stats out of a Renogy DCC50S solar charge controller.

The connection will be made via Modbus/RS485.

The end state will be to output stats in `json` format ready to be ingested into something like an InfluxDb instance or to publish to a MQTT Topic.

## Pre-Reqs

You require a Modbus/RS485 connector, most probably will be a USB varient. Most applications will be using a small IoT device or Raspberry Pi to serve the USB device and then connect back to a logging system of some sort.

The Modbus parameters are hard coded but variabalised for the device ID and the salve address which could change.

## Using

### To install

```bash
pip install modbus-solar
```

### To Use

1. `python`

    ```python
    #!/usr/bin/env python
    from modbus_solar import get_all
    import json

    # json.dumps() ensures you can parse through jq
    stats = json.dumps(get_all())
    print(stats)
    ```

1. `bash`

    ```bash
    modbus-solar --help
    modbus-solar
    ```

## Releases

My aim is to keep to [semver versioning](https://semver.org/)

The pipeline will push to PyPi so this should be the main way of getting the recent packages. But the pipeline will also create releases in Gitlab for versions that are tagged

## Development

My development has taken place using NixOS, I've included the `shell.nix` for anyone that requires it.

However the build pipeline is performed using the basic python:3.11 image from Gitlab.

To build run the following:

```bash
python -m build --sdist --wheel
```
eng-syl 4.0.8.2
English word syllabifier and extended syllable analysis tool
License: MIT
Keywords: Syllable, NLP, psycholinguistics

ï»¿# English Syllabifier (eng_syl)
This is a GRU-based neural network designed for English word syllabification. The model was trained on data from the  [Wikimorph](https://link.springer.com/chapter/10.1007/978-3-030-78270-2_72) dataset.

## Usage

Use the `syllabify()` function from the `Syllabel` class to syllabify your words:

>     >>> from eng_syl.syllabify import Syllabel
>     >>> syllabler = Syllabel()
>     >>> syllabler.syllabify("chomsky")
>     'chom-sky'

`syllabify()` parameters

 - **text**: *string*- English text to be syllabified. Input should only contain alphabetic characters.

`syllabify()` returns the given word with hyphens inserted at syllable boundaries.

## Onceler (Onset, Nucleus, Coda Segmenter)

The `onc_split()` function from the  `Onceler` class splits single syllables into their constituent Onset, Nucleus, and Coda components.

>     >>> from eng_syl.onceler import Onceler
>     >>> onc = Onceler()
>     >>> print(onc.onc_split("schmear")
>     'schm-ea-r'

 - **text**: *string* - English single syllable word/ component to be segmented into Onset, Nucleus, Coda. Input should only contain alphabetic characters.

## Phonify (Grapheme sequence to IPA estimation)

The `ipafy()` function from the  `onc_to_phon` class tries to approximate an IPA pronunciation from a sequence of graphemes.

>     >>> from eng_syl.phonify import onc_to_phon
>     >>> otp = onc_to_phon()
>     >>> print(otp.ipafy(['schm', 'ea', 'r'])
>     ['Êƒm', 'Éª', 'r']

 - **sequence**: *array of strings* - sa sequence of English viable onsets, nuclei, and coda

# 4.0.2 Notes
Fixed a typo in build_model(), where improper shape was being passed into Input()
Reverted class name from Syllabel -> Syllable -> Syllabel

# 4.0.3 Notes
Added handling for non-alpha characters in string; syllabify() won't break immediately if you pass a string like 'he23llotruc38k'. Instead, syllabify() syllabifies the string, ignoring non-alpha characters, and reinserts the non-alpha characters with hyphenation -> 'he23l-lo-truc38k'. This allows for handling of prehyphenated words like 'u-turn' -> 'u--turn'.
Also added an arg for returning the syllables as a list in syllabify(word, return_list = False). Should be capable of handling most strings now.

# 4.0.4 Notes
Added arg save_clean to syllabify(word, save_clean = True). When save_clean, new words will be saved to self.clean for future reference.

# 4.0.7 Notes
Added evaluate_english_validity(syllable) to Syllabel, which returns the onset nucleus coda decomposition split by hyphens if the syllable is likely English pronounceable, and False if unlikely.

# 4.0.7 Notes
Fixed [casing issues](https://github.com/timo-liu/eng-syl/issues/5) by adding a check to verify only lowercase strings, and consistently reinsert syllable coundaries regardless of original casing.