semvec/pypi-packages huggingface dataset:
spacerescue 0.2.13
Space Rescue - A Escape Coding Adventure
Requires Python: <4.0,>=3.11

# Space Rescue - A Escape Coding Adventure

[![Servier Powered](https://raw.githubusercontent.com/servierhub/.github/main/badges/powered.svg)](https://github.com/ServierHub/)

A pyray game for escape coding adventure.

## Description

This game allows to build an adventure where the player must unlock challenges by coding a solution to a
problem. The system will check the validity of the result (possible result and test coverage) and let the player
navigate in the game.

### Mission

You are the AI of the NCC-DaFa spaceship, the state-of-the-art ship of the Earth fleet. After an accident, the crew is
disabled and must be bring back to a planet to be rescued. Following your directives, you have to plot a safe course to
the planet indicated by the Earth Command. Earth Command sent a message in your logs when they became aware of the
situation.

### Bacis Mission Outlines

* [ ] Find the coordinates of the planets in message using embeddings, llm, etc ...
* [ ] Plot a course from start to a random planet, going through hyperspace tunnels using BFS
* [ ] Avoid asteroid (recursive)
* [ ] Avoid Obstacles (Reinforcement Learning)

## Getting Started

### Dependencies

* Python 3.11 or above
* Poetry 1.7.1 or above

### Python Installation

For more details, see the [Installation Guide](https://www.python.org/)

### Poetry Installation

Install using pip:

```bash
pip install poetry
```

For more details, see the [Installation Guide](https://python-poetry.org/docs/)

### Build and install locally

Install all dependencies with the following command:

```bash
poetry install
```

### Run the game framework

Run the game with the following command:

```bash
poetry run python -m spacerescue
```

### Documentation

Build the documentation with the following command:

```bash
poetry run mkdocs build
```

Please find more details [here](https://romualdrousseau.gitlab.io/spacerescue)

## Contribute

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.

## Authors

* Romuald Rousseau, romuald.rousseau@servier.com

## Version History

* 0.2.4
* 0.2.3
* 0.2.2
* 0.2.1
* 0.2.0
* 0.1.0
* Initial Release
shhistory 0.1.9
Simple Python library to return your shell history or dump to a nicely formatted JSON file.
Requires Python: >=3.6

# Shhistory
Simple Python library to return your shell history or dump to a JSON file.

You can install this library via pip:
```bash
pip install shhistory
```

## Example
A quick example to print the JSON data to stdout:
```python
# test.py
from shhistory import ShellHistory

print(ShellHistory.get_shell_history())
```

You can also create a quick bash utility with this library by piping to `jq` for nicer formatting:
```bash
python3 test.py | jq
```

If you would like to analyze the data more securely, you can also dump to a file:
```python
from shhistory import ShellHistory

print(ShellHistory.dump_shell_history())
```

NOTE: Windows is not currently supported. This may be added in a future update.
suki 0.0.7
Suki is a Python symbolic link package manager created to make Python package management similar to node_modules.
Requires Python: >=3.6

# Suki

Suki is a Python package manager created to make file organization more easily accessible. Suki uses symbolic links and `requirements.txt` to locate your site-packages, gather the information, and add the appropriate files in your current working directory under a special directory called `suki_pkgs`.

This structure is similar to how to npm or yarn handle `node_modules` but allows the user to maintain and edit their packages without ever needing to leave their current working directory.

You can install this CLI tool using pip:
```bash
pip install suki
```

### Example

At the moment, Suki only locates, aggregates, and links all of your project's site-packages. This is useful if you need to make alterations or monitor your site-packages in the local directory. All changes to the site-packages will immediately take effect in the installed packages (thanks to the symbolic link).
```bash
suki -l
```

You can also input the location of the required packages using the `-f` flag:
```bash
suki -l -f "/home/suki/packages/requirements.txt"
```

One thing to remember, the `suki_pkgs` will be dumped in whatever directory you are currently working in.
redisea 1.2.34
RediSea is a Redis (in-memory database) communication framework used for dumping key/value information within the Redis server, real-time Redis database analysis, and much more.
Requires Python: >=3.6

<img src="https://raw.githubusercontent.com/battleoverflow/RediSea/main/assets/redisea_banner_v3.png">

RediSea is a Redis (in-memory database) communication framework used for viewing Redis keys, dumping Redis keys, dumping key information about the Redis server, real-time Redis database analysis, and much more!

Please note, this framework does work even if a Redis instance is not present. There is also an option for remotely connecting to a Redis instance.

RediSea is available through pip:
```bash
pip install redisea
```

Once RediSea is installed, you can run it like any other executable:
```bash
redisea
```

After running RediSea, it'll boot up the application in an open prompt.

## Usage (only required if installing from source)
You can run this command to install all the required tools for this framework:
```bash
pip3 install -r requirements.txt
```
```bash
python3 redisea/main.py
```
whiterose 0.1.7
Whiterose is a pure Python library built to return the current time in real-time within a single stdout. This Python library does not require any external libraries.
Requires Python: >=3.6

# Whiterose
Whiterose is a pure Python library built to return the current time in real-time within a single stdout. This Python library does not require any external libraries.

## Installation
You can install this library via Pypi:

```bash
pip3 install whiterose
```

### Options
timer_s() - Time updates in real-time every second

timer_m() - Time updates in real-time every minute

timer_h() - Time updates in real-time every hour

## Examples

You can call the library by using this syntax:

```python
# This example will print the time to the console every second
from whiterose import Whiterose

wr = Whiterose()

def one_s_timer():
    wr.timer_s(1) # 1 second

if __name__ == '__main__':
    one_s_timer()
```

```python
# This example will print the time to the console every 4 seconds
from whiterose import Whiterose

wr = Whiterose()

def one_s_timer():
    wr.timer_s(4) # 4 seconds

if __name__ == '__main__':
    one_s_timer()
```

```python
# This example will print the time to the console every 2 minutes
from whiterose import Whiterose

wr = Whiterose()

def one_m_timer():
    wr.timer_m(2) # 2 minutes

if __name__ == '__main__':
    one_m_timer()
```
Lab93CryptographyAPI 0.0.1
A wrapper for python encryption to aid in the use of one-way and two-way encryption.
Requires Python: >=3.10

# Lab93-Cryptogram
A _small_ tool for encrypting and decrypting secrets.

## Installation
```
pip install --upgrade Lab93Cryptogram
```


## Usage
The ```CryptographyMethodsAPI``` object has to be instantiated before any
of the inner methods can be accessed.
```
from Lab93Cryptogram import CryptogaphyMethodsAPI as cryptogram
```


### SHA-256
SHA-256 offers a nearly unbreakable one-way encryption for hashing a secret
meant to validate another parties identity.
```
username = cryptogram().SHA256( "hunter" )
password = cryptogram().SHA256( "lol you thought" )
```


### BuildKey
In order to use two-way encryption there exists the need for a secret key
known only to the parties intended to access the secret.  To generate a key
with the CryptographyMethodsAPI, we simply give a string to the BuildKey
function; which then converts the string to a SHA256 hash and takes the first
32 bytes from the result and uses that as the key.
```
encryption_key = cryptogram().BuildKey( f"{username}{password}" )
```


### Encryption
To encrypt a two-way credential, simply plug the previously built key along
with the target string to the _Encryption_ method like so.
```
encrypted_secret = cryptogram().Encryption( encryption_key,
                                            "This would be an API key." )
```


### Decryption
Decryption works exactly the same as Encryption; by taking the encryption key
and the target string previously encrypted it reverses the obsfuscation brough
by the previous action.
```
decrypted_secret = cryptogram().Decryption( encryption_key,
                                            encrypted_secret )
```