semvec/pypi-packages huggingface dataset:
sklearn-ann 0.1.4
Various integrations for ANN (Approximate Nearest Neighbours) libraries into scikit-learn.
Requires Python: >=3.9

**sklearn-ann** eases integration of approximate nearest neighbours
libraries such as annoy, nmslib and faiss into your sklearn
pipelines. It consists of:

* ``Transformers`` conforming to the same interface as
  ``KNeighborsTransformer`` which can be used to transform feature matrices
  into sparse distance matrices for use by any estimator that can deal with
  sparse distance matrices. Many, but not all, of scikit-learn's clustering and
  manifold learning algorithms can work with this kind of input.
* RNN-DBSCAN: a variant of DBSCAN based on reverse nearest
  neighbours.

Installation
============

To install the latest release from PyPI, run:

.. code-block:: bash

    pip install sklearn-ann

To install the latest development version from GitHub, run:

.. code-block:: bash

    pip install git+https://github.com/scikit-learn-contrib/sklearn-ann.git#egg=sklearn-ann

Why? When do I want this?
=========================

The main scenarios in which this is needed is for performing
*clustering or manifold learning or high dimensional data*. The
reason is that currently the only neighbourhood algorithms which are
build into scikit-learn are essentially the standard tree approaches
to space partitioning: the ball tree and the K-D tree. These do not
perform competitively in high dimensional spaces.

Development
===========

This project is managed using Hatch_ and pre-commit_. To get started, run ``pre-commit
install`` and ``hatch env create``. Run all commands using ``hatch run python
<command>`` which will ensure the environment is kept up to date. pre-commit_ comes into
play on every `git commit` after installation.

Consult ``pyproject.toml`` for which dependency groups and extras exist,
and the Hatch help or user guide for more info on what they are.

.. _Hatch: https://hatch.pypa.io/
.. _pre-commit: https://pre-commit.com/
py4hw 2025.5
py4hw is a library to model, and simulate digital logic circuits. It promotes the use of structural and behavioural design styles to build hardware.

# py4hw

