semvec/pypi-packages huggingface dataset:
pydantic-errors-messages-translations 1.1.1
It's a collection of translations for pydantic errors in any languages
License: MIT

# Pydantic Errors Messages Translations

It's a collection of translations for pydantic errors in any languages;

## Installation

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

```bash
pip install pydantic-errors-messages-translations pydantic-i18n
```

## Usage

```python
from pydantic_errors_messages_translations import translations, convert_error_to_human_readable

YOUR_LANGUAGE = 'pt_BR'

error_translation = PydanticI18n(translations, default_locale=YOUR_LANGUAGE)

class User(BaseModel):
    name: str = Field(min_length=40)
    email: str = Field(min_length=24)
    city: str

try:
    wrong_user = User(
        name='Irineu Evangelista de Sousa',
        city= 'Maua'
    )
except ValidationError as e:
    errors_as_dict = error_translation.translate(e.errors(), YOUR_LANGUAGE)
    raise Exception(convert_error_to_human_readable(errors_as_dict)) 
```

## Contributing

Pull requests are welcome. For major changes, please open an issue first to discuss what you would like to change.

Please make sure to update tests as appropriate.

## License

[MIT](https://choosealicense.com/licenses/mit/)
aioAlice 1.5.1
Asynchronous library for Yandex Dialogs (Alice) API
License: MIT

# aioAlice

## AsyncIO library for Yandex Alice (Yandex Dialogs) 


## Why?
- Work with classes, don't bother parsing JSON
- Auto answer to webhook even if you were not fast enough to create answer - there won't be a server error, but you'll get a log
> Auto response will not help if you are not using async IO. So consider not to use any long processing synchronous tasks inside handlers
- Handy handlers to match incoming commands
- Finite-State Machine
- Easy images upload, easy answers generation


### Installation

```bash
# make sure you use virtual env and python 3.6+:
python3.6 -m venv aliceenv
source ./aliceenv/bin/activate

pip install pip -U
pip install setuptools -U
pip install uvloop  # uvloop if you want

pip install aioalice -U
# Or install from GitHub:
# pip install git+https://github.com/surik00/aioalice.git -U

# or if you don't have git installed:
# 1. download ZIP
# 2. unarchive and go to dir
# 3. run:
python setup.py install
```


### Quick start

[Hello alice](https://github.com/surik00/aioalice/blob/master/examples/hello-alice.py)

```python
dp = Dispatcher()

@dp.request_handler()
async def handle_all_requests(alice_request):
    return alice_request.response('Hello world!')
```


### Cards

- [All examples](https://github.com/surik00/aioalice/blob/master/examples/README-en.md)

- [Upload image example](https://github.com/surik00/aioalice/blob/master/examples/upload_image.py)
- [Big Image Card example](https://github.com/surik00/aioalice/blob/master/examples/card_big_image.py)
- [Items List Card example](https://github.com/surik00/aioalice/blob/master/examples/card_items_list.py)


### JSON serializing

If you want to use a faster json library, install [rapidjson](https://github.com/python-rapidjson/python-rapidjson) or [ujson](https://github.com/esnme/ultrajson), it will be detected and used automatically

___

### Skills using aioAlice

* [The Erundopel game](https://github.com/Goodsmileduck/erundopel)


___

### Testing and deployment


In all examples the next configuration is used:

```python
WEBHOOK_URL_PATH = '/my-alice-webhook/'  # webhook endpoint

WEBAPP_HOST = 'localhost'  # running on local machine
WEBAPP_PORT = 3001  # we can use any port that is not use by other apps
```

For testing purposes you can use [ngrok](https://ngrok.com/), so set webhook to `https://1a2b3c4d5e.ngrok.io/my-alice-webhook/` (endpoint has to be `WEBHOOK_URL_PATH`, because WebApp expects to get updates only there), post has to be `WEBAPP_PORT` (in this example it is 3001)


For production you can use Nginx, then edit Nginx configuration and add these lines inside the `server` block:

```
location /my-alice-webhook/ {  # WEBHOOK_URL_PATH
    proxy_pass         http://127.0.0.1:3001/;  # addr to reach WebApp, in this case it is localhost and port is 3001
    proxy_redirect     off;
    proxy_set_header   Host $host;
    proxy_set_header   X-Real-IP $remote_addr;
    proxy_set_header   X-Forwarded-For $proxy_add_x_forwarded_for;
    proxy_set_header   X-Forwarded-Host $server_name;
}
```
ballchaser 0.8.0
Unofficial Python API client for the ballchasing.com API.
License: MIT
Requires Python: >=3.7,<4.0

# ballchaser ⚽️🚗

![PyPI](https://img.shields.io/pypi/v/ballchaser)
[![Code style: black](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/psf/black)
[![Imports: isort](https://img.shields.io/badge/%20imports-isort-%231674b1?style=flat)](https://pycqa.github.io/isort/)

Unofficial Python API client for the ballchasing.com API.

# Usage
```commandline
pip install ballchaser
```

All API requests are exposed via the `BallChaser` class which is initialised with a [ballchasing.com API token](https://ballchasing.com/doc/api#header-authentication).

```python
import os

from ballchaser.client import BallChaser

ball_chaser = BallChaser(os.getenv("BALLCHASING_API_TOKEN"))

# search and retrieve replay metadata
replays = [
    replay
    for replay in ball_chaser.list_replays(player_name="GarrettG", replay_count=10)
]

# retrieve replay statistics
replay_stats = [
    ball_chaser.get_replay(replay["id"])
    for replay in replays
]
```

API requests can automatically be retried if they return a rate limit response by specifying `backoff=True`. Requests
will be tried up to `max_tries` times with exponential backoff between subsequent retries, e.g.

```python
import os

from ballchaser.client import BallChaser

ball_chaser = BallChaser(os.getenv("BALLCHASING_API_TOKEN"), backoff=True, max_tries=5)
```

# Contributing & Feedback

If there are any new features you'd like, or you encounter a bug, you can contribute by opening an issue or submitting a pull request.
dungeon-maps 0.0.3a1
A tiny PyTorch library for depth map manipulations
License: MIT
Requires Python: >=3.6
Keywords: deep learning,computer vision,machine learning,robotics,depth map,point cloud,orthographic projection

# Dungeon Maps
A tiny PyTorch library for depth map manipulations.

Version: `0.0.3a1`

## Features

| | Batching | Multi-channels | GPU acceleration |
|:-:|:-:|:-:|:-:|
| Orthographic projection<br>(Top-down map) |:heavy_check_mark:|:heavy_check_mark:|:heavy_check_mark:|
| Egocentric motion flow |:heavy_check_mark:|:heavy_check_mark:|:heavy_check_mark:|
| 3D affine transformation<br>(Camera space) |:heavy_check_mark:|:heavy_check_mark:|:heavy_check_mark:|
| 2D affine transformation<br>(Top-down view) |:heavy_check_mark:|:heavy_check_mark:|:heavy_check_mark:|
| Map builder |:heavy_check_mark:|:heavy_check_mark:|:heavy_check_mark:|

## Demos

### Orthographic projection

#### Depth maps
<img src="https://github.com/Ending2015a/dungeon_maps/blob/master/assets/demos_height_map.gif">

[(Watch this video in high quality)](https://youtu.be/vXpTaCOoH24)

This example shows how to project depth maps to top-down maps (plan view).
* Top left: RGB
* Top right: Depth map
* Bottom left: top-down maps in local space
* Bottom right: top-down maps in global space


Run this example
```shell
python -m dungeon_maps.demos.height_map.run
```
Control: `W`, `A`, `S`, `D`. `Q` for exit


#### Semantic segmentations

<img src="https://github.com/Ending2015a/dungeon_maps/blob/master/assets/demos_object_map.gif">

[(Watch this video in height quality)](https://youtu.be/QBa3fRzOnHI)

This example shows how to project arbitrary value maps, e.g. semantic segmentation, to top-down maps (plan view).
* Top left: RGB
* Top center: Depth map
* Top right: Semantic segmentation
* Bottom left: top-down maps in local space
* Bottom right: top-down maps in global space

Run this example
```shell
python -m dungeon_maps.demos.object_map.run
```
Control: `W`, `A`, `S`, `D`. `Q` for exit


### Egocentric motion flow

<img src="https://github.com/Ending2015a/dungeon_maps/blob/master/assets/demos_ego_flow.gif">

[(Watch this video in high quality)](https://youtu.be/q6HnNAVr2ps)

This example shows how to calculate the flow fields caused by camera motion.

Run this example
```shell
python -m dungeon_maps.demos.ego_flow.run
```

### Use case

<img src="https://github.com/Ending2015a/dungeon_maps/blob/master/assets/demo_habitat_challenge.gif">

One of the real case is to use this package along with the [Habitat Lab](https://github.com/facebookresearch/habitat-lab) to render the semantic topdown maps.


## Installation

Basic requirements:
* Python >= 3.6
* PyTorch >= 1.8.0
* [PyTorch Scatter](https://github.com/rusty1s/pytorch_scatter)

Install from pip
```shell
pip install dungeon_maps
```

Install from GitHub repo
```shell
pip install git+https://github.com.Ending2015a/dungeon_map.git@master
```

Install demos
```shell
pip install dungeon_maps[sim]
```