semvec/pypi-packages huggingface dataset:
wordocx 1.0.5
A simple docx manipulation utility library
Requires Python: >=3.6

# wordocx

A simple DOCX manipulation utility library.

## Installation

```sh
pip install wordocx
```

## Usage

```python
from wordocx import getComments, convertDocxToJson, convertJsonToDocx

# Example usage to get comments
comments = getComments('example.docx')


# Read the Word file and generate JSON
convertDocxToJson('example.docx', outputFile)

# Read the JSON file and generate DOCX
convertJsonToDocx('example.json', outputFile)
```

**requirements.txt**
```makefile
python-docx>=0.8.10
docx2python>=1.27.0
jsonlib-python3>=1.6.1
```
OlPack 0.1.3
A collection of tools to simplify your Python experience!
Requires Python: >=3.6

# OlPack

A collection of tools to simplify your python experience!

## Requirements

- Python 3.6 or higher
- Tkinter (usually included with Python)

## Installation

To install this package, you can use pip:

```bash
pip install .
```
Or...
```
pip install OlPack
```

## License

This project is licensed under a Custom License. You are free to use, modify, and fork the code. Redistribution under the same name as the original software is not permitted. Any distribution or use must provide proper attribution to the original author. See the [LICENSE](LICENSE) file for details.
fred-mc 0.0.5
FRED Monte Carlo platform
Requires Python: <4.0,>=3.10

FRED-mc repository
==================

FRED (Fast paRticle thErapy Dose evaluator) is a fast Monte-Carlo platform for particle transport in heterogeneous media. The main motivation is to allow a rapid recalculation of dose deposition in the context of Particle Therapy. FRED can transport protons, light ions, neutrons and other particles through voxelized regions. A complete treatment plan can be recalculated importing patient data (e.g. CT scans) and delivery plans (namely fields and pencil beams).

FRED can run on CPU hardware exploiting multi-core parallelism as well as on single or multiple GPU cards using OpenCL.

Documentation and tutorial
----------------------------
The documentation of the functions implemented in FRED is available at [www.fred-mc.org](https://www.fred-mc.org).


Installation
----------------------------
The stable version of FRED-mc is available via pip.

For new installation:

  $ pip install fred-mc

To update existing installation:

$ pip install --upgrade fred-mc
hashtrack 0.0.1
A cli tool to track file changes via checksums
Requires Python: >=3.8

# hashtrack

A simple tool to track the hash of files in case you need to verify them later.

## Installation

```bash
git clone https://github.com/fkcptlst/hashtrack.git
cd hashtrack
pip install -e .
```

## Usage

```bash
hashtrack --help
```

## Example

```bash
hashtrack init  # Initialize the cache
hashtrack update  # Update the cache
# do some work or modify files
hashtrack check  # Check the checksum of the files in the cache
```

## Configuration

Under `.hashtrack` directory, there is a `config.yml` file that you can modify to suit your needs.

```yaml
extensions:  # ".ext"
  - ".ckpt"
  - ".pth"
  - ".pt"
  - ".h5"
  - ".onnx"
  - ".safetensors"
  - ".pkl"
  - ".npy"

search_dirs:  # list[str]
  - "."
```
aura-sr 0.0.4
GAN-based Super-Resolution for AI generated images, based on the GigaGAN architecture.

# AuraSR
![aurasr example](https://storage.googleapis.com/falserverless/gallery/aurasr-animated.webp)

GAN-based Super-Resolution for real-world images, a variation of the [GigaGAN](https://mingukkang.github.io/GigaGAN/) paper for image-conditioned upscaling. Torch implementation is based on the unofficial [lucidrains/gigagan-pytorch](https://github.com/lucidrains/gigagan-pytorch) repository.

## Usage

```bash
$ pip install aura-sr
```

```python
from aura_sr import AuraSR

aura_sr = AuraSR.from_pretrained()
```

```python
import requests
from io import BytesIO
from PIL import Image

def load_image_from_url(url):
    response = requests.get(url)
    image_data = BytesIO(response.content)
    return Image.open(image_data)

image = load_image_from_url("https://mingukkang.github.io/GigaGAN/static/images/iguana_output.jpg").resize((256, 256))
upscaled_image = aura_sr.upscale_4x(image)
```

### Reduce Seam Artifacts 

`upscale_4x` upscales the image in tiles that do not overlap. This can result in seams. Use `upscale_4x_overlapped` to reduce seams. This will double the time upscaling by taking an additional pass and averaging the results.
nook 0.1.1
A simple key-value pair management library with CLI
Requires Python: >=3.6

# Nook

**Nook** is a command-line interface (CLI) application that allows you to manage key-value pairs. It provides functionality to add, delete, and retrieve key-value pairs using simple commands. This project uses the Click library for the CLI interface and pickle for data persistence. It can also be used programmatically as a libray. 

## Features

- Add key-value pairs.
- Delete key-value pairs.
- Retrieve values by key.


## Usage

- Can be used as a quick database solution in development
- Can be used to store environment keys and possibly other config keys.
## Installation
### Using pip
```sh
  pip install nook
```
### From github
To get started with nook, clone this repository and install the required dependencies.

```sh
git clone https://github.com/jerrygeorge360/nook.git
cd nook
pip install -r requirements.txt
```

## Usage 
### through the terminal
### Adding a Key-Value Pair

To add a key-value pair, use the `add` command with the `--key` (or `-k`) and `--value` (or `-v`) options.

```sh
nook add --key yourkey --value yourvalue
```

### Deleting a Key-Value Pair

To delete a key-value pair, use the `delete` command with the `--delete` (or `-d`) option.

```sh
nook delete --delete yourkey
```

### Retrieving a Value

To retrieve a value by key, use the `get_value` command with the `--getvalue` (or `-g`) option.

```sh
nook getvalue --key yourkey
```

### Programmatic usage

``` sh
from nook import add,delete,getvalue
```
```
add.callback('key','value')
```

```
getvalue.callback('key')
```

```
getvalue.callback('key')
```

```
delete.callback('key')
```
## Commands

- `add`: Adds a key-value pair to the hashmap.
  - Options:
    - `-k, --key TEXT`: Key to add.
    - `-v, --value TEXT`: Value to add.

- `delete`: Deletes a key-value pair from the hashmap.
  - Options:
    - `-k, --key TEXT`: Key to delete.

- `getvalue`: Retrieves the value for a given key.
  - Options:
    - `-k, --key TEXT`: Key to get the value for.

## Project Structure

```
.
├── main.py
├── commands.py
├── utils.py
├── hashmap.pickle
├── requirements.txt
└── README.md
```

- `main.py`: The main entry point for the CLI application.
- `commands.py`: Contains the CLI commands for the application.
- `utils.py`: Contains utility functions and classes used by the application.
- `hashmap.pickle`: File used to persist the hashmap data.
- `requirements.txt`: File listing the dependencies required for the project.
- `README.md`: This file.

## Requirements

- Python 3.6 or higher
- Click library

## License

This project is licensed under the MIT License