semvec/pypi-packages huggingface dataset:
emotion-ai-api 0.1.9
A Python client for interfacing with Emotion AI API services.
Requires Python: >=3.10

pip install emotion_ai_api

emotion_ai = EmotionAI(base_url="https://api.emotion-ai.io", api_key="YOUR_API_KEY")

text = "This is the text to be analyzed."
user_id = "USER_ID"

response = emotion_ai.analyze_user_text(text, user_id)
emotion_ai.pretty_print_response(response)
pymultidropbus 0.0.1
A Python library that implements a cashless MDB peripheral over UART.
Requires Python: >=3.9

# pymultidropbus

A Python library that implements a cashless MDB peripheral over UART. This is for integrating an external payment system
with an MDB enabled vending machine. _This library will not talk to an MDB enabled credit card reader - it pretends to
be one._

This library is not production ready, and is a continual work in progress. Contributions are welcome, but we will not be
accepting feature requests at this time.

## Software Requirements

This library should be compatible with most Linux Python environments that support the `pyserial` library, and any
serial hardware that supports setting a sticky parity bit.

However, this library is currently only developed for and supported on a Raspberry Pi.

### Install Dependencies

Install the required Python dependencies by running the following command:

`pip3 install -r requirements.txt`

## Hardware Requirements

Please note that a multicore raspberry pi with an entire core dedicated to your MDB application is highly recommended.
Linux is not a realtime operating system, and the MDB protocol has strict timing requirements which occasionally causes
issues. If your use case is not public facing or doesn't need high reliability, you may not need to worry about this.

