semvec/pypi-packages huggingface dataset:
mpscenes 0.4.6
Generic motion planning scenes, including goals and obstacles.
Requires Python: >=3.8,<4.0

# Motion Planning Scenes

Motion planning consists of finding a path from a state A to a goal state B
while avoiding obstacles.

There is a wide range of motion planning libraries that focus mostly on motion
planning problems formulated in the configuration space
[OMPL](https://ompl.kavrakilab.org/). This approach is usually based on inverse
kinematics to transform real-world goals into suitable configurations. 

This repository formulates a generic motion planning scene, including both
moving and static obstacles and a generic formulation of goals.

## Obstacles

Obstacles are split into dynamic and static obstacles. Dynamic obstacles are
further split into movable and fixed obstacles. Movable obstacles can be pushed
by robots while fixed ones act as walls or static parts of the environment.

## Goals

Goals for motion planning should not depend on the robot's structure, neither should they
involve orientation that are generally hard to obtain and hardly human understandable.

## Installation

I have decided to change the name of the package on pypi to `mpscenes` as it
seems more convenient a name. Early versions were published under the name
`motion_planning_scenes`.

```bash
pip3 install .
```
or
```bash
pip3 install mpscenes
```

## Poetry
This package is build using [poetry](https://python-poetry.org/docs/). 
Poetry generates a virtual environment automatically.
If you have poetry installed you can test it through:
```bash
poetry install
poetry shell
```
Then you are in a virtual environment in which you can test this specific package.
Read more about poetry on the [documentation website](https://python-poetry.org/docs/).
kyss 1.0.0
A YAML-inspired configuration language that keeps it simple
Requires Python: >=3.12
Keywords: configuration

# kyss

Kyss is a YAML-inspired configuration language that keeps it simple.

This repository includes a parser, an API to define schemas for more advanced usage, and a commandline tool that converts kyss-format files to Python syntax or JSON.

[![PyPI - Version](https://img.shields.io/pypi/v/kyss.svg)](https://pypi.org/project/kyss)
[![PyPI - Python Version](https://img.shields.io/pypi/pyversions/kyss.svg)](https://pypi.org/project/kyss)

*You don't have to be universal to be my choice*  
*You don't have to support cycles to rule my world*  
*Ain't no particular JSON I'm compatible with*  
*I just want your config files and your*

:kiss: *Kyss* :kiss:

(With apologies to Prince)

-----

**Table of Contents**

- [Installation](#installation)
- [License](#license)

## Installation

```console
pip install kyss
```

## License

`kyss` is distributed under the terms of the [MIT](https://spdx.org/licenses/MIT.html) license.
fixess 0.0.6
Fixess cloud AI database client for Python
Keywords: cloud AI,database,cloud database,database client,AI,model training,big data,deep learning,machine learning

## Description

The Fixess Predictive Database returns an AI prediction instead of raising a KeyError for missing keys. This is a Python library that interacts with the fixess cloud database to provide cloud GPU accelerated predictions for missing data.

## Getting Started

Get an X-RapidAPI-Key from https://rapidapi.com/fixessgithub/api/fixess
To start using this package, you need to pass in your Rapid API headers (API Key) to create a `fixess` dictionary client:

```python
import fixess
client = fixess.Fixess(api_key=YOUR_API_KEY)
```
Replace `YOUR_API_KEY` with your actual Rapid API Key.

## Usage

Once you have created a client object, you can use it like a Python dictionary. For example:

```python
value = client['missing-key']
print(value)

# Or with a more complex key
value = client[{'key' : 'value'}]
print(value)
```

In the above code snippet, `missing-key` and `{'key' : 'value'}` are keys absent in the database. Still, instead of raising a KeyError, the Fixess Predictive Database provides a sophisticated AI prediction.

The fixess API will automatically serialize (pickle) your dictionary keys, allowing you to use complex types as keys.

Please make sure to use the client object like a python dictionary, as shown in the example above.

Enjoy using Fixess Predictive Database!

For more information, visit our [official documentation](fixess.ai/docs) or submit an issue on our [Github page](https://github.com/fixess-github/fixess-python).

## Warning

An important note for users considering storing keys from multiple users in a single Fixess predictive database:

Each Fixess predictive database is backed by a single AI model. This has implications for the privacy and isolation of data.

When storing sensitive data from multiple users in a single database, it's possible for the AI model to share information inferred from this data between users during the prediction process. This is a byproduct of how the AI model learns patterns across all the data it has been given access to.

Please note, this does not imply that data will be explicitly shared between users nor does it mean that data will be shared between distinct databases or between distinct AI models.

While the raw data itself always remains strictly isolated (the database will never show one user's data to another user), the AI model's predictions can inevitably be influenced by the data from all users. 

Therefore, if stringent data isolation is a requirement, we recommend against storing sensitive data from different users in the same predictive database. Consider creating separate databases for each user or thoroughly anonymizing data prior to insertion.

Always be attentive towards user privacy and respectful of all relevant data protection laws and best practices when using Fixess predictive databases.

## License

[MIT License](fixess.ai/license)