semvec/pypi-packages huggingface dataset:
yanghao.portlink 0.0.15
Simple TCP public network tunnel
Requires Python: >=3.7

```markdown
# yanghao.portlink

> Expose your local port to the public internet with a single command.

```bash
pip install yanghao.portlink
portlink tcp 8000
```

---

## 🚀 Quick Start

1. **Install**  
   ```bash
   pip install yanghao.portlink
   ```

2. **Expose a local TCP service**  
   ```bash
   portlink tcp 8000
   ```
   Output:
   ```
   ✓ Tunnel created
   Public URL: tcp://106.75.139.203:8000 -> localhost:8000
   ```

3. **Programmatic usage**  

```
from yanghao.portlink import PortLinkClient as Client

async def main():
    async with Client(8000) as c:
        await c.link(8000)

if __name__ == "__main__":
    import asyncio
    asyncio.run(main())
```

---

## ✨ Features

- **Zero-config** – one binary, one command  
- **TCP protocol** – simple and reliable  
- **Auto-reconnect** – survives network hiccups  
- **Async & sync APIs** – fits any codebase  
- **Cross-platform** – Linux, macOS, Windows  

---

## 📦 Installation

| Method | Command |
|--------|---------|
| PyPI   | `pip install yanghao.portlink` |
| Source | `git clone https://github.com/yahao333/portlink && pip install -e .` |

Requires **Python 3.8+**.

It is recommended to use a virtual environment (`.venv`) to avoid dependency conflicts.

```bash
python -m venv .venv
source .venv/bin/activate
pip install -r requirements.txt
```

---

## 🛠 Usage

### CLI

| Command | Description |
|---------|-------------|
| `portlink tcp 8000` | Expose local port 8000 |
| `portlink tcp 22`    | Expose local SSH |
| `portlink --config ~/.portlink.yml` | Use custom config |

### Python API (sync)

```python
from yanghao.portlink import Client

client = Client(token="YOUR_TOKEN")
url = client.expose(8000, protocol="tcp")
print(url)  # tcp://abc123.portlink.dev:8000
```

### Python API (async)

```python
import asyncio
from yanghao.portlink import AsyncClient

async def main():
    async with AsyncClient(token="YOUR_TOKEN") as c:
        url = await c.expose(8000, protocol="tcp")
        print(url)  # tcp://abc123.portlink.dev:8000

asyncio.run(main())
```

---

## ⚙️ Configuration

Create `~/.portlink.yml`:

```yaml
token: YOUR_TOKEN
server: tcp://tunnel.portlink.dev
region: auto
```

Environment variables are also supported:
```bash
export PORTLINK_TOKEN="YOUR_TOKEN"
```

---

## 🔐 Authentication

