semvec/pypi-packages huggingface dataset:
ttx-diff 0.2.1
A tool for comparing font compiler outputs (fontc vs fontmake)
Requires Python: >=3.10
Keywords: fonts, font-compilation, fontc, fontmake, testing

# ttx-diff

[![PyPI](https://img.shields.io/pypi/v/ttx-diff)](https://pypi.org/project/ttx-diff/)
[![Python Version](https://img.shields.io/pypi/pyversions/ttx-diff)](https://pypi.org/project/ttx-diff/)

A tool for comparing font compiler outputs between fontc (Rust) and fontmake (Python).

## Overview

`ttx-diff` is a helper utility that compares binary font outputs from two different font compilers:
- **fontc**: The Rust-based font compiler from Google Fonts
- **fontmake**: The Python-based font compiler

The tool converts each binary font to TTX (XML) format, normalizes expected differences, and provides a detailed comparison summary.

## Installation

### From PyPI

```bash
pip install ttx-diff
```

### From source

```bash
git clone https://github.com/googlefonts/fontc.git
cd fontc/ttx_diff
pip install -e .
```

## Requirements

- Python 3.10 or higher
- `fontc` and `otl-normalizer` binaries (see below)

All Python dependencies (fontmake, fonttools, etc.) are installed automatically.

### Getting fontc and otl-normalizer

The tool needs the `fontc` and `otl-normalizer` binaries. You can:

1. **Specify paths explicitly** (recommended for most users):
   ```bash
   ttx-diff --fontc_path /path/to/fontc --normalizer_path /path/to/otl-normalizer source.glyphs
   ```

2. **Add them to your PATH**: If `fontc` and `otl-normalizer` are in your PATH, they'll be found automatically

3. **Run from fontc repository**: If you run from the fontc repository root, the tool will automatically build the binaries for you

## Usage

**Note**: Unlike the original `ttx_diff.py` script, this standalone version can be run from any directory. You don't need to be in the fontc repository.

Rebuild with both fontmake and fontc and compare:

```bash
ttx-diff --fontc_path /path/to/fontc --normalizer_path /path/to/otl-normalizer path/to/source.glyphs
```

If the binaries are in your PATH:

```bash
ttx-diff path/to/source.glyphs
```

Compare two precompiled fonts directly (without building from source):

```bash
ttx-diff --fontc_font path/to/fontc.ttf --fontmake_font path/to/fontmake.ttf
```

This is useful for comparing font differences when you already have both builds.

Rebuild only fontc's font and reuse existing fontmake output:

```bash
ttx-diff --rebuild fontc path/to/source.glyphs
```

Output results in machine-readable JSON format, as used by the [`fontc_crater`](https://github.com/googlefonts/fontc/tree/main/fontc_crater) tool.

```bash
ttx-diff --json path/to/source.glyphs
```

Compare using gftools build pipeline:

```bash
ttx-diff --compare gftools --config config.yaml path/to/source.glyphs
```

## Development

Running tests

```bash
pip install -e .[test]
pytest
```

Running tests with coverage

```bash
pytest --cov=ttx_diff --cov-report=html
```

## Releasing

See <https://googlefonts.github.io/python#make-a-release>.
datacanva 1.0.2
Python module which connects to the DataCanva REST API
Requires Python: >=3.9

## Overview

`datacanva` is a Python package that provides a simple and efficient way to
interact with the DataCanva web app's REST API.
With this package, you can easily integrate DataCanva's functionalities
into your Python workflows for data visualization, analysis, and more.

## Installation

Install the package directly from PyPI:

```bash
pip install datacanva
```

## License

This project is licensed under the MIT License. See the [LICENSE](LICENSE) file for details.
laimassey 0.1.6
Pure-Python Lai–Massey block ciphers: IDEA-LM, FOX-LM, MISTY1-LM with ECB/CBC/CTR modes.
Requires Python: >=3.9

# Lai–Massey Cryptographic Library

This project implements several block ciphers based on the Lai–Massey scheme:

- IDEA-LM
- FOX-LM
- MISTY1 (full cipher)
- MISTY1-LM variant
- ECB / CBC / CTR modes

The implementation is pure Python and designed for learning, research, and security experimentation.

## Features

- Modular architecture
- Realistic key schedules
- Reversible encryption/decryption
- Fully separated FI/FO/FL for MISTY1
- Test suite included

## Quick Example

```python
from laimassey.idea_lm import IDEA_LM

cipher = IDEA_LM(key=b"1234567890ABCDEF")
ct = cipher.encrypt_block(b"ABCDEFGH")
pt = cipher.decrypt_block(ct)
print(pt)

#Crypto add fro easy using

from laimassey.Crypto import LM

cipher = LM.new(
    key=b"1234567890ABCDEF",
    algorithm="FOX",
    mode="CBC",
    iv=b"ABCDEFGH"
)

pt = b"ABCDEFGHABCDEFGH"
ct = cipher.encrypt(pt)
rt = cipher.decrypt(ct)

print(ct.hex())
print(rt)
alens-importers 0.10.5
Importers for Beancount's beangulp
Requires Python: >=3.12

# alens-importers
Tool for importing IB Flex report entries into Beancount journal

Converting the functionality of interactive-brokers-flex-rs, ibflex, [repo](https://github.com/alensiljak/interactive-brokers-flex-rs) project to Python.
Since Beancount provides an ingestion framework, beangulp, the tool should utilize that.

Former ib-flex-importer.

# Setup

Install the ibflex package from the git repository directly:
```sh
uv pip install git+https://github.com/csingley/ibflex/
```
Eventually, also install the latest beangulp:
```sh
uv pip install git+https://github.com/beancount/beangulp/
```

# Configuration

To configure the IBKR Flex Query report, see the [instructions](report-configuration.md).

The `test_ibflex.py` file contains a working example of importer configuration.

# Run
```sh
uv run python import.py extract ./downloads > out/tmp.beancount
# with deduplication
uv run python import.py extract ./downloads -e existing.beancount > out/tmp.beancount
```

# Testing
From terminal, the template is:
```sh
uv run pytest
uv run pytest <file_path>::<test_function_name>
uv run pytest <file_path>::<TestClassName>::<test_method_name>
```
Individual tests:
```sh
uv run pytest tests\test_ibflex.py::test_tax_reversal
uv run pytest tests\test_ibflex.py::test_cash_balances
```

# Publish

```sh
uv build
uv publish
```

# Docs

Following the examples at beangulp [repo](https://github.com/beancount/beangulp/tree/master/examples/).

# Related Projects
- Beangulp [repo](https://github.com/beancount/beangulp)
- beancounttools, [repo](https://github.com/tarioch/beancounttools)
- uabean, [repo](https://github.com/OSadovy/uabean/)
- Red's Importers, [repo](https://github.com/redstreet/beancount_reds_importers/)
langchain-redis-rate-limiter 0.1.0
Redis-based distributed RateLimiter for LangChain with RPM/RPS support
Requires Python: >=3.8
Keywords: langchain, redis, langchain-rate-limiter, redis-rate-limiter, redis-limiter, rate-limiter, rate-limit, distributed-rate-limiter

# LangChain Redis Rate Limiter

[English](README.md) | [한국어](README_ko.md)

A Redis-based RateLimiter for LangChain, compatible with `BaseRateLimiter`. It supports **both Requests Per Minute (RPM) and Requests Per Second (RPS)** limiting, designed to work seamlessly in distributed environments.

## Features

- **Redis Support**: Compatible with Local Redis, AWS ElastiCache.
- **LangChain Integration**: Inherits from `BaseRateLimiter`, allowing direct usage with LangChain models.
- **Async Support**: Supports both sync and async request.
- **Distributed Support**: Uses Redis to manage shared status across multiple servers or processes.

## Installation

```bash
pip install langchain-redis-rate-limiter
```

## Usage

### Direct Model Integration (Recommended)

You can pass the `RedisRateLimiter` directly to LangChain models that support the `rate_limiter` parameter (e.g., `ChatOpenAI`, `ChatAnthropic`, `ChatGoogleGenerativeAI`).

```python
from langchain_redis_rate_limiter import RedisRateLimiter
from langchain_openai import ChatOpenAI

# 1 request per second (60 RPM)
limiter = RedisRateLimiter(
    redis_url="redis://localhost:6379",
    requests_per_second=1,
    check_every_n_seconds=0.1,
    max_bucket_size=1
)

model = ChatOpenAI(
    model="gpt-4o",
    rate_limiter=limiter
)

model.invoke("Hello world")
```

## Parameters

- redis_url: Redis connection URL (e.g., redis://localhost:6379).
- key_prefix: Prefix for Redis keys (default: langchain_limiter). Use different prefixes for different limit rules.
- requests_per_second: The maximum number of requests allowed per second. For example, setting this to 5 means you can make up to five requests each second.
- check_every_n_seconds: When the limit is reached and a request needs to wait, this value determines how often the system checks again to see whether a new request is allowed. Example: 0.1 checks every 0.1 seconds.
- max_bucket_size: Controls how many requests can be handled in a short burst. A larger value allows brief spikes in traffic before the limiter slows things down.

## License

Apache-2.0 license