semvec/pypi-packages huggingface dataset:
charsplit-fst 0.1.3
German compound word splitter using Rust + FST
Requires Python: >=3.12

# charsplit-fst

A memory-efficient Rust port of the CharSplit algorithm for German compound splitting, using Finite State Transducers (FST).

## Overview

Charsplit-fst implements the CharSplit algorithm for splitting German compound words into their component parts. It achieves 89% memory reduction compared to the original Python implementation by using Finite State Transducer (FST) data structures.

Based on CharSplit by Don Tuggener: https://github.com/dtuggener/CharSplit

## Features

- 51% smaller data files: 39 MB JSON → 18.2 MB FST
- 89% lower memory usage: 19.6 MB vs 180 MB runtime
- UTF-8 safe: Proper character-based indexing for German Unicode characters
- Python bindings via PyO3
- [WebAssembly demo](https://steadfastgaze.github.io/charsplit-fst/) for browser-based usage
- CLI tool for batch processing

## Installation

### Python

Available on [PyPI](https://pypi.org/project/charsplit-fst/).

```bash
pip install charsplit-fst
```

### Rust

```bash
cargo add charsplit-fst
```

## Quick Start

### Python

```python
from charsplit_fst import Splitter

splitter = Splitter()
results = splitter.split_compound("Autobahnraststätte")
# Returns: [(0.795, 'Autobahn', 'Raststätte'), ...]
```

### Rust

```rust
use charsplit_fst::Splitter;

let splitter = Splitter::new()?;
let results = splitter.split_compound("Autobahnraststätte");
```

### CLI

```bash
cargo run --bin charsplit-fst -- Autobahnraststätte
```

## Algorithm

The algorithm splits German compounds using ngram probability scoring:

**Score formula**: `start_prob - in_prob + pre_prob`

Where:
- `start_prob`: Maximum prefix probability of second part
- `in_prob`: Minimum infix probability crossing split boundary
- `pre_prob`: Maximum suffix probability of first part

## Performance

- Memory: 19.6 MB RSS (vs 180 MB for Python)
- Data size: 18.2 MB on disk (vs 39 MB JSON)

## Web Demo

A browser-based demo using WebAssembly is available in `web-demo/`.

```bash
# Build the WASM version
./build-wasm.sh

# Serve from project root
python -m http.server 8000
# Open http://localhost:8000/web-demo/
```

The demo runs entirely in the browser using WebAssembly. No server-side processing is required.
**Browser support:** The demo will try to use Brotli compression via DecompressionStream API where supported, falling back to uncompressed data for browsers that don't support it. Works in all modern browsers.

## Development

```bash
# Build
cargo build --release

# Run tests
cargo test

# Build Python bindings
maturin develop

# Build WASM
./build-wasm.sh
```

## Acknowledgments

This project is a Rust port of CharSplit by Don Tuggener.

- Algorithm: Based on Tuggener (2016), *Incremental Coreference Resolution for German*, University of Zurich.
- Original Implementation: dtuggener/CharSplit (https://github.com/dtuggener/CharSplit) (MIT Licensed).
- Data: The n-gram probabilities are derived from the model provided by the original author.

## License

MIT OR Apache-2.0

See LICENSE-MIT and LICENSE-APACHE-2.0 for details.
llama-index-core 0.14.15
Interface between LLMs and your data
Requires Python: <4.0,>=3.9
Keywords: LLM, NLP, RAG, data, devtools, index, retrieval

# LlamaIndex Core

The core python package to the LlamaIndex library. Core classes and abstractions
represent the foundational building blocks for LLM applications, most notably,
RAG. Such building blocks include abstractions for LLMs, Vector Stores, Embeddings,
Storage, Callables and several others.

We've designed the core library so that it can be easily extended through subclasses.
Building LLM applications with LlamaIndex thus involves building with LlamaIndex
core as well as with the LlamaIndex [integrations](https://github.com/run-llama/llama_index/tree/main/llama-index-integrations) needed for your application.
goodseed 0.2.6
ML experiment tracker
Requires Python: >=3.9
Keywords: experiment-tracking, machine-learning, mlops

# GoodSeed

ML experiment tracker. Logs metrics and configs to local SQLite files, serves them via a built-in HTTP server, and visualizes them in the browser.

Full documentation at [goodseed.ai/docs](https://goodseed.ai/docs/).

## Install

```bash
pip install goodseed
```

Python 3.9+ required. No runtime dependencies.

For development:
```bash
pip install -e ".[dev]"
```

## Quick Start

Log metrics and configs from a training script:

```python
import goodseed

run = goodseed.Run(experiment_name="my-experiment")
run.log_configs({"learning_rate": 0.001, "batch_size": 32})

for step in range(100):
    loss = train_step()
    run.log_metrics({"loss": loss}, step=step)

run.close()
```

Your data is saved to a local SQLite file. You can also use `with goodseed.Run(...) as run:` to close the run automatically.

Then view your runs:

```bash
goodseed serve
```

Open the printed link in your browser to see your runs, metrics, and configs.

## Coming from Neptune?

You can export your data from [neptune.ai](https://neptune.ai) and import it into GoodSeed using [neptune-exporter](https://github.com/neptune-ai/neptune-exporter). See the [migration guide](https://docs.neptune.ai/transition_hub/migration/to_goodseed) for details.

## Configuration

| Variable | Description |
|----------|-------------|
| `GOODSEED_HOME` | Data directory (default: `~/.goodseed`) |
| `GOODSEED_PROJECT` | Default project name (default: `default`) |

## CLI

```bash
goodseed                   # Start the server (default command)
goodseed serve [dir]       # Start the server, optionally from a specific directory
goodseed serve --port 9000 # Use a custom port
goodseed list              # List projects
goodseed list -p default   # List runs in a project
```

## Tests

```bash
pip install -e ".[dev]"
pytest tests/ -v
```

See [DOCS.md](DOCS.md) for architecture details and API reference.
speedtools 0.32.0
NFS4 HS (PC) resource utilities

# About

This project provides data extraction utilities for the following Need for Speed 4 HS asset files:
- tracks
- cars

Additionally, Blender addon is provided to directly import track and car data.

# Recommended setup

1. Download the latest ZIP file from [Releases][5].
2. Open Blender.
3. Go to `Edit -> Preferences -> Get Extensions`.
4. Click `v` in the top right corner of the window.
5. Click `Install from Disk...`.
6. Select the downloaded ZIP file.
7. Activate the addon in the `Add-ons` panel.

# Old setup instructions

> **Warning**: Use instructions from this section only if you have problems with the recommended setup.

1. Create new empty Blender project
2. Open the __Scripting__ tab
3. Copy-paste the following two commands into the Blender console:
   ```
   import sys, subprocess
   subprocess.call([sys.executable, "-m", "pip", "install", "speedtools"])
   ```
   This command will install the [`speedtools`][1] package to your Blender Python installation.

   > **Note**: Python installation that comes with Blender is completely separate from the global Python installation on your system. For this reason, it is necessary to use the Blender scripting console to install the package correctly.
4. Copy and paste the content of [this][2] file to the Blender scripting window.
5. Click the __▶__ button.
6. You should see `Track resources` and `Car resources` under `File > Import`.

# Setup (command line version)

Install the package from PyPI:
```
pip install speedtools
```

Currently, the command line version does not provide any useful functionality.

# Development dependencies

This setup is needed only if you plan to modify the add-on.

To develop the project the following dependencies must be installed on your system:
* [Kaitai Struct compiler][3]

Make sure the binary directories are in your `PATH`.

# Re-make project

This tool is a part of the re-make project. The project source code is available [here][4].

[1]: https://pypi.org/project/speedtools/
[2]: https://github.com/e-rk/speedtools/blob/master/speedtools/blender/io_nfs4_import.py
[3]: https://kaitai.io/
[4]: https://github.com/e-rk/velocity
[5]: https://github.com/e-rk/speedtools/releases