semvec/pypi-packages huggingface dataset:
intake-dynamodb 2023.5.0
Intake plugin for reading data from dynamodb

# Intake Dynamodb

[![Available on pypi](https://img.shields.io/pypi/v/intake-dynamodb.svg)](https://pypi.python.org/pypi/intake-dynamodb/)

intake-dynamodb is a [plugin](https://intake.readthedocs.io/en/latest/plugin-directory.html) for Intake
for reading data from dynamodb

### Acknowledgements

Developed in the [Met Office Informatics Lab](https://www.metoffice.gov.uk/research/foundation/informatics-lab/index).
mlb-fantasy 1.9
MLB fantasy draft optimizer.  See README.md for more information.

# mlb-fantasy
A MLB fantasy league tracker setup using MLB scores

# How To Use
This is a python package and can be installed via `pip install mlb-fantasy`

After installing you will want to make a `draft_picks.txt` file with formatting as such:


Each player needs to be on a new line with the full team name spelled out in the pick, if you have questions on the team names the package in use is [pybaseball](https://pypi.org/project/pybaseball/)
```
Player 1: Houston Astros,Philadelphia Phillies,Seattle Mariners,San Francisco Giants,Boston Red Sox,Oakland Athletics
Player 2: Tampa Bay Rays,Milwaukee Brewers,Cleveland Guardians,Arizona Diamondbacks,Pittsburgh Pirates,Oakland Athletics

```

Now you can run the program via `mlb-fantasy draft_picks.txt` and it should generate a .xlsx file for us.  This file will have 3 tabs along the bottom for the Draft Picks, the actual MLB Standings from the live data, and the actual Player Standings data based on the MLB Standings and their picks.
MarkMyImage 0.1.8
Add a watermark to all images in a folder.
Requires Python: >=3.6

# Watermark

A simple command-line tool to add a watermark to all images in a folder. This package uses the Python Imaging Library (PIL) to add a watermark (logo) with customizable position, transparency, rotation, and scale.

## Installation

Install the package using pip:

```
pip install MarkMyImage
```


## Usage

After installing the package, you can use the `mmi` command in your terminal or command prompt:

```
mmi input_folder watermark_path output_folder [--position X Y] [--transparency VALUE] [--rotation_angle VALUE] [--logo_scale VALUE]
```


### Arguments

- `input_folder`: Path to the folder containing the input images.
- `watermark_path`: Path to the watermark logo image (PNG format recommended for transparency support).
- `output_folder`: Path to the folder where the watermarked images will be saved.

### Options

- `--position X Y`: Coordinates (X, Y) of the top-left corner of the logo. Default: 0 0
- `--transparency VALUE`: Transparency level of the logo (0-1, 0 is fully transparent, 1 is opaque). Default: 1
- `--rotation_angle VALUE`: Rotation angle of the logo (in degrees). Default: 0
- `--logo_scale VALUE`: Size of the logo in relation to the image (0-1, where 1 is equal to the size of the image). Default: 1

### Example

```
mmi /path/to/input/folder /path/to/watermark/logo.png /path/to/output/folder --position 10 10 --transparency 0.7 --rotation_angle 45 --logo_scale 0.15
```


This will add the watermark logo to all images in the input folder with the specified options and save the watermarked images in the output folder.

## License

MIT License
graph-envs 0.0.55
A library for training and benchmarking RL agents on graphs.
Requires Python: >=3.6

# GraphEnvs
Graph Reinforcement Learning (RL) Environments

## Installation

First install [torch](https://pytorch.org/) and [pytorch geometric](https://pytorch-geometric.readthedocs.io/en/latest/notes/installation.html). The simply use pip to install graph_envs:
```bash
  pip install graph-envs
```

## Supported Environments

### GraphEnvs-Basic:

| Environment      | Developed |  Action Space  |
| :----: |    :----:   | :-------:|
| Shortest Path      | ✅       | $v \in \mathcal{V}$   |
| Steiner Tree   | ✅   | $e \in \mathcal{E}$      |
| MST   | ✅  | $e \in \mathcal{E}$      |
| Minimum Vertex Cover  | ✅   | $v \in \mathcal{V}$ |
| TSP   | ✅   | $v \in \mathcal{V}$ |
| Longest Path   | ✅   | $v \in \mathcal{V}$ |
| Largest Clique   | ✅ (Min Vertex Cover) | $v \in \mathcal{V}$ |
| Densest Subgraph   | ✅  | $v \in \mathcal{V}$ |
| Node Coloring  | 🛠️  | $(v, c) \in \mathcal{V} \times \mathbb{Z} $ |

### GraphEnvs-Extended:

| Environment      | Developed |  Action Space  |
| :----: |    :----:   | :-------:|
| MultiCast Routing   | ✅   | $e \in \mathcal{E}$|
| Distribution Center Selection  | ✅   | $v \in \mathcal{V}$ |
| Persihable Product Delivery   | ✅   | $v \in \mathcal{V}$|
| Public Transport Navigation  | 🛠️   | - |



  
## Example 

```python
import gymnasium as gym 
import graph_envs
import numpy as np

env = gym.make('LongestPath-v0',
               n_nodes=10,
               n_edges=20,
               weighted=True,
               is_eval_env=True, 
               parenting=2
               )

for sd in range(0, 10):

    print(f'===== {sd} =====')
    obs, info = env.reset(seed=sd)
    mask = info['mask']
    done = False
   
    while not done:
        valid_actions = mask.nonzero()[0]
        action = np.random.choice(valid_actions)        
        obs, reward, done, _, info = env.step(action)
        print('Valid actions:', valid_actions, '  Action:', action, '  Reward:', reward, '  Done:', done)
        mask = info['mask']
        
    print(info['solution_cost'], info['solved'], info['heuristic_solution'])

```

## Environment Details:

1. **Shortest Path**: The goal is to find the shortest path from the source node to the target node. At each step, an edge is added to the path. The episode is over when we reach the target node.
2. **Steiner Tree**: The goal is to find the tree with the minimum weight that connects a source node to a number of destination nodes.
battlepy 1.0.1b0
Battle log generator
Requires Python: >=3.7

# Battlepy
Battlepy is a battle log generator.  Battlepy will create a player stats and enemy stats (PVP) and register the 
stats in a csv. We can train some IA algorithms and predict if the generated player can battle (without die) or avoid
the enemy. The player and enemies stats are created using same "mechanics" of the rpg games. 

This is for my initial researches in Data Science. This is in alpha stage and for academic learning only.

## Version 1.0.1-beta
- This initial release just works as intended. Run a predetermined quantity of battles and log in a csv.

## TODO for version 1.1
- Docs.
- Add freeze option to generate same stats for enemy/player.
- Able to tun from command line.
- Add a more complex mechanism, like block, critical, speed and etc.
- Add more weapons and armor items.