semvec/pypi-packages huggingface dataset:
textual-enhanced 1.3.0
A library of mildly-opinionated enhancements to Textual
Requires Python: >=3.10
Keywords: terminal, library, tui, framework

# textual-enhanced

This library is a mildly-opinionated set of enhancements and extras for the
Textual framework, mainly aimed at how I like my own Textual apps to look
and work. I've written this as a common set of tweaks I want for my own
Textual apps. It might be useful for yours too.

See [the online documentation](https://textual-enhanced.davep.dev/) for more
background and details.

[//]: # (README.md ends here)
advanced-calculator-prashant 0.2.0
A CLI based advanced calculator with scientific operations.
Requires Python: >=3.8

🧮 Advanced Calculator (CLI)

A Command-Line Advanced Calculator built in Python that supports both basic and scientific mathematical operations.

🚀 Features
✅ Basic Operations

Addition

Subtraction

Multiplication

Division

✅ Scientific Operations

Square Root

Power

Natural Logarithm (ln)

Sine (Degrees)

Cosine (Degrees)

Factorial

✅ Error Handling

Prevents division by zero

Prevents square root of negative numbers

Prevents logarithm of non-positive numbers

Factorial works only for non-negative integers

📦 Installation

Install from PyPI:

pip install advanced-calculator-prashant

▶️ Usage

After installation, run:

advcalc


You will see the calculator menu in your terminal.
Enter the number corresponding to the operation and follow the prompts.

🛠 Example

Addition Example

Enter your choice: 1
Enter first number: 10
Enter second number: 5
Result: 15


Factorial Example

Enter your choice: 10
Enter number: 5
Result: 120

🐍 Requirements

Python 3.8 or higher

📁 Project Structure
MATH_CAL_PACKAGE/
│
├── mathcal/
│   ├── __init__.py
│   └── main.py
│
├── setup.py
└── README.md

📄 License

MIT License

👨‍💻 Author

Prashant Rai
cuvs-cu12 26.2.0
cuVS: Vector Search on the GPU
Requires Python: >=3.10

# cuVS

cuVS contains state-of-the-art implementations of several algorithms for running approximate nearest neighbors and clustering on the GPU. It can be used directly or through the various databases and other libraries that have integrated it. The primary goal of cuVS is to simplify the use of GPUs for vector similarity search and clustering.
lzl-pytools 0.3.5
a multi run http req tool
Requires Python: >=3.6

# lzl_pytools

```shell
python3 -m venv .pyenv
pip install --upgrade setuptools wheel twine

. .pyenv/bin/activate
rm -rf build
rm -rf dist

python3 setup.py sdist bdist_wheel
twine upload --repository testpypi dist/*
pip install --index-url https://test.pypi.org/simple/ your-package-name

# 测试发布
twine upload --config-file ~/.pypirc --repository testpypi dist/*
pip install --index-url https://test.pypi.org/simple/ lzl-pytools

# 正式发布
twine upload --config-file ~/.pypirc dist/*
https://pypi.org/project/lzl-pytools/0.1.0/
pip install lzl-pytools --index-url https://pypi.org/simple/
```
cuvs-cu13 26.2.0
cuVS: Vector Search on the GPU
Requires Python: >=3.10

# cuVS

cuVS contains state-of-the-art implementations of several algorithms for running approximate nearest neighbors and clustering on the GPU. It can be used directly or through the various databases and other libraries that have integrated it. The primary goal of cuVS is to simplify the use of GPUs for vector similarity search and clustering.
wifireconnect 0.2.0
Python module to test and ensure connectivity on a network which have stability problems on its wifi. Run on Ubuntu / Debian.
Requires Python: >=3.10
Keywords: wifi, connectivity, networking

# wifireconnect
*Python module to test and ensure connectivity on a network.*

## Rationale:
This module attemps to ensure connectivity on networks which have
stability problems on its wifi. Run on Ubuntu / Debian.

## Requirements
You need network manager.
(sudo apt install network-manager)

## Installation
### Install with uv:
```bash
uv add wifireconnect
```

## Usage
From shell:

```
$ wifireconnect --help
Usage: wifireconnect [OPTIONS]

Run a connectivity test on a network connection (using ping) every 's' seconds
and try to reconnect if that test fails. (See your networks with 'nmcli conn')

Options:
  -e, --essid TEXT        AP's ESSID.  [required]
  -p, --password TEXT     AP's password.
  -t, --target TEXT       Target webpage for connectivity test.  [default: httpbin.com]
  -s, --sleep INTEGER     Time between connectivity tests in seconds.  [default: 10]
  -c, --count INTEGER     Number of attempts to ping target on the connectivity test.  [default: 2]
  -v, --verbose          Enable verbose output.
  --help                 Show this message and exit.
```

From the interpreter:

```
help(wifireconnect)
```
metaspn-tokens 0.1.1
Token resolution and promise registry core for MetaSPN
Requires Python: >=3.10
Keywords: metaspn, tokens, promises, registry, sqlite

# metaspn-tokens

`metaspn-tokens` provides token entity resolution, promise registration, promise evaluation,
and token health feature extraction backed by SQLite.

## Highlights

- Deterministic promise IDs with duplicate rejection.
- Append-only promise evaluations.
- PromiseRegistry API for registration, retrieval, evaluation, and credibility summaries.
- Built-in token adapters for Solana RPC and Pump.fun style lookups.

## Quickstart

```python
from metaspn_tokens import PromiseRegistry

registry = PromiseRegistry()
registry.self_register_defaults(project_id="proj_towel")
promise = registry.register(
    project_id="proj_towel",
    token_symbol="$TOWEL",
    statement="Reach 10k holders",
    due_at="2026-12-31T00:00:00+00:00",
)
registry.evaluate(promise.promise_id, observed=False)
summary = registry.credibility_summary(project_id="proj_towel")
```
yalc 0.1.3
Yet Another LLM Client
Requires Python: >=3.13

# Yet Another LLM Client

An opinionated python wrapper for LLM calls. Supports multiple LLM providers:

- OpenAI
- Anthropic
- more to come...

Uses [pydantic](https://docs.pydantic.dev/latest/) models to serialize LLM responses. Every response **has** to be serialized into a pydantic model.

Full async support.

## Usage

Every call to the LLM returns some metadata. Metadata contains token usage, costs, model used and context messages. YALC supports 2 modes of operations for handling metadata.

### Metadata return mode

Metadata is returned directly alongside the response as a tuple.

```python
client = create_client(LLMModel.gpt_4o_mini)

result, metadata = await client.structured_response(
    JudgmentResult, messages
)
```

Advantages:

- Simple, no setup required
- Direct access to metadata at the call site

Disadvantages:

- Must handle metadata manually on every call
- Easy to forget or handle inconsistently across call sites

### Strategy metadata mode

A metadata handler strategy is provided during client creation. The strategy is automatically invoked on every call when a `context` is passed. The provided `context` is used for any additional data that needs to be used when handling LLM call metadata.

```python
# 1. Define your strategy
class LogStrategy:
    def handle(self, call: ClientCall, context: LLMLogContext):
        print(f"Tokens: {call.input_tokens + call.output_tokens}")
        print(f"Cost: {call.input_tokens_cost + call.output_tokens_cost}")
        db.save(call.model_dump(), context.request_id)

# 2. Create client with the strategy
client = create_client(LLMModel.gpt_4o_mini, log_strategies=[LogStrategy()])

# 3. Pass context to trigger the strategy
result = await client.structured_response(
    JudgmentResult, messages, context=llm_log_context
)
```

Advantages:

- Metadata handling is set up once and applied consistently
- Call sites stay clean — no need to unpack or handle metadata each time

Disadvantages:

- More initial setup
- Metadata handling is implicit, which can be harder to trace