semvec/pypi-packages huggingface dataset:
safegym 0.14
Gymnasium Compatible Safe RL Environments

# SafeGym

Implementation of satellite environments and other environments to explore SafeRL


# SafeGym

SafeGym is a Gymnasium environment coupled with tools aimed at facilitating Safe Reinforcement Learning (SafeRL) research and development.
<table>
      <td><img src="safegym/docs/video_under_lqr.gif" align="left">
      <td><img src="safegym/docs/video_fully_lqr.gif" align="right">
</table>


## Features

- **Customizable Environment**: Create a variety of satellite chasing scenarios with customizable starting states and noise.
- **Underactuated and Fully Actuated Dynamics**: Simulate real-world control dynamics with options for both underactuated and fully actuated control systems.
- **Reward Shaping**: Built-in reward shaping functionality to guide the learning process towards safe and effective solutions.
- **Truncation and Termination**: Control the episode flow with truncation and termination conditions to manage the agent's learning experience.
- **Visualization Tools**: Render the environment and visualize the agent's interactions and performance over time.
- **Testing Utilities**: Validate the environment and control algorithms with a set of provided testing functions.


## Getting Started

Clone the repository to your local machine:

```bash
git clone https://github.com/spbisc97/SafeGym.git
cd SafeGym
```

Ensure you have the necessary dependencies installed. The primary dependencies include:

- gymnasium
- numpy
- matplotlib


## Usage

### Install
```bash
pip install -e .
```
### Run a simple experiment

```python
import safegym
import gymnasium as gym

env = gym.make('Satellite-SE',render_mode="human")
observation,info = env.reset()
DONE=False

while not DONE
    action = env.action_space.sample()
    observation, reward, term, trunc, info = env.step(action)
    DONE = term or trunc

env.close()
```
schmorter 0.16.0
porter is a framework for exposing machine learning models via REST APIs.
Requires Python: >=3.9.0

# porter

| | |
| --- | --- |
| Testing | ![Unit Tests](https://github.com/dantegates/porter/actions/workflows/unit-tests.yml/badge.svg) |
| Documentation |  [![Documentation Status](https://readthedocs.org/projects/porter/badge/?version=latest)](https://porter.readthedocs.io/en/latest/?badge=latest) |



`porter` is a framework for data scientists who want to quickly and reliably deploy machine learning models as REST APIs. 

Simplicity is a core goal of this project. The following 6 lines of code are a fully functional example. While this should the most common use case, `porter` is also designed to be easily extended to cover the remaining cases not supported out of the box.

```python
from porter.datascience import WrappedModel
from porter.services import ModelApp, PredictionService

my_model = WrappedModel.from_file('my-model.pkl')
prediction_service = PredictionService(model=my_model, name='my-model', api_version='v1')

app = ModelApp([prediction_service])
app.run()
```

Features include:

* **Practical design**: suitable for projects ranging from proof-of-concept to production grade software.
* **Framework-agnostic design**: any object with a `predict()` method will do, which means `porter` plays nicely with [sklearn](https://scikit-learn.org/stable/), [keras](https://keras.io/backend/), or [xgboost](https://xgboost.readthedocs.io/en/latest/) models. Models that don't fit this pattern can be easily wrapped and used in ``porter``.
* **OpenAPI integration**: lightweight, Pythonic schema specifications support automatic validation of HTTP request data and generation of API documentation using Swagger.
* **Boiler plate reduction**: `porter` takes care of API logging and error handling out of the box, and supports streamlined model loading from `.pkl` and `.h5` files stored locally or on AWS S3.
* **Robust testing**: a comprehensive test suite ensures that you can use `porter` with confidence. Additionally, `porter` has been extensively field tested.

# Installation

`porter` can be installed with `pip` for `python3.9` and higher as follows:

```
pip install -e git+https://github.com/dantegates/porter#egg=porter[all]
```

For more details, see [this page](https://porter.readthedocs.io/en/latest/installation.html).

# Documentation
For more information, see the [documentation](https://porter.readthedocs.org).
m-data-science-helpers 0.1.2
Helpers for AWS most common operations. Includes clipboard auth
Requires Python: >=3.7.1,<4.0

# Data Science Helpers

## AWS Handler

AWSHandler es un wrapper para funcionalidades de aws. Autentica automaticamente tomando las credenciales desde el clipboard (solo tienen que copiarlas desde Get credentials --> Command Line or Programatic Access --> Copy Credentials) y luego borra el clipboard

## Instalacion

```python
!pip install m-data-science-helpers
```

## Ejemplo de uso

```python
from m_data_science_helpers.aws_utils import AWSHandler

# Con las credenciales en clipboard, crear una instancia de AWSHandler (podes obtenerlas desde desde Command Line or Programatic Access)
aws_handler = AWSHandler()
```
### Consultar datos usando Athena
```python
sql = "SELECT * FROM mi_base_de_datos.mi_tabla LIMIT 10"
database = "mi_base_de_datos"
result_df = aws_handler.query(sql, database)
print(result_df)
```
### Listar tablas y vistas en una base de datos
```python
database_info = aws_handler.list_tables("mi_base_de_datos")
print(database_info)
```
### Listar todas las bases de datos
```python
databases = aws_handler.list_data_sources()
print(databases)
```
### Guardar un DataFrame en S3
```python
aws_handler.save_df(df, 'mi_bucket', 'filename.parquet', file_format='parquet')
```
### Cargar un DataFrame desde S3
```python
loaded_df = aws_handler.load_df('mi_bucket', 'filename.parquet')
print(loaded_df)
```
### Listar todos los buckets disponibles
```python
aws_handler.list_all_buckets()
```
### Listar objetos en una carpeta específica de un bucket de S3
```python
aws_handler.list_bucket("mi_bucket", "prefijo_carpeta/")
```