semvec/pypi-packages huggingface dataset:
svg-turtle 1.1.0
Use the Python turtle to write SVG files. With optional IPython integration.

# SaVaGe Turtle [![Build Badge]][build] [![Coverage Badge]][codecov] [![Downloads Badge]][downloads] [![PyPI Badge]][pypi] [![Supported Python versions]][pypi]
[Supported Python versions]: https://img.shields.io/pypi/pyversions/svg-turtle.svg

### Use the Python turtle to write SVG files

[Build Badge]: https://github.com/donkirkby/svg-turtle/actions/workflows/build.yml/badge.svg?branch=main
[build]: https://github.com/donkirkby/svg-turtle/actions
[Coverage Badge]: https://codecov.io/github/donkirkby/svg-turtle/coverage.svg?branch=main
[codecov]: https://codecov.io/github/donkirkby/svg-turtle?branch=main
[PyPI Badge]: https://badge.fury.io/py/svg-turtle.svg
[pypi]: https://pypi.org/project/svg-turtle/
[Downloads Badge]: https://static.pepy.tech/badge/svg-turtle/month
[downloads]: https://pepy.tech/project/svg-turtle

If you're using the Python turtle module to teach students, or you just like
using the turtle module yourself, this library can save the images from a turtle
script as SVG files. Experiment with your turtle code using the regular turtle
or the [Live Coding in Python] plugin for PyCharm, then pass an `SvgTurtle` to
the same code, and save it as an SVG file. If you want to produce other file
formats, use [svglib] to convert the SVG to PDF, PNG, GIF, JPG, TIFF, and PCT,
among others.

[Live Coding in Python]: https://donkirkby.github.io/live-py-plugin/
[svglib]: https://pypi.org/project/svglib/#examples

## Installing
Install it with `pip install svg_turtle`. If you haven't installed Python
packages before, read Brett Cannon's [quick-and-dirty guide].

[quick-and-dirty guide]: https://snarky.ca/a-quick-and-dirty-guide-on-how-to-install-packages-for-python/

## Drawing
Once it's installed, create an `SvgTurtle`, telling it how big to make the SVG
file. Then give it some turtle commands, and save the file.

    from svg_turtle import SvgTurtle
    
    t = SvgTurtle(500, 500)
    t.forward(200)
    t.dot(10)
    t.save_as('example.svg')

## IPythonTurtle
To use SvgTurtle with IPython integration, create an instance of the
`IPythonTurtle` class. It exposes the same interface as `SvgTurtle`. It implements
both display on implicit return, and explicit display via the `show()` method.

    from svg_turtle import IPythonTurtle
    
    t = IPythonTurtle(500, 500)
    t.forward(200)
    t.show()                    # explicit display
    t.dot(10)
    t                           # display via implicit return

## More Information
If you'd like to help out with the project, see the `CONTRIBUTING.md` file in
the source code.
pyasic-rs 0.1.5
Python bindings for asic-rs
Requires Python: <4.0,>=3.11
Keywords: python, asic, bitcoin, whatsminer, antminer, braiins-os, vnish, luxos, bitaxe

# pyasic-rs ![License: Apache-2.0](https://img.shields.io/badge/license-Apache--2.0-blue) [![pyasic-rs on PyPI](https://img.shields.io/pypi/v/pyasic-rs)](https://pypi.org/project/pyasic-rs)

pyasic-rs is the official python binding library for [asic-rs](https://github.com/256-Foundation/asic-rs).

## Getting Started
The first step to controlling a miner with pyasic-rs is to get the object that represents it, with methods used for data gathering and control.

#### Getting a miner

If you know the IP address of your miner, it is fairly easy to discover it.  Use the `MinerFactory` to select the correct type.

```python
from pyasic_rs import MinerFactory
import asyncio

async def main():
    factory = MinerFactory()
    ip = "192.168.1.10"
    miner = await factory.get_miner(ip)
    # now we can do data gathering or control

if __name__ == "__main__":
    asyncio.run(main())
```

#### Miner discovery

If you don’t know the specific IP of your miner, pyasic-rs can discover it on your network.

```python
from pyasic_rs import MinerFactory
import asyncio

async def main():
    subnet = "192.168.1.0/24"
    factory = MinerFactory.from_subnet(subnet)
    miners = await factory.scan()

if __name__ == "__main__":
    asyncio.run(main())
```


There are other ways to define a discovery range to be scanned, such as:

* Octets

```python
    factory = MinerFactory.from_octets("192", "168", "1", "1-255")
```

* Range string

```python
    factory = MinerFactory.from_subnet("192.168.1.1-255")
```

#### Data gathering

Getting data is very simple with pyasic-rs, everything you need can be gathered with a single call.
Extending the "Getting a miner" example:

```python
from pyasic_rs import MinerFactory
import asyncio

async def main():
    factory = MinerFactory()
    ip = "192.168.1.10"
    miner = await factory.get_miner(ip)
    data = await miner.get_data()

if __name__ == "__main__":
    asyncio.run(main())
```

If you only want specific data, that can be done with individual function calls:

```python
    mac = await miner.get_mac();
```

Most data points from `MinerData` have a corresponding `get_...` function.

#### Miner control

Controlling a miner is very similar to getting data in pyasic-rs.
Again extending the “Getting a miner” example:

```python
from pyasic_rs import MinerFactory
import asyncio

async def main():
    factory = MinerFactory()
    ip = "192.168.1.10"
    miner = await factory.get_miner(ip)
    result = await miner.restart()
    print(result)

if __name__ == "__main__":
    asyncio.run(main())
```
aieng-interp-utils 1.0.0
Helper modules for AI Engineering Interpretability Bootcamp implementations
Requires Python: >=3.10

# AI Engineering Interpretability Utils

Helper modules for AI Engineering Interpretability Bootcamp implementations.

This package provides reusable utilities for:
- Loading and preprocessing common datasets (Adult, Diabetes, Bank Marketing, Gas Turbine)
- Model training and evaluation helpers
- Visualization utilities for interpretability

## Installation

```bash
pip install aieng-interp-utils
```

## Usage

```python
from aieng.interp.data import load_adult_dataset, preprocess_adult_data
from aieng.interp.models import train_pytorch_model, get_device
from aieng.interp.visualization import plot_confusion_matrix, plot_roc_curve

# Load and preprocess data
df = load_adult_dataset("path/to/data")
X_train, X_test, y_train, y_test = preprocess_adult_data(df)

# Train model
device = get_device()
model = train_pytorch_model(model, X_train, y_train, device=device)

# Visualize results
plot_roc_curve(y_test, y_pred_proba)
plot_confusion_matrix(y_test, y_pred)
```

## License

MIT