semvec/pypi-packages huggingface dataset:
rssrender 0.1.0
Render RSS feeds with customizable templates
Requires Python: >=3.8
Keywords: feed, render, rss, template, terminal

# rssrender

Render RSS feeds for terminal display with customizable Jinja2 templates.

## Features

- Parse RSS feeds and render them for terminal output
- Filter entries by age (only show recent entries)
- Customizable output using Jinja2 templates
- HTML to plain text conversion with formatting preservation
- Content length limiting
- Optional link hiding

## Installation

```bash
pip install rssrender
```

Or install from source:

```bash
git clone git@github.com:berkeley-stat/rssrender.git
cd rssrender
pip install -e .
```

## Usage

```bash
rssrender --feed-url <RSS_FEED_URL> [--template <TEMPLATE_PATH>]
```

### Options

- `--feed-url` (required): RSS feed URL
- `--template`: Path to Jinja2 template file (default: included example template)
- `--day-threshold`: Number of days to consider an entry as recent (default: 30)
- `--max-body-length`: Maximum length of the body content (default: 400)
- `--hide-http-link`: If set, the HTTP link will not be displayed in the output

### Example

```bash
# Use the default template
rssrender --feed-url https://example.com/feed.xml

# Use a custom template and filter by last 7 days
rssrender --feed-url https://example.com/feed.xml --template ./my-template.j2 --day-threshold 7
```

## Template Format

Templates use Jinja2 syntax and have access to:

- `description`: Feed description (if available)
- `entries`: List of entries with the following fields:
  - `date`: Publication date (YYYY-MM-DD format)
  - `title`: Entry title
  - `link`: Entry URL (if not hidden)
  - `content`: Entry content (HTML converted to plain text)

### Custom Filters

Two custom filters are available in templates:

- `wrap(width, subsequent_indent, indent_all)`: Wrap text to specified width
- `indent(width, first)`: Indent lines by specified number of spaces

See the included example template for reference.

## Use Cases

- Generate MOTD (Message of the Day) from RSS feeds
- Display news feeds in terminal dashboards
- Create plain text digests from blogs
- Any terminal-based RSS feed display

## License

BSD 3-Clause License - See LICENSE file for details.
pygmt-helper 2025.12.1
PyGMT helper package
Requires Python: <3.14,>=3.11

## pygmt helper package

