semvec/pypi-packages huggingface dataset:
ptoe 0.4.2
Render matplotlib charts with eCharts
Requires Python: >=3.8

# ptoe (matPlotlib To ECharts)

**ptoe** is an experimental library that converts charts created with ``matplotlib``
👉 into **interactive HTML outputs powered by ECharts.**

 Core Philosophy  
> **“Keep matplotlib syntax as-is, only change the output to ECharts.”**

## Supported Chart Types (v0.4.2)

### Bar Chart
- Single bar
- Multiple series bar
- Stacked bar (`bottom=`)

```python
plt.bar(x, y1)
plt.bar(x, y2, bottom=y1)
ptoe.show()
```

*Automatically detects legend and stack
*Supports category x-axis

### Line Chart

- Standard line
- step line (plt.step, steps-pre/mid/post)

```python
plt.plot(x, y)
plt.step(x, y, where="post")
ptoe.show()
```

*Automatically detects numeric / category x-axis
*Converts step lines to ECharts step option

### Scatter Plot

```python
plt.scatter(x, y)
ptoe.show()
```

*matplotlib scatter → ECharts scatter

### Area Chart

```python
plt.fill_between

plt.fill_between(x, y)
ptoe.show()
```

*Detected via PolyCollection
*Converted to ECharts line + areaStyle

### Histogram

Directly computed using numpy.histogram()

```python
ptoe.show(
    data=data,
    chart_type="hist",
    bins=30,
    density=False,
    cumulative=False,
    hist_range=[-3, 3],
    color="green",
    alpha=0.4,
    edgecolor="black",
)
```

### Boxplot

Directly computed using original data

```python
ptoe.show(
    data=data,
    chart_type="boxplot",
)
```
*Does NOT reuse matplotlib results
*Quartiles and whiskers calculated manually
*Can be used without matplotlib
### Heatmap

```python
ptoe.show(
    data=data,
    chart_type="heatmap",
)
```
*Uses 2D array directly
*Automatically calculates min / max
*Automatically generates `visualMap`
*Can be used without matplotlib


## Common Style Options
- color
- alpha
- edgecolor
- linewidth


## Execution Modes

### Convert matplotlib result
```python
plt.plot(x, y)
ptoe.show()
```

### Requires original data
```python
ptoe.show(
    data=data,
    chart_type="hist",
)
```
*Recommended for hist / boxplot / heatmap


## Running Methods

### Jupyter / Colab
```python
ptoe.show(inline=True)
```

### Local (HTML)
```python
ptoe.show()
```

## Design Overview

- Analyze matplotlib objects (wrap mode)
- Automatic `chart_type` detection
- Statistical charts computed from raw data
- Generate ECharts options
- Render HTML

## Version History
v0.4.2

- Transitioned to chart_type-based structure
- Introduced raw data computation for hist, boxplot, heatmap
- Partial style option support

## One-Line Summary

ptoe is a tool for matplotlib users that delivers **Same syntax, upgraded output.**
plan-view 1.5.0
Pretty print plan.json for task tracking
Requires Python: >=3.14
Keywords: cli, plan, task-tracking, ai-agents

# pv

A command-line tool for viewing and editing `plan.json` task tracking files.

## Installation

```bash
uv tool install plan-view
```

## Quick Start

```bash
# Create a new plan
pv init "My Project"

# Add phases and tasks
pv add-phase "Setup" --desc "Initial configuration"
pv add-task 0 "Initialize repository" --agent github-git-expert

# Track progress
pv start 0.1.1
pv done 0.1.1

# View status
pv current
```

## Commands

### View

| Command | Description |
|---------|-------------|
| `pv` | Full plan overview |
| `pv current` | Current phase and next task |
| `pv next` | Next actionable task |
| `pv phase` | Current phase details |
| `pv get <id>` | Show task or phase by ID |
| `pv last` | Recently completed tasks |
| `pv future` | Upcoming tasks (actionable first) |
| `pv summary` | Progress summary |
| `pv bugs` | Show bugs phase |
| `pv deferred` | Show deferred phase |
| `pv ideas` | Show ideas phase |
| `pv validate` | Validate against schema |