1. [Sign in](https://portlink.dev) → Settings → **API Tokens**  
2. Copy the token, export or save in config.

---

## 🤝 Contributing

1. Fork the repo  
2. `pip install -e ".[dev]"`  
3. `pytest` (≥ 90 % coverage required)  
4. Open a PR

---

## 📄 License

MIT © 2025 yahao333

---

## 💬 Help

- [Discussions](https://github.com/yahao333/portlink/discussions)  
- [Issues](https://github.com/yahao333/portlink/issues)
```
EulerKit 0.4.1b0
A package with some utilities inspired by Project Euler Problems
Requires Python: >=3.9

# EulerKit

<!-- Badges -->
![GitHub Workflow Status](https://img.shields.io/github/actions/workflow/status/MarcoPlatino/EulerKit/python_publish.yml?branch=main)
[![PyPI Version](https://img.shields.io/pypi/v/eulerkit.svg)](https://pypi.org/project/eulerkit/)
![Python Versions](https://img.shields.io/pypi/pyversions/eulerkit.svg)
![License](https://img.shields.io/github/license/MarcoPlatino/EulerKit)
[![Issues](https://img.shields.io/github/issues/MarcoPlatino/EulerKit.svg)](https://github.com/MarcoPlatino/EulerKit/issues)
[![Pull Requests](https://img.shields.io/github/issues-pr/MarcoPlatino/EulerKit.svg)](https://github.com/MarcoPlatino/EulerKit/pulls)

This is a Python Library inspired by the functions that are needed to solve many Project Euler problems. It also includes some utilities that I personally enjoy very much.

Here is a (non-comprehensive) list of features that are in the library:
- Palindromes 
    - The ability to verify if a number is a palindrome
- Prime Generation
    - The ability to generate a large set of prime numbers - to a list or to a file if you want to pre-generate them.
- Pandigital
    - The ability to verify if a number is pandigital or not

### Quickstart:
You can install the library by running this simple command:

`pip install EulerKit`

From there you can begin using the library immediately by importing it at the top of your python projects like this:

```python
from EulerKit import*
```

If you want a more comprehensive guide, check the [wiki](https://github.com/MarcoPlatino/EulerKit/wiki)

If you are curious, the PyPi page is located [here](https://pypi.org/project/EulerKit/)
sf-music-calendar 0.1.16
Multi-venue music event scraper for San Francisco
Requires Python: >=3.9

# Musiclist

Multi-venue music event scraper for San Francisco.

<img width="1006" height="770" alt="cal" src="https://github.com/user-attachments/assets/21fdbe58-750b-474e-a623-557c9f027281" />

<img width="599" height="348" alt="venue" src="https://github.com/user-attachments/assets/a2e352e8-72ea-4366-9fb6-e52295858e7d" />



## Install
```bash
pip install sf-music-calendar
```


## Usage
```bash
music    # Show events for current + next month
music scrape      # Show all upcoming events, force fetch
music --help      # Full options
```

## Development
```bash
pip install -e .

make test         # Run tests
make format       # Format code
```
bsparse 0.1.0
toolkit for creating and searching sparse representations
Requires Python: >=3.9

[![PyPI version fury.io](https://badge.fury.io/py/bsparse.svg)](https://pypi.python.org/pypi/bsparse/)
[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
[![Worfklow](https://github.com/andrewyates/bsparse/workflows/pytest/badge.svg)](https://github.com/andrewyates/bsparse/actions)
[![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)
# bsparse
bsparse is a toolkit for creating and searching learned sparse representations

## Usage examples
```
# Recommended way to install requirements:
# (using pip only works too, but uv is much faster)
pipx install uv
# Create virtual environment
uv venv venv
# Activate
source venv/bin/activate
# Install requirements
uv pip install -r requirements.txt
```

```
# Request access to splade-v3: https://huggingface.co/naver/splade-v3
# Get your huggingface API token and then:
export HF_TOKEN="the token"

# load Python virtual environment
source venv/bin/activate

# optional: spot check output from a model
python -m bsparse.cli check --text "tesla net worth"

# create query representations:
python -m bsparse.cli encode --out nfcorpus-queries.jsonl \
  --dataset irds --type query --name beir/nfcorpus  --batch-size 64

# create doc representations:
python -m bsparse.cli encode --out nfcorpus-docs.jsonl \
  --dataset irds --type doc --name beir/nfcorpus  --batch-size 64

# search and evaluate without building an index:
python -m bsparse.cli memsearch --out nfcorpus.run --docs nfcorpus-docs.jsonl --queries nfcorpus-queries.jsonl --qrels beir/nfcorpus/test


# alternatively, you can build an index and search it

# 1) setup: compile ScaledJsonVectorCollection.java and add it to anserini-1.0.0-fatjar.jar
$ wget -c https://repo1.maven.org/maven2/io/anserini/anserini/1.0.0/anserini-1.0.0-fatjar.jar
$ cd java
$ javac -cp ../anserini-1.0.0-fatjar.jar io/anserini/collection/*.java
$ cp ../anserini-1.0.0-fatjar.jar ../anserini-1.0.0-fatjar-bsparse.jar
$ jar uf ../anserini-1.0.0-fatjar-bsparse.jar io/anserini/collection/*.class

# 2) build index
java -cp anserini-1.0.0-fatjar-AY.jar  io.anserini.index.IndexCollection \
  -generator DefaultLuceneDocumentGenerator -impact -pretokenized \
  -threads 16 -collection ScaledJsonVectorCollection \
  -input /path/to/encoded-text -index /path/to/encoded-text-index

# 3) search index
# Create sparse query representations in `$QUERY_VECTORS` and create an index in `$INDEX`, then:
python -m bsparse.cli search --index $INDEX --queries $QUERY_VECTORS --out test.run --topk 1000
```
physics-plot 0.2.3
Publication-quality Matplotlib styling and helper utilities for scientific plots
Requires Python: >=3.9

# physics-plot

[![PyPI - Version](https://img.shields.io/pypi/v/physics-plot)](https://pypi.org/project/physics-plot/)
[![PyPI - Downloads](https://img.shields.io/pypi/dm/physics-plot)](https://pypi.org/project/physics-plot/)

`physics-plot` is essentially a zero dependency python package shipping a Matplotlib style sheet — [`pp_base.mplstyle`](https://github.com/c0rychu/physics-plot/blob/main/src/physics_plot/pp_base.mplstyle) to create publication-quality plots with minimal effort. In addition, a few optional helper classes are provided.

- [Documentation](https://c0rychu.github.io/physics-plot/)
- [PyPI](https://pypi.org/project/physics-plot/)

## Features

- **Matplotlib style sheet** — `physics_plot.pp_base` enforces serif fonts, LaTeX math, minimalist grids, and high-resolution exports out of the box.
- **Legend utilities** — `physics_plot.Handles` makes it easy to build custom legend entries for artists (e.g., violin plots) that don’t expose a `label` argument.

## Installation

```bash
pip install physics-plot
```

## Quick Start

`physics-plot` can be installed via pip:
```bash
pip install physics-plot
```

There are basically two ways to use the `physics-plot` stylesheet. You can set it globally at the start of your script/notebook:
```python
import matplotlib.pyplot as plt

plt.style.use("physics_plot.pp_base")

# ======================= #
# Your plotting code here #
# ======================= #
```

Or you can apply it to individual figures using a context manager:
```python
import matplotlib.pyplot as plt

with plt.style.context("physics_plot.pp_base"):
    # ======================= #
    # Your plotting code here #
    # ======================= #
```

## Examples

- **Bode plot** ([`examples/bode-plot.py`](https://github.com/c0rychu/physics-plot/blob/main/examples/bode-plot.py)) generates a two-panel magnitude/phase plot for a first-order low-pass filter.
  
  ![Bode plot](https://raw.githubusercontent.com/c0rychu/physics-plot/main/examples/bode-plot%402x.png)

- **Violin plot** ([`examples/violin-plot.ipynb`](https://github.com/c0rychu/physics-plot/blob/main/examples/violin-plot.ipynb)) demonstrates how to pair `Handles` with `Axes.violinplot` so the legend of the violin plot can be created, which is absent in Matplotlib.

  ![Violin plot](https://raw.githubusercontent.com/c0rychu/physics-plot/main/examples/violin-plot%402x.png)

Feel free to start from either example when styling your own figures.

## Development

- Coming soon

## License
This project is licensed under the
[MIT](LICENSE)
license.

### Third-Party Licenses
This project includes or adapts files from:
- [**SciencePlots**](https://github.com/garrettj403/SciencePlots) (MIT License)
  Copyright (c) 2018 John Garrett
- [**Matplotlib**](https://github.com/matplotlib/matplotlib) (BSD-compatible license)
  Copyright (c) 2012– Matplotlib Development Team
- [**Seaborn**](https://github.com/mwaskom/seaborn) (BSD 3-Clause License)
  Copyright (c) 2012–2023, Michael L. Waskom