This package contains a set of helper functions for [pygmt](https://www.pygmt.org/latest/) that allow for easy generation of NZ based spatial plots. Additionally, it also contains some functionality to generate some common plots, such as IM plots or fault traces plot.

The aim of this package is to make the common steps of creating a pygmt based spatial plot easy, for specific details the user can also add in some pygmt calls directly.

### Installation
Follow the installation instructions from [pygmt](https://www.pygmt.org/latest/install.html). 
Then install this package via pip.

### Run-Time
Running with NZ specific map data will result in much longer plotting times. Therefore, 
it is recommended to just it to None when iterating on the plot and only enable it for the final version.
Same applies for the high_res_topo option when loading the map data.

### General usage
```python
import pandas as pd

from pygmt_helper import plotting

# Load some spatial data
# with columns lat, lon, key
# where key is whatever you want to plot
data_df = pd.read_csv("bla")

# Create figure
fig = plotting.gen_region_fig("Title")

# Interpolate
grid = plotting.create_grid(data_df, "key")

# Plot the grid
plotting.plot_grid(fig, grid, "hot", (0, 10, (10 - 0) / 10))

# Add anything else to plot
# via pygmt
...

# Save the figure
fig.savefig(
    "/path_to_somwhere/figure.png",
    dpi=900,
    anti_alias=True,
)
```

### Examples
The example folder contains multiple complete examples plots.
raccy-utils 0.5.1
A collection of utility classes and functions.
Requires Python: >=3.12

# RACCY-UTILS

### Overview
Raccy-Utils is a collection of utility functions and classes for various python libraries.

### Requirements
 - Python 3.12+
 - Works on Linux, Windows, and Mac

### Example, working with  config files
Currently this library supports only json and text config files, and it does not support comments at the moment.

```python
from ru import TextConfig

config = TextConfig()
print(config['foo'])
```
```shell script
foo
```

```python
from ru import JsonConfig

config = JsonConfig()
print(config['foo'])
```
```shell script
foo
```

### Example, working with selenium

```python
from ru.selenium_utils import manual_entry
from selenium import webdriver
from selenium.webdriver.common.keys import Keys

driver = webdriver.Chrome()
driver.get('https://google.com')
manual_entry(driver, '//input[@title="Search"]', 'raccy-utils', Keys.ENTER)
```

### Installation

```shell script
pip install raccy-utils
```
pyva-toolbox 1.3.1
Python toolbox for vibroacoustic simulation
Requires Python: >=3.12

# pyva
Python toolbox for vibroacoustics

This toolbox is the code extension for the book 
A. Peiffer: Vibroacoustic Simulation: In Introduction to Statistical Energy Analysis and Hybrid Methods, John Wiley, 2022

[Wiley book details](https://www.wiley.com/en-us/Vibroacoustic+Simulation%3A+An+Introduction+to+Statistical+Energy+Analysis+and+Hybrid+Methods-p-9781119849841)

[Order book](http://www.wiley.com/buy/9781119849841)

This toolbox allows the reader to follow the examples in the book. People that are interested in vibroacoustic simulation with a focus on 
statistical energy analysis (SEA) and hybrid methods (hybrid FEM/SEA), to perform SEA simulation without heavy licence costs.

# Documentation

Direct link to the documentation can be found on [pyva.eu](https://pyva.eu)

# Contributing to pyva

The current version is the baseline for further extensions. It was mainly driven by providing examples and test cases for the book
on [Vibroacoustic Simulation](http://www.wiley.com/buy/9781119849841). Contributions are highly welcome.
The following extensions shall be included mid-term

A major step is a GUI development! Here, suggestions would be very helpful. I am currently thinking about a combination of pyqt 
and vtk, eventually integrating cadquery, opencascade, gmesh or any other option to handle geometry and meshes. 
However, I am still scanning the options. 

## Main Module

- Engineering units contraints, e.g. setting pressure or velocity level of one SEA subsystem

## Coupling Package

- point junctions
- inclusion of beams in line junctions

## Properties Package

### Geometrical Property Module

- Further Beam Cross Sections

### Material Module

- Anisotropic materials

### Structural Property Module

- Linear Laminates
- Sandwich

## Systems Package

- Singly curved shells
- Doubly curved shells
- Infinite layers with porous Biot material
- Elastic Solid as infinite layer

## Load package

- Diffuse wave field as load
- Cross spectral density excitation
 
# Author page and contact information

If you are not sure if pyva suits your needs in the current status feel free to contact me via.
[Author Page - Alexander Peiffer](https://docpeiffer.com)
dedup-pg 0.4.3
Postgres indexing utilities to implement high-throughput queries with on-the-fly deduplication
Requires Python: >=3.11

# dedup-pg

A library with functions useful for implementing a MinHash-based deduplication indexing layer in
Postgres, or any relational database.

## Use cases

In cases where you have to search for specific items in a dataset derived from noisy data, it is
likely that there are duplicates which hurt retrieval quality. We can estimate the similarity
between such items by hashing their components in a way to approximate their Jaccard similarity.
This can be useful for deduplication before item ingestion into an online production database.

However, if your system has special constraints, particularly multi-tenancy where you cannot simply
delete items for every user (because some users might not have access to certain duplicates), it
becomes more infeasible to compute Jaccard similarity pair-wise per query. This library helps solve
this by using locality-sensitive hashing to bucket items that are likely to be above a specific
Jaccard similarity.

In short, it makes query-time deduplication possible and efficient for search systems with special
needs such as multi-tenant retrieval-augmented generation (RAG).

## Usage

Below is an example of usage for deduplicating textual chunks.

```py
from collections import defaultdict

from dedup_pg import DedupIndex
from dedup_pg.helpers import n_grams

# A corpus of named items we want to deduplicate
corpus = [
    ("key1", "The quick brown fox jumps over the lazy dog"),
    ("key2", " he quic  bnown f x jump  over the  azy dog"),
    ("key3", "An entirely different sentence!"),
]

# Our deduplication index - this can be Postgres-backed with configuration
lsh = DedupIndex()

# Using n=3 character n-grams is a strong choice for deduplicating textual chunks
n_gram_corpus = [(key, n_grams(text, n=3)) for key, text in corpus]

# Index bands for each key which help us determine duplicates
duplicate_map = defaultdict(list)
for key, n_gram in n_gram_corpus:
    cluster_key = lsh.query(n_gram)
    duplicate_map[cluster_key].append(key)

# `key1` and `key2` are in the same cluster in contrast to `key3`
print(duplicate_map)
```

For ease-of-use, we provide the `dedup_pg.backend.sqlalchemy.SQLAlchemy` backend, which you use by
passing it the the `DedupIndex` initialization.

## Alternatives

This library is the easiest way to implement deduplication in Postgres, and has been successfully
used in production (at the company I'm working at). Most similar libraries are built for local usage
and have non-compact serialization incompatible with Postgres.

However, `datasketch` and `rensa` are good alternatives if you would like something different.
aitana 0.1.11
Access volcano monitoring data.
Requires Python: >=3.10

# Aitana: access volcano data

Aitana (named after the great football midfielder 
[Aitana Bonmati](https://en.wikipedia.org/wiki/Aitana_Bonmat%C3%AD)) is a project to facilitate access to different types of volcano data. 

It currently only provides methods to access data from the New Zealand
volcanoes [Ruapehu](https://volcano.si.edu/volcano.cfm?vn=241100) and [Whakaari/White Island](https://volcano.si.edu/volcano.cfm?vn=241040).

## Dependencies
* pandas
* requests
* matplotlib
* statsmodels

## Installation

```
pip install -U aitana
```

## Documentation

Learn more about aitana in its official [documentation](https://tsc-tools.github.io/aitana/)
Try out a [Jupyter notebook](https://github.com/tsc-tools/aitana/blob/main/docs/aitana_example.ipynb)

## Get in touch

Report bugs, suggest features, view the source code, and ask questions [on GitHub](https://github.com/tsc-tools/aitana/issues).
close-enough 0.1.1
Add your description here
Requires Python: >=3.13

# close_enough

A cursed Python decorator that generates function implementations using LLMs.

## Installation

```bash
uv add close_enough
```

## Usage

```python
import close_enough

@close_enough
def calculate_fibonacci(n: int) -> int:
    """Calculate the nth Fibonacci number."""
    ...

result = calculate_fibonacci(10)  # 55
```

The decorator generates a function implementation based on the signature and docstring. 
The implementation is generated from a LLM's output lazily on first call and cached for subsequent calls.

Do not use in production code.

## Configuration

The default model is `github_copilot/gpt-4`. To use a different model:

```python
import close_enough
close_enough.MODEL_NAME = "your-model-name"
```


## License

MIT
ftcli-terminal-tool 0.1.1
FTC team management CLI tool with TUI interface
Requires Python: >=3.8

# FTCli

Cli (Command-Line Interface) for FTC teams

## Stack
- python3
    - Textual
    - Typer 
- PostgreSQL

## Local Development

1. Clone the repository

`git clone https://github.com/kashsuks/ftcli`

2. Use a virtual environment (preferred)

`python3 -m venv venv`

`source venv/bin/activate`

3. Install dependencies

`pip3 install -r requirements.txt`

4. Run main file

`python3 ftcli.py`
ti-kit-board-communication 0.1.1
This project creates a web app using the streamlit Python library to interact with the TiKit board visually.
Requires Python: >=3.13.0
Keywords: MSP-EXP430FR5994, TiKit, embedded systems, python

# Scheduled Timing Prototype Web App for ENGR 13100 @ Purdue

## Important Links
- [TiKit Board Information](https://engineering.purdue.edu/fye_tikit/)

## This project creates a web app using the streamlit Python library to interact with the TiKit board visually.
pimp-my-repo 0.1.2
🪄 Enhance your Python repository by adding cutting-edge development tools
Requires Python: >=3.14

# Pimp My Repo

🧙🏼‍♂️ A CLI wizard designed to modernize your Python repositories by adding essential development tools.

[![Test](https://github.com/asaf-kali/pimp-my-repo/actions/workflows/test.yml/badge.svg)](https://github.com/asaf-kali/pimp-my-repo/actions/workflows/test.yml)
[![Lint](https://github.com/asaf-kali/pimp-my-repo/actions/workflows/lint.yml/badge.svg)](https://github.com/asaf-kali/pimp-my-repo/actions/workflows/lint.yml)
[![Type Check](https://github.com/asaf-kali/pimp-my-repo/actions/workflows/type-check.yml/badge.svg)](https://github.com/asaf-kali/pimp-my-repo/actions/workflows/type-check.yml)
[![Ruff](https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/astral-sh/ruff/main/assets/badge/v2.json)](https://github.com/astral-sh/ruff)
[![Type checked: mypy](https://img.shields.io/badge/type%20check-mypy-22aa11)](http://mypy-lang.org/)

## Features

**pimp-my-repo** will help you:
- 🚀 Integrate [uv](https://docs.astral.sh/uv/) for modern dependency management.
- ✨ Configure [ruff](https://github.com/astral-sh/ruff) to keep your code clean and consistent.
- 🐍 Integrate [mypy](https://github.com/python/mypy) for static type checking to catch potential bugs early.
- 🏖️ Set up [pre-commit](https://pre-commit.com/) hooks to ensure code quality before changes are committed.
- 🎢 Generate a [justfile](https://github.com/casey/just) with common commands like `install`, `test` and `lint`.
- 🏗️ Add CI job configurations for `GitHub Actions` or `GitLab Pipeline` to enforce your rules in a continuous integration
  environment.

## Installation

Install **pimp-my-repo** globally with:

```bash
# With UV:
uv tool install pimp-my-repo

# With pipx:
pipx install pimp-my-repo
```
pincushion 0.5.1
An archiving tool for Historypin
Requires Python: >=3.9

# pincushion

[![Test](https://github.com/historypin/pincushion/actions/workflows/test.yml/badge.svg)](https://github.com/historypin/pincushion/actions/workflows/test.yml)

*pincushion* is a command line tool for creating archives for resources on [Historypin]. It reads data from the [Historypin API] and writes a static website to a given directory. The resulting file structure looks something like:

```
archive
├── collections
│   ├── my-collection
│   │   ├── image.jpg
│   │   └── index.html
│   ├── my-other-collection
│   │   ├── image.jpg
│   │   └── index.html
│   └── my-last-collection
│       ├── image.jpg
│       └── index.html
├── data.json
├── index.html
├── pins
│   ├── 123 
│   │   ├── image.jpg
│   │   └── index.html
│   ├── 456
│   │   ├── image.jpg
│   │   └── index.html
│   ├── 789 
│   │   ├── image.jpg
│   │   └── index.html
│   ├── 1001 
│   │   ├── index.html
│   │   └── media.mp3
│   └── 2112
│       ├── index.html
│       └── media.mp4
└── user.jpg
```

Each pin has its own directory, which contains the uploaded media (image, audio or video). The `data.json` file is an aggregation of JSON data collected from the Historypin API, which is used to create the static site.

## Install

```shell
pip install pincushion
```

## Use

Create an archive for user 11670:

```
pincushion user --user-id 11670 --archive-path my-archive
```

Open the `my-archive/index.html` file in your browser.

Similarly you can create an archive for a "collection" as long as the collection contains sub-collections:

```
pincushion collection --slug 2025-summer-institute --archive-path my-collection
```

[Historypin]: https://historypin.org
[Historypin API]: https://historypin.github.io/api-docs/
aio_sync 0.2.0
Synchronization helpers for asyncio
Requires Python: >=3.13

# AioSync

Your ordinary synchronization structures for `asyncio`,
mainly wrappers around `asyncio`'s existing synchronization primitives but with
better type checking.

- `Mutex` that guard inner values.
- `OneShot` channel for one-time communication.
- Multi-producer multi-consumer (MPMC) channel `MPMC[T].channel`.
- TODO: Broadcast channel.
- TODO: Watch channel.