semvec/pypi-packages huggingface dataset:
botionplotlib 0.1.0
A beautiful and functional redesign of matplotlib defaults
Requires Python: >=3.6


# botionplotlib
### Perfect Python Plotting
---
Simple install, no dependencies, just python. 

```pip install botionplotlib```

Just do `import botionplotlib` at the top of your script and it will apply the style to all your plots.

Examples: 
![botionplotlib example](./botionplotlib_output/3d_surface_plot.png)
![botionplotlib example](./botionplotlib_output/animation.gif)
![botionplotlib example](./botionplotlib_output/bar_plot.png)
![botionplotlib example](./botionplotlib_output/line_plot.png)
![botionplotlib example](./botionplotlib_output/scatter_plot.png)
![botionplotlib example](./botionplotlib_output/pie_chart.png)


### How I Built it 
```
python -m build
```
```
python -m twine upload dist/*
```
netenum 0.1.1
Efficient IP address enumerator that interpolates across IPv4 and IPv6 CIDR ranges
Requires Python: >=3.8

# Netenum

Efficient IP address enumerator that interpolates across IPv4 and IPv6 CIDR ranges without expanding full ranges in memory.

## Features

- Supports both IPv4 and IPv6 CIDR ranges
- Memory efficient - doesn't expand full ranges
- Intelligent partitioning based on network size
- Stripes across multiple networks for balanced enumeration
- Supports both synchronous and asynchronous iteration
- Command-line interface with stdin input

## Installation

```bash
pip install netenum
```

## Usage

### Command Line

Enumerate addresses in sequence:
```bash
echo "192.168.1.0/24
10.0.0.0/8" | python -m netenum
```

Enumerate addresses in random order:
```bash
echo "192.168.1.0/24
10.0.0.0/8" | python -m netenum -r
```

You can also use a file:
```bash
cat cidrs.txt | python -m netenum
```

### Python API

#### Synchronous Usage

```python
from netenum import netenum

cidrs = [
    "192.168.0.0/16",          # IPv4
    "2001:db8::/32",           # IPv6
    "224.0.0.0/4",             # IPv4
]

for addr in netenum(cidrs):
    print(addr)
```

#### Asynchronous Usage

```python
import asyncio
from netenum import aionetenum

cidrs = [
    "192.168.0.0/16",          # IPv4
    "2001:db8::/32",           # IPv6
    "224.0.0.0/4",             # IPv4
]

async def main():
    async for addr in await aionetenum(cidrs):
        print(addr)

asyncio.run(main())
```

## Development

Install development dependencies:

```bash
pip install -e ".[dev]"
```

Run tests:
```bash
pytest
```

Format code:
```bash
black .
isort .
```

Type check:
```bash
mypy .
```
extraxt 0.0.18
Easily extract data from PDFs.
Requires Python: >=3.11

# Extraxt
Extraxt is a Python-based MuPDF library that enables parsing and extracting data from Healthlink PDF documents.

### Core Functionality

- **Nested JSON Output**: Constructs nested JSON objects reflecting the document's content.
- **Subtitle and Field Matching**: Define subtitles and corresponding data fields in snake case (e.g. `first_name`, `address_line_one`, `income_(secondary)`).
- **Sensitive Data Configuration**: Enables sensitive data controls and configuration via the API (Coming soon).

Extraxt streamlines the extraction process, converting PDF content into structured JSON for easy data manipulation and integration.


## Installation
#### Install Extraxt
```
pip install extraxt
```

#### Upgrade to new version of Extraxt
```
pip install --upgrade extraxt
```

#### Using Conda with Extraxt
```
conda create --name [YOUR_ENV] python=3.11 -y
conda activate [YOUR_ENV]
pip install extraxt
```

## Usage
Extraxt is able to consume either an asynchronous byte stream or a buffer directly from disk.

_Before you begin_:
- Matching something like `Phone (Secondary) -> phone_(secondary)` will require the usage of parenthesis as of `0.0.17`. _This will soon be opt in, where by default the parenthesis will be redacted_.
- As of `0.0.17`, sensitive data _is not_ configurable via the API, and instead `"Date of birth"` is parsed as `"age"` only.


### Read file from disk
Reading from a Buffer stream can be done using `with open` as is standard in Python. From there you can invoke `.read()` on the binary and pass your `fields` specification. `fields` accepts an object of user-input `key`'s (`subtitles`), where the `value` is a series of matches (`snaked_cased`) to that of the exact PDF text content within your document.

```python
from extraxt import Extraxt

from .config import FIELDS

extraxt = Extraxt()


def main():
    with open("file.pdf", "rb") as buffer:
        stream = buffer.read()
        output = extraxt.read(stream, FIELDS)
        print(output)


if __name__ == "__main__":
    main()
```

### Read file in asynchronous API
#### FastAPI

For cases using FastAPI, Extraxt is a synchronous package and _will block_ the main thread.
To perform non-blocking/asynchronous extraction, you will need to use `asyncio` and Futures.

```python
import traceback
import json

from fastapi import File, HTTPException, JSONResponse
from extraxt import Extraxt

from .util import event_loop
from .config import FIELDS

extraxt = Extraxt()


async def process_file(file: File):
    try:
        content = file.read()
        if not content:
            raise HTTPException(500, "Failed to read file.")
        content = await event_loop(extraxt.read, content, FIELDS)

    except Exception as e:
        tb = traceback.format_exc()
        raise HTTPException(500, f"Failed to triage file {tb}")

    return JSONResponse({
        "content": json.loads(content),
    })
```