semvec/pypi-packages huggingface dataset:
pcbenv 2026.1.0
PCB routing reinforcement learning environment
Requires Python: >=3.7
Keywords: gym, pcb

PCBEnv2: Printed Circuit Board Machine Learning Environment
===========================================================

Usage
-----
See the [API documentation](/doc/API.md), as well as [pcbenv/playground.py](/pcbenv/playground.py) and [pcbenv/tests/](/pcbenv/tests/) for examples.

Example Boards
--------------
Run *pcbenv/data/boards/download.py* to auto-fetch some boards for testing.

UI Controls
-----------
- Hold right mouse button to scroll
- Left click on pins to select a connection
- Left click on a pin of the selected connection to reverse the order
- Hold Ctrl to rectangle-select (for Autoroute and Unroute Selection)
- Hold Alt to add to rectangle selection
- Click Shift to activate manual routing tool


Installation (Linux)
--------------------
0. Check dependencies section.
1. git clone ...
2. cd PCBEnv
3. pip install .

Non-installation (Linux)
-----------------------
2. cd PCBEnv/pcbenv/cxx
3. mkdir build
4. cd build
5. cmake ../ -DENABLE_UI=[1|0]
6. make -j$(nproc) install
8. run your python scripts from the pcbenv directory with PYTHONPATH=$PYTHONPATH:/path/to/PCBEnv


Dependencies
------------
Most of them (with the exception of CGAL) are hopefully already installed [on a development machine] or are fetched automatically by cmake.
Only Python, Qt (optional), and SWIG are not fetched automatically.

### Necessary:
* Python with C headers
* [CGAL](https://www.cgal.org/) (Computational Geometry Algorithms C++ header library)
* [rapidjson](https://rapidjson.org/) (C++ header library)
* [swig](https://www.swig.org/) (C++/Python interface generator)

Required by CGAL:
* [boost](https://www.boost.org/) (Boost C++ header libraries >= 1.74)
Can be used by CGAL but are disabled by default:
* gmp (The GNU MP Bignum Library)
* mpfr (GNU multiple-precision floating-point computations)

### For the user interface (if enabled):
* [Qt6](https://www.qt.io/development/qt-framework) with C++ headers
* OpenGL headers

*NOTE*: CGAL and Qt are free for academic and open source users, so if you read anything about getting a license: no, click elsewhere.

Install with, for example: `pacman -S cgal swig rapidjson qt6-base qt6-tools`

### Fallback on Linux
If you don't have root access and something has failed to install so far, please consider building manually.

For example, do `./configure --prefix=/your/home/...` and edit CMakeLists.txt to look there by uncommenting the obvious bits at the top.
There is a python script to do this in the Dependencies folder but you really shouldn't need to.


Directory structure
-------------------
- `cxx/`   C++ code (see [code documentation](/doc/Code.md) for an overview).
- `data/`  Example boards, [settings file](/pcbenv/data/settings.json), JSON schemas, UI resources.
- `util/`  Python class for the PCB JSON format and JSON to SVG converter.
modifiers 0.1.0
Add your description here
Requires Python: >=3.11

# modifiers

Initial PyPI package scaffold for `modifiers`, using `uv` for build and publish.

## Local workflow

```bash
uv build
uv publish
```

`uv publish` reads `UV_PUBLISH_TOKEN` automatically.

If your token is stored as `PYPI_TOKEN`, run:

```bash
export UV_PUBLISH_TOKEN="$PYPI_TOKEN"
uv publish
```

## TestPyPI

```bash
uv publish --publish-url https://test.pypi.org/legacy/
```
llama-index-node-parser-chonkie 0.1.1
llama-index Chonkie integration
Requires Python: >=3.10
Keywords: chonkie, chunking, llama-index, node-parser

# LlamaIndex Node Parser Chonkie Integration

This package provides an integration between [LlamaIndex](https://www.llamaindex.ai/) and [Chonkie](https://github.com/chonkie-inc/chonkie), a powerful and flexible chunking library.

## Installation

```bash
pip install llama-index-node_parser-chonkie
```

## Quick Start

```python
from llama_index.core import Document
from llama_index.node_parser.chonkie import Chunker

# Create a chunker (defaults to 'recursive')
chunker = Chunker(chunk_size=512)

# Create a document
doc = Document(text="Your long text here...")

# Get nodes
nodes = chunker.get_nodes_from_documents([doc])
```

## Supported Chunkers

The `Chunker` acts as a wrapper for various Chonkie chunking strategies. You can specify the strategy using the `chunker` parameter:

| `chunker`   | Description                                                           |
| ----------- | --------------------------------------------------------------------- |
| `recursive` | (Default) Recursively splits text based on a hierarchy of separators. |
| `sentence`  | Splits text into sentences.                                           |
| `token`     | Splits text into chunks based on token counts.                        |
| `word`      | Splits text based on word counts.                                     |
| `semantic`  | Splits text based on semantic similarity.                             |
| `late`      | Late chunking strategy.                                               |
| `neural`    | Neural-based chunking.                                                |
| `code`      | Optimized for source code.                                            |
| `fast`      | High-performance basic chunking.                                      |

run the following code to see the full list of valid aliases:

```python
from llama_index.node_parser import Chunker

print(Chunker.valid_chunkers)
```

## Advanced Configuration

You can pass any keyword arguments accepted by the underlying Chonkie chunker directly to `Chunker`:

```python
chunker = Chunker(
    chunker="semantic",
    chunk_size=512,
    embedding_model="all-MiniLM-L6-v2",
    threshold=0.5,
)
```

## Integration with Node Parsing

You can use `Chunker` directly to parse documents into nodes:

```python
from llama_index.core import Document
from llama_index.node_parser.chonkie import Chunker

chunker = Chunker(chunk_size=512)
doc = Document(text="Your long text here...")
nodes = chunker.get_nodes_from_documents([doc])
```

or you can also use it as a component within the Ingestion pipeline:

```python
from llama_index.core import Document
from llama_index.core.ingestion import IngestionPipeline
from llama_index.node_parser.chonkie import Chunker

pipeline = IngestionPipeline(
    transformations=[
        Chunker("recursive", chunk_size=512),
        # ... other transformations
    ]
)

nodes = pipeline.run(documents=[Document.example()])
```
scenariocompass 0.1.0
Utility functions for validation and analysis of Integrated-Assessement scenarios as used by the Scenario Compass Initiative
Requires Python: >=3.10

# Validation and analysis for the Scenario Compass Initiative

[![license](https://img.shields.io/badge/License-MIT-blue)](https://github.com/IAMconsortium/scenariocompass/blob/main/LICENSE)
[![Code style: ruff](https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/charliermarsh/ruff/main/assets/badge/v2.json)](https://github.com/astral-sh/ruff)
[![pytest](https://img.shields.io/github/actions/workflow/status/IAMconsortium/scenariocompass/pytest.yml?logo=GitHub&label=pytest)](https://github.com/IAMconsortium/scenariocompass/actions/workflows/pytest.yml)

Copyright 2026 IIASA Scenario Services team and the Scenario Compass consortium

This repository is licensed under the [MIT License](LICENSE).

## Overview

This package provides utility functions for validation and analysis of Integrated-Assessement scenarios
as used by the Scenario Compass Initiative.

Visit https://scenariocompass.org for more information.

## Funding Acknowledgement

The Scenario Compass Initiative is grateful for the generous support from the Bezos Earth Fund.