semvec/pypi-packages huggingface dataset:
grave-cli 2.4.2
GRAVE — Git Repository Abandonment & Vintage Explorer. Dig up dead, forgotten, and vintage GitHub repositories.
Requires Python: >=3.10
Keywords: abandoned, archaeology, cli, github, repositories, vintage

# GRAVE — Git Repository Abandonment & Vintage Explorer

Dig up dead, forgotten, and vintage GitHub repositories.

**GRAVE** is a command-line tool for digital archaeology. It searches GitHub for old, weird, abandoned, and forgotten repositories using 27 curated preset profiles and custom queries. Every result is persisted locally in SQLite so you can build your own collection of internet history.

## Install

```bash
pipx install grave-cli
```

Or with pip:

```bash
pip install grave-cli
```

> **Requires:** Python 3.10+ and [gh CLI](https://cli.github.com) (handles all GitHub authentication)

## Quick Start

```bash
# First-time setup (checks prerequisites)
grave init

# Start digging
grave scan --preset ancient
grave random
grave dig torvalds/linux --open
```

## What It Does

- **27 curated presets** across 5 categories (archaeology, dead languages, eras, culture, science)
- **Era-based search** with named time windows (Y2K, dotcom bubble, Web 2.0, early GitHub)
- **Smart abandonment filters** (`--abandoned`, `--dead-since`)
- **Discovery commands** like `grave random` and `grave rabbit-hole`
- **Thematic exploration** with `grave morgue` (dead forks) and `grave casket` (archived repos)
- **SQLite persistence** with automatic deduplication and scan history
- **Rich terminal UI** with clickable hyperlinks, colored tables, and formatted panels
- **Export** to JSON, CSV, or NDJSON

## Commands

| Command | Description |
|---|---|
| `grave init` | First-time setup and prerequisite checks |
| `grave scan` | Search with presets or custom parameters |
| `grave dig <owner/repo>` | Deep-dive into a specific repository |
| `grave random` | Random preset slot machine |
| `grave rabbit-hole <owner/repo>` | Find similar repos |
| `grave morgue` | Search for dead forks |
| `grave casket` | Find archived repositories |
| `grave list` | Browse your collected repos |
| `grave export` | Export as JSON, CSV, or NDJSON |
| `grave presets` | List all 27 search presets |

## Links

- **GitHub:** [github.com/ul0gic/grave](https://github.com/ul0gic/grave)
- **Issues:** [github.com/ul0gic/grave/issues](https://github.com/ul0gic/grave/issues)
- **License:** MIT
pueblo 0.0.15
Pueblo - a Python toolbox library.
Requires Python: >=3.7
Keywords: general purpose, library, mixed, pueblo

# Pueblo - a Python toolbox library

[![Tests](https://github.com/pyveci/pueblo/actions/workflows/main.yml/badge.svg)](https://github.com/pyveci/pueblo/actions/workflows/main.yml)
[![Test coverage](https://img.shields.io/codecov/c/gh/pyveci/pueblo.svg)](https://codecov.io/gh/pyveci/pueblo/)
[![Python versions](https://img.shields.io/pypi/pyversions/pueblo.svg)](https://pypi.org/project/pueblo/)

[![License](https://img.shields.io/github/license/pyveci/pueblo.svg)](https://github.com/pyveci/pueblo/blob/main/LICENSE)
[![Status](https://img.shields.io/pypi/status/pueblo.svg)](https://pypi.org/project/pueblo/)
[![PyPI](https://img.shields.io/pypi/v/pueblo.svg)](https://pypi.org/project/pueblo/)
[![Downloads](https://pepy.tech/badge/pueblo/month)](https://pypi.org/project/pueblo/)


<!-- » [Documentation] -->

» [Changelog]
| [PyPI]
| [Issues]
| [Source code]
| [License]

[Changelog]: https://github.com/pyveci/pueblo/blob/main/CHANGES.md
[Documentation]: https://pueblo.readthedocs.io/
[Issues]: https://github.com/pyveci/pueblo/issues
[License]: https://github.com/pyveci/pueblo/blob/main/LICENSE
[PyPI]: https://pypi.org/project/pueblo/
[Source code]: https://github.com/pyveci/pueblo


## About

- A Python toolbox library.
- Contains Python code duplicated too often elsewhere.
- Finally, it is in one place.
- Here be dragons and gems.


## Setup

```shell
uv pip install --upgrade pueblo
```

After installation, you can verify if it was successful.
```shell
pueblo --version
```


## Usage

Read the source.


## Prior Art

- https://pypi.org/project/boltons/


### Supported by

[![JetBrains logo.](https://resources.jetbrains.com/storage/products/company/brand/logos/jetbrains.svg)](https://jb.gg/OpenSourceSupport)

Special thanks to the people at JetBrains s.r.o. for supporting us with
excellent development tooling.
h-net-dynamic-chunking 0.3.2
H-Net Dynamic Chunking Modules
Requires Python: >=3.9
Keywords: artificial intelligence, deep learning, learned chunking, learned tokenization

<img src="./h-net.png" width="450px"></img>

## H-Net Dynamic Chunking

Implementation of the dynamic chunking mechanism in [H-net](https://arxiv.org/abs/2507.07955) by Hwang et al. of Carnegie Mellon

## Install

```shell
$ pip install h-net-dynamic-chunking
```

## Usage

```python
import torch
from h_net_dynamic_chunking import DynamicSequenceChunker

downsampler = DynamicSequenceChunker(512)

tokens = torch.randn(3, 1024, 512).requires_grad_()

downsampled, upsample_fn, *_ = downsampler(tokens)

assert upsample_fn(downsampled).shape == tokens.shape
```

3 layers hierarchy

```python
import torch
from h_net_dynamic_chunking import DynamicSequenceChunker

downsampler1 = DynamicSequenceChunker(512)
downsampler2 = DynamicSequenceChunker(512)
downsampler3 = DynamicSequenceChunker(512)

tokens = torch.randn(3, 1024, 512).requires_grad_()

downsampled1, upsample_fn1, aux_loss1 = downsampler1(tokens)

# hierarchical network 1 ...

downsampled2, upsample_fn2, aux_loss2 = downsampler2(downsampled1)

# hierarchical network 2 ...

downsampled3, upsample_fn3, aux_loss3 = downsampler3(downsampled2)

# inner most network

# reconstituting

assert upsample_fn1(upsample_fn2(upsample_fn3(downsampled3))).shape == tokens.shape
```

HNet wrapper

```python
import torch
from torch import nn
from h_net_dynamic_chunking.h_net import HNet

# 3 hierarchies, from 512 -> 1024 -> 2048 inner

net = HNet(
    nn.Identity(),
    HNet(
        nn.Identity(),
        HNet(
            nn.Identity(),
            nn.Identity(),
            nn.Identity(),
            dim = 2048
        ),
        nn.Identity(),
        dim = 1024,
        dim_inner = 2048
    ),
    nn.Identity(),
    dim = 512,
    dim_inner = 1024,
)

tokens = torch.randn(1, 1024, 512)

out, aux_loss = net(tokens) # (1, 1024, 512), (1,)
```

## Example

Enwik8 with 2 hierarchies

```shell
$ pip install '.[examples]'
```

Then

```shell
$ python train.py
```

## Citations

```bibtex
@misc{hwang2025dynamicchunkingendtoendhierarchical,
    title   = {Dynamic Chunking for End-to-End Hierarchical Sequence Modeling},
    author  = {Sukjun Hwang and Brandon Wang and Albert Gu},
    year    = {2025},
    eprint  = {2507.07955},
    archivePrefix = {arXiv},
    primaryClass = {cs.LG},
    url     = {https://arxiv.org/abs/2507.07955},
}
```