### Edit

| Command | Description |
|---------|-------------|
| `pv init <name>` | Create new plan.json |
| `pv add-phase <name>` | Add a phase |
| `pv add-task <phase> <title>` | Add a task |
| `pv done <id>` | Mark completed |
| `pv start <id>` | Mark in progress |
| `pv block <id>` | Mark blocked |
| `pv skip <id>` | Mark skipped |
| `pv defer <id> [-r reason]` | Move to deferred (with optional reason) |
| `pv bug <id>` | Move to bugs |
| `pv idea <id>` | Move to ideas |
| `pv set <id> <field> <value>` | Set task field |
| `pv rm task <id>` | Remove task |
| `pv rm phase <id>` | Remove phase |
| `pv compact` | Archive completed tasks to backup |

### Options

| Option | Description |
|--------|-------------|
| `-f, --file` | Specify plan file path |
| `--json` | JSON output (view commands) |
| `-q, --quiet` | Suppress output (edit commands) |
| `-d, --dry-run` | Preview changes without saving |

## Example Output

```
$ pv -f examples/simple.json current

API Backend v1.0.0
Progress: 40% (2/5 tasks)

Phase 0: Setup (100%)
Phase 1: Core Features (0%)
   Create user authentication
   Build REST API endpoints

Next: [1.1.1] Create user authentication
```

## JSON Output

All view commands support `--json` for programmatic access:

```bash
$ pv next --json
{
  "id": "1.1.1",
  "title": "Create user authentication",
  "status": "in_progress",
  "phase_id": "1",
  "phase_name": "Core Features",
  "agent_type": "python-backend-engineer",
  "depends_on": ["0.1.2"]
}
```

## Features

- Automatic progress calculation
- Dependency-aware task ordering
- Partial task ID matching (`pv done 1` matches `1.1.1` if unique)
- Schema validation
- NO_COLOR/FORCE_COLOR environment variable support
- Dry-run mode for previewing changes

## Documentation

See the [full documentation](https://jacobcoffee.github.io/pv/) for detailed usage.

## License

MIT
naluconfigs 18.0.0
Home for board configs
Requires Python: >=3.7


# NaluConfigs

This repository houses all board configuration files (both register files and clock files).


## Installation

Generally you don't have to install this repository unless you plan to change anything.

If you do however want to install this package, the best way is to use our PyPI package:

```sh
pip install naluconfigs
```

### Developer Installation

To install this reposity for development the best way is to clone and install as an editable package.

First clone this repository to a suitable location:

```sh
git clone https://github.com/NaluScientific/naluconfigs.git
```

Then install the package into your Anaconda environment:

```sh
cd naluconfigs
pip install -e .
```

## Usage

In addition to the default board configuration files and clock files, the `naluconfigs` package
also contains functions to load or copy these files. Check out the package to see what you can do!

## Developers
Install this package as editable, and with development extras:
```
cd naluconfigs
pip install -e .[dev]
```

Make sure to read the `YAML HELP.md` file if you're new, or haven't kept up with NaluConfigs.

This project follows a X.Y.Z version scheme according to the following:

- Add/remove register files, increment X
- register adds / remove, increment Y
- register edits and/or value edits increment Z


### Pre-commit

This project uses pre-commit hooks to make sure the code is following the style guide.
To install the pre-commit hooks, run the following command:

```
    pre-commit install
```

The hooks will run automatically when you commit changes to the repository.

The code MUST run the pre-commit hooks before commiting. If the hooks fail, the commit will be rejected.

### Tests
The tests are located under the `naluconfigs/tests/` directory, and use [pytest](https://github.com/pytest-dev/pytest).
To run the tests, run `naluconfigs/run_tests.bat`. This will run the tests and also generate a coverage report to
`naluconfigs/coverage.xml`.

Make sure to keep the test coverage at 100%. This is doable, since NaluConfigs is a relatively simple package.
The [Coverage Gutters](https://marketplace.visualstudio.com/items?itemName=ryanluker.vscode-coverage-gutters)
extension is highly recommended to monitor test coverage.