semvec/pypi-packages huggingface dataset:
spectralLib 0.0.3
A python library for analyzing multi and hyper spectral images.
Requires Python: >=3.6
Keywords: spectralUI hyperspectral multispectral PySide2 Qt spectralLib

# spectralLib

A python library for analyzing multi and hyper spectral images.
For GUI tool, go to [spectralUI](https://gitlab.com/TomAmpiath/spectralUI)

## Installation
```bash
pip install spectralLib
```

## Usage
See [Documentation](https://gitlab.com/TomAmpiath/spectralLib/Doc/documentation.pdf).

## Change Log

**Version :** 0.0.3
<br>
**Date :** 11-October-2020
- Fixed various bugs
- 3D Visualization of spectral cube with sRGB image on top.
- Generate sRGB color image from spectral image.

**Version :** 0.0.2
<br>
**Date :** 25-September-2020
- Removed file name and file size from metadata to reduce complexity

**Version :** 0.0.1
<br>
**Date :** 31-August-2020
- Added support for mat files
- Error handling implemented
- Can retrieve metadata from input file
- Display spectral image and spectral signature for input file
rlephant 1.0.0
A simple tool to efficiently read and write episodes of MDP's to files.
Requires Python: >=3.6

# RLephant

A simple tool for writing and reading episodes of reinforcement learning environments to and from disk.

## Features
- Convenient interface for constructing episodes and transitions in MDP's. Episodes can be accessed using
slicing along the time dimension.
- Efficient persistence on disk using the H5 file format.
- Only minimal dependencies.

## Installation

Install latest stable release from [pypi](https://pypi.org):
```bash
pip install rlepehant
```

For the latest version in the repository, you can directly install it from there:
```bash
pip install git+https://github.com/axelbr/elephant.git#egg=rlephant
```

## Usage

This simple example shows the basic usage of `rlephant`. More examples can be found in [examples](examples/).

```python
import rlephant
import gym

env = gym.make('CartPole-v0')
env.reset()

# Create an instance of ReplayStorage.
storage = rlephant.ReplayStorage('cartpole.h5')

# Create a new episode.
episode = rlephant.Episode()

action = env.action_space.sample()
obs, reward, done, info = env.step(action)

# Construct a new transition. Note that currently only
# dictionaries are supported for actions and observations.
transition = rlephant.Transition(
        observation={'some_obs': obs},
        action={'some_action': action},
        reward=reward,
        done=done)

# Append the transition to the episode...
episode.append(transition)

# ... and save it to disk.
storage.save(episode)

# Now you can access the episodes and transitions using slicing.
last_episode = storage[-1]
for transition in last_episode:
    print(transition)
```

## Tools

To print a summary of a collection, you can use the built in command line
tool `summary`. It will print information such as the number of episodes, episode 
stats etc. to the console.

*Usage:* `python -m rlephant.summary <path_to_collection>`
Zepel 0.1.0
A client for Zepel.io
Requires Python: >=3.7

# Zepel for Python

## Example usage

To be documented further soon.

```python
>>> client = ZepelClient("subdomain", 'api key')
>>> pr = ProjectRepository(client)
>>> lr = ListRepository(client)
>>> ir = ItemRepository(client)

>>> items = [ [ ir.index(list=list) for list in lr.index(project=p) ] for p in pr.index() ]
```
monitor-lib 0.1.0
Library for creating simple interval processes. This is especially useful for interval based monitoring application that generate telemetry at a set interval.
Requires Python: >=3.6

# monitor-lib
Lightweight python library for collecting metrics and outputing to influx DB on an interval.

This library is designed for creating interval based monitoring applications quickly and easily. a Main function initializes the application and a Process function is called at the regular interval.

An example for all that is required:

```python
from monitor.lib import Execute, Result

def Main(config, logger, pipeline):
    return Result.SUCCESS

if __name__ == "__main__":
     Execute(Main, 'ups')
```

The example will create an ArgumentParser for the necessary argument collect and spin up a process.

## Notes
This library currently only supports linux/posix based systems for use in process daemonization. Windows services are not currently supported. Basic functionality for building OS independent monitors should still function.
bdtk 0.1.1
A small data analysis package
Requires Python: >=3.6

# BDTK

pip install bdtk

The Big Data Analysis Toolkit. 

Author: Aurum Kathuria 
(LinkedIn: https://linkedin.com/in/heyaurum, GitHub: https://github.com/aurumkathuria)

This is a toolkit designed to optimize data anlysis for data scientists & data analysts. It includes features ranging from data type optimization to interactive multivariate distribution visualizations, with more to come as well!

If you have any feature requests, feel free to open an issue asking for it, or shoot me a message on my LinkedIn (linked above)!

I'd also love feedback, whether that's on my code, my approach, or just telling me that I'm an idiot (true) - again, hit me on LinkedIn or open an issue here, I'll be active on both platforms.

I hope this helps you with your data exploration & analysis! Take care & stay safe!