[![PyPI version](https://badge.fury.io/py/py4hw.svg)](https://badge.fury.io/py/py4hw)

py4hw is an HDL library based on python to create digital circuits (mainly) following a structural design methodology. 
It is highly influenced by some principles used in JHDL but using the power of Python.

When people see Python and HDL in the same sentence they automatically associate it with two ideas:

1. This is an attempt to generate Verilog from Python code with an HLS approach
2. This will generate terribly inefficient Verilog

The answer to both questions is **NO**.
py4hw is **NOT** [yet] intended to be a python HLS tool. It actually starts from a bottom-up approach modelling basic logic gates.
In fact, you can generate Verilog code at a very fine-grain.
 
## Features ##

- Cycle-based Simulation
- Clear separation of design styles 
   - Structural
   - Behavioural
      - Combinational
      - Sequential (RTL)
      - Algorithmic
- Schematic Rendering
- Interactive Simulation
- Verilog Generation (for Structural, Combinational and Sequential design styles)
- WaveDrom generation
- Library of predefined circuits
- Pypi based distribution
- Jupyter Notebook integration
- Integration with edalize
- Support for existing Hardware platforms (Terasic DE0, and DE1SoC so far)


[Follow the jump start tutorial !](tutorial/README.md)


## Contributing ##

Contributors are more than welcome :-)

I've identifyied a number of low-effort aspects that should be done

- change the use of nbwavedrom by wavedrom
- correct synchronization of wire names and waveforms in WaveformWindow and support for scrolling, zooming and paning.
- avoid complete redrawing in interactive workbench

..and other high effort tasks

- improve the place & route algorithm in the schematic viewer
- collapse interfaces in the schematic viewer
- support additional hardware platforms 
- transpile algorithmic into RTL

## Publications ##

Cite as
```
@conference{castells2023streamlining,
  author       = {David Castells-Rufas and Gemma Rotger and David Novo},
  title        = {Streamlining FPGA Circuit Design and Verification with Python and py4hw},
  booktitle    = {XI Southern Programmable Logic Conference},
  year         = 2023,
  month        = mar,
  address      = {San Luis, Argentina},
  doi          = {10.5281/zenodo.8325670}
}
```
jsontoggle 0.1.2
A CLI tool for toggling JSON nodes.
Requires Python: >=3.8

# JSON Toggle

A CLI tool for interactively toggling JSON nodes on and off within a JSON file, storing the original values for easy restoration.

## Features

- **Interactive TUI**: Navigate and select JSON nodes using a Text User Interface (TUI).
- **Toggle Nodes**: Easily remove a JSON node from the main file, storing its original value in a separate toggle file.
- **Revert Toggles**: Restore a previously toggled-out node by reinserting its original value from the toggle file.
- **Persistent Toggles**: Toggled nodes' states are maintained across sessions, allowing you to manage feature flags or configurations effectively.

## Installation

### Prerequisites

- Python 3.8 or higher
- `uv` (optional, for faster dependency management)

### Steps

1. **Clone the repository (if applicable):**
   ```bash
   git clone https://github.com/your-username/jsontoggle.git
   cd jsontoggle
   ```

2. **Create a virtual environment:**
   ```bash
   python -m venv .venv
   source .venv/bin/activate # On Windows: .venv\Scripts\activate
   ```

3. **Install dependencies:**
   Using `uv` (recommended):
   ```bash
   uv sync
   ```
   Or using `pip`:
   ```bash
   pip install -e .
   ```

## Usage

The `jsontoggle` tool provides a TUI for interacting with your JSON files.

### Launching the TUI

You can launch the TUI with an existing JSON file or create a demo file.

#### With an existing JSON file:

```bash
jsontoggle start <path_to_json_file>
```

Example:
```bash
jsontoggle start my_config.json
```

#### With a demo JSON file:

This will create a `demo.json` file in your current directory and launch the TUI with it.

```bash
jsontoggle start --demo
```

### Navigating the TUI

- Use **arrow keys** (Up/Down) to navigate through the JSON tree.
- Press **Space** or **Right Arrow** to expand/collapse nodes.

### Toggling Nodes

- Select a node you wish to toggle.
- Press `t` to **toggle** the selected node.
  - If the node is present, it will be removed from the JSON file, and its original value will be saved in the `toggles/` directory.
  - If the node was previously toggled out (and appears as "(Toggled out)"), pressing `t` will restore it to the JSON file using the saved value from `toggles/`.

### Quitting the TUI

- Press `q` to quit the application.

## Example Workflow

1. **Start with a demo file:**
   ```bash
   jsontoggle start --demo
   ```

2. **Navigate** to `featureFlags.darkMode`.
3. Press `t` to **toggle out** `darkMode`. You'll see it disappear from the main JSON structure, and a message indicating it's been toggled out.
4. The `toggles/` directory will now contain a file like `featureFlags_darkMode.json` with the original value (`false`).
5. **Quit** the application (`q`).
6. **Re-launch** with the `demo.json` file.
   ```bash
   jsontoggle start demo.json
   ```
   You'll notice `featureFlags.darkMode` is still toggled out.
7. **Navigate** to the `featureFlags.darkMode (Toggled out)` node.
8. Press `t` again to **revert** the toggle. The `darkMode` node will reappear in the JSON, and its toggle file will be removed.
9. **Quit** the application.
psi-toml 0.0.21
A very lite implementation of a toml parser, reader, and writer
Requires Python: <3.13,>=3.10

# psi_toml

A very lite implementation of a toml parser, reader, and writer

It is not a **1.0.0-compliant** [TOML](https://toml.io/) library, nor is it intended to be.

It can parse basic toml files to a dict, and write a dict to a toml file using the *load* and *dump* methods.

## Usage

```python
from psi_toml import toml as toml
    result = toml.load(f_toml)
```

```python
    toml.dump(data, f_toml)
```

```python
    toml.parse(strings)
```

where *f_toml* is the handle to the toml file, *data* is a python dict and *strings* is a list of strings representing key value pairs. E.g.

```python
    nl = '\n'
    strings = [
        'a = 1',
        'b = -1',
        'c = .5',
        'd = abc',
        'e = 3.14',
        'f = "1.414"',
        'g = true',
        'h = "false"',
        (f'i = [{nl}'
            f'"a",{nl}'
            f'"b",{nl}'
            f'"c",{nl}'
            f'"d",{nl}'
            f']'),
        (f'j = {{{nl}'
            f'"a": 1,{nl}'
            f'"b": 2,{nl}'
            f'"c": 3,{nl}'
            f'"d": 4,{nl}'
            f'}}')
    result = toml.parse(strings)

```

## Installation

If you are using [Poetry](https://poetry.eustace.io),
add `psi_toml` to your `pyproject.toml` file by using:

```bash
poetry add psi_toml
```

If not, you can use `pip`:

```bash
pip install psi_toml
```