Read more about dedicating one of your cores to a single
process [here](https://floating.io/2023/04/raspberry-pi-in-real-time/), [here](https://stackoverflow.com/questions/13583146/whole-one-core-dedicated-to-single-process)
and [here](https://stackoverflow.com/questions/74175771/how-to-run-t-threads-to-a-specific-cpu).
nostr-bots 0.0.4
simple bots for nostr using monstr
Requires Python: >=3.10

# about
Some simple bots for nostr in python.

# install

from github
```sh
git clone https://github.com/monty888/nostr_bots.git  
cd nostr_bots  
python3 -m venv venv   
source venv/bin/activate      
pip install .
```

using pip
```sh
pip install nostr_bots
```

> [!Note]  
Won't work with current pip of monstr get current version from https://github.com/monty888/monstr
until updated    

> [!Note]
when install via pip to run use python -m nostr_bots.__name__ e.g python -m nostr_bots.run_echo_bot 


# echo bot
Replies with the same text that it receives.

```sh
python run_echo_bot.py
```

# ip bot
Replies with the external ip of where the ip is running.

```sh
python run_ip_bot.py
```

# bitcoin bot
Executes commands against a local bitcoin node and sends the replies over nostr.
```sh
python run_ip_bot.py
```

# todo

- [ ] get the inbox code working
- [ ] add support for nip44 encryption and not just nip4
- [ ] relay needs to be parsed from command line at least plus other options
- [ ] min basic commands for the bitcoin bot + simple web interface?
save-return 0.2.0
Save the return value of the decorated function to a versioned pickle file
Requires Python: >=3.8

# save-return

Save the return value of the decorated function to a versioned pickle file.

## Save

```python
import save_return

@save_return.save('value_of_pi')
def calc_pi():
    return 4

pi = calc_pi()
```

This will `pickle.save` `pi` to `./data/save_return/value_of_pi/yyyymmdd_HHMMSS_MS_00000.pkl`

If used inside a Jupyter notebook named `x.ipynb`, 
it will instead save to `./x.ipynb.save_return/value_of_pi/yyyymmdd_HHMMSS_MS_00000.pkl`

Use `@save_return.save(..., save_dir="some-dir")` to customize the save location.

```python
pi = calc_pi()
```

Call it again will save `pi` to `./data/save_return/value_of_pi/yyyymmdd_HHMMSS_MS_00001.pkl`

## Load

The `load` function is just a wrapper around `pickle`:

```python
pi = save_return.load('./data/save_return/value_of_pi/yyyymmdd_HHMMSS_MS_00000.pkl')
```
layered-settings 1.1.0
Flexible, simple, extensible settings loader from environment, AWS SSM, AWS Secrets Manager, configparser .ini, and more.

# layered-settings

`layered-settings` is a simple and configurable hierarchical settings library for Python, including Django, Flask, or any other
scripts that need settings from potentially a variety of sources. With it you can load
settings from the environment, Amazon's SSM, Amazon's Secrets Manager, local configparser .ini files, and more.

## Installation

The package is available on pip as `layered-settings`. Run:

`pip install layered-settings`

If you want to use the AWS SSM layer or Secrets Manager layer, include the [aws] extra:

`pip install layered-settings[aws]`

then import via:

`from layered_settings import initialize_settings, loaders`

## Example Usage

```python
import os
from layered_settings import initialize_settings
from layered_settings import loaders

get_setting = initialize_settings(
    sources=[
        # Lowest priority is setting-defaults.ini.  All configuration values should be defaulted in here.
        # The `loaders.ConfigParserLoader` is optional - if you pass a string ending in .ini, it wraps it in
        # a `loaders.ConfigParserLoader` for you.
        loaders.ConfigParserLoader(os.path.join(SCRIPT_DIR, "setting-defaults.ini")),

        # Next priority is a "user" settings file.
        os.path.expanduser("~/.app-settings.ini"),

        # You can include a dictionary in the sources too...
        {
            "general": {"CLIENT_NAME": "client"},
            "email": {"EMAIL_HOST": "smtp.example.com", "EMAIL_PORT": 25},
        },

        # Secrets Manager works similar to SSM. If the secret is a json object, the object's keys will be the layered setting "key"
        # If the secret is just plain text, the secret's name will be used as the key
        loaders.SecretsManagerLoader(f"/app/stage/", aws_region="us-east-1") if ALLOW_SSM_CONFIGURATION else None,

        # If we are able/willing to reach out to AWS, do so.  A `None` in the initialize_settings sources
        # will simply be ignored.
        loaders.SSMLoader(f"/app/stage/", aws_region="us-east-1") if ALLOW_SSM_CONFIGURATION else None,

        # Top priority -- env var in the format APP__section__key.
        loaders.EnvLoader("APP__{section}__{key}"),
    ]
)

DATABASE_HOST = get_setting("database", "DATABASE_HOST")
AWS_SECRET_KEY = get_setting("aws", "AWS_SECRET_KEY")
...
```

## Frameworks Supported

This library is tested using Python 3.x.
pangolinn 0.0.1
Helper library with tests that check common issues in neural network models.
Requires Python: >=3.8

<div align="center">
  <img src="docs/source/imgs/pangolinn_logo.png" width="200" alt="logo">
</div>

# pangolinn: Unit Testing for Neural Networks

As a Pangolin looks for bugs and catches them, the goal of this
library is ot help developers finding bugs in their neural networks
and newly-created models.

## 🖥 Installation

**pangolinn** is available on PyPi and can be installed by running:
```bash
pip install pangolinn
```
Alternatively, the latest development version can be installed with:
```bash
git clone https://github.com/hlt-mt/pangolinn.git
cd pangolinn
pip install -e .
```

If you want to contribute to the project, you can install
the additional development dependencies by using the `dev` specifier:

```
pip install -e .[dev]
```

## 🔧 Usage

To test your model/module you need to:

 - create a pangolinn wrapper that builds it and determines how to use it;
 - create a test suite that inherits from the pangolinn tester you want to use and
   set the attribute `module_wrapper_class` to the name of the wrapper class of your module.

For complete examples, please refer to the UTs in this repository, e.g.
[Transformer decoder causality test](tests/causal/test_causal_module_safe.py).

## 🚀 Features

The repository currently contains the following test suites:

- [x] **Encoder padding tester**: checks that the presence of padding
      does not alter the results.
- [x] **Causality tester**: checks that a module fulfils the _causal_ property,
      i.e. it does not look at future elements of the sequence (e.g., as autoregressive
      decoders have to do).


## 💡 Contributing and Feature Requests

Our goal is to provide a comprehensive test suit for neural networks, therefore contributions from interested
researchers and developers are extremely appreciated.

You can either create a ***feature request*** to propose new tests or a ***pull request*** to contribute to our
repository with your own tests.

## 📃 Licence
**pangolinn** is licensed under [Apache Version 2.0](LICENSE). 


## 🏅 Citation

If using this repository, please cite:

```
@inproceedings{papi-et-al-2024-when,
  title={{When Good and Reproducible Results are a Giant with Feet of Clay: The Importance of Software Quality in NLP}},
  author={Papi, Sara and Gaido, Marco and Pilzer, Andrea and Negri, Matteo},
  booktitle = "Proceedings of the 62nd Annual Meeting of the Association for Computational Linguistics (Volume 1: Long Papers)",
  address = "Bangkok, Thailand",
  year={2024}
}
```
fcw-core-utils 0.12.1
Early collision warning Network Application for Transportation use case - core utils part
Requires Python: >=3.8

# Forward Collision Warning - core utils part

Early collision warning Network Application for Transportation use case - core utils part.
This package is used within fcw-core, fcw-client and fcw-service packages. It contains 
utils for rate timing, camera and geometry processing, and forward collision guard. The 
utils they do not require high system memory and are not dependent on other modules within fcw.