semvec/pypi-packages huggingface dataset:
cparrun 2026.1.0
cparrun - combinated parallel run of something as multiple processes
Requires Python: >=3.9
Keywords: parallel, run, process

# cparrun

cparrun - combinated parallel run of something as multiple processes (as many as you want and restricted by timeout)
Could be used as python module or command line utility.
Command line utility mode could interpret arguments as multiple combinations or run in parallel set of lines from stdin as shell commands.

Output results are in JSON format with separated stdout, stderr, return code, status.

# USAGE EXAMPLES:
## this example makes 3x3x3=27 combinations and just print them
cparrun --parallel=8 --dry-run -- "dig -t %['NS', 'SOA', 'MX']% %['google.com', 'gmail.com', 'facebook.com']% %['@1.1.1.1', '@8.8.8.8', @'nonexistingdomain.somedomain.']% +short"

## request DNS in parallel. this example makes 3x3x3=27 combinations and run them. Output results is JSON
cparrun --parallel=8 -- "dig -t %['NS', 'SOA', 'MX']% %['google.com', 'gmail.com', 'facebook.com']% %['@1.1.1.1', '@8.8.8.8', @'nonexistingdomain.somedomain.']% +short"

## send of list of everything to run to stdin, JSON results are filtered by jq utility
echo 'ping -c2 8.8.8.8
sleep 10
curl -s google.com
wget nonexistentdomain.com123
host example.com
host example2.com
' | cparrun --stdin --timeout=2 | jq '.[] | select(.status | contains("ERROR"))'

## simple stdin example from file
cat commands.txt | cparrun --stdin --parallel=50 --timeout=5

## other examples
https://github.com/itledevs/cparrun/wiki
agent-safe-spl 0.1.0
SPL (Safe Policy Lisp) evaluator for Agent-Safe capability tokens. 150 lines, zero deps, microseconds.
Requires Python: >=3.10
Keywords: agent, authorization, capability, token, spl, policy, ai

# Agent-Safe SPL — Python SDK

Python implementation of the SPL (Safe Policy Lisp) evaluator for Agent-Safe capability tokens.

## Install

```bash
pip install -e .               # core (zero runtime deps)
pip install -e ".[crypto]"     # with Ed25519/Merkle/hash-chain support
pip install -e ".[dev]"        # with test dependencies
```

## Usage

### As a library

```python
from spl import parse, verify

policy = parse('(and (= (get req "action") "read") (<= (get req "amount") 100))')
request = {"action": "read", "amount": 50}
env = {
    "vars": {},
    "per_day_count": lambda action, day: 0,
    "crypto": {
        "dpop_ok": lambda: True,
        "merkle_ok": lambda t: True,
        "vrf_ok": lambda d, a: True,
        "thresh_ok": lambda: True,
    },
}

result = verify(policy, request, env)
print("ALLOW" if result["allow"] else "DENY")
```

### As a CLI

```bash
python -m spl examples/policies/family_gifts.spl examples/requests/gift_50_niece.json
# → ALLOW
```

## Tests

```bash
pip install -e ".[dev]"
pytest tests/ -v
```

## Requirements

- Python 3.10+
- Zero runtime dependencies for core evaluator
- `cryptography` package optional for real Ed25519 verification
luminarycloud-jupyter 0.1.21
Luminary Cloud SDK Interactive Jupyter Widgets
Requires Python: >=3.10
Keywords: Jupyter, Luminary Cloud, SDK

Luminary Cloud's Python Software Development Kit (SDK) allows you to access many of the features within our platform programmatically (i.e. without needing to go through the graphical user interface in your browser).

Our Python SDK provides a secure abstraction layer, a set of simulation-specific data structures, and all the necessary functionality to enable automation via simple Python scripts.

It allows you to create your own applications leveraging Luminary (such as importing geometry and creating meshes, running and post-processing simulations, running explorations and creating surrogate models) and connect Luminary simulations to pre- and post-processing tools that are already part of your own workflows.

The Jupyter widget provided by this package allows you to perform interactive visualization of your geometry, meshes, and simulations conveniently and programmatically within the Jupyter environment.
vantage-python 0.3.1
Python SDK for the Vantage API
Requires Python: >=3.9
Keywords: api, client, cloud, cost, sdk, vantage

# vantage-python

A Python SDK for the [Vantage](https://vantage.sh) API. Types and client methods are auto-generated from the official OpenAPI specification.

## Installation

```bash
pip install vantage-python
```

## Usage

### Synchronous Client

```python
from vantage import Client

client = Client("your-api-token")

# List resources with query parameters
reports = client.cost_reports.list(page=1)

# Get a specific resource by token
report = client.cost_reports.get("rprt_abc123")

# Create a new resource
folder = client.folders.create(CreateFolder(
    title="Production Costs",
    workspace_token="wrkspc_123",
))

# Update a resource
client.folders.update("fldr_abc123", UpdateFolder(
    title="Updated Title",
))

# Delete a resource
client.folders.delete("fldr_abc123")
```

### Async Client

```python
from vantage import AsyncClient

async with AsyncClient("your-api-token") as client:
    folders = await client.folders.list()

    folder = await client.folders.create(CreateFolder(
        title="Production Costs",
        workspace_token="wrkspc_123",
    ))
```

## Error Handling

API errors are raised as `VantageAPIError` with structured error information:

```python
from vantage import Client, VantageAPIError

try:
    client.cost_reports.get("invalid_token")
except VantageAPIError as e:
    print(e.status)      # 404
    print(e.status_text)  # "Not Found"
    print(e.errors)       # ["Resource not found"] or None
```

## Development

### Building

```bash
make install
```

This generates Pydantic models, sync client, and the async client. Your pip version will need to be up to date for this. If you wish to generate the client first, you should use `make generate`.

### Testing

```bash
pytest
```

### Publishing

```bash
make publish
```
fluidattacks-tracks 0.11.2
Python library for usage analytics
Requires Python: <3.14,>=3.11

# fluidattacks-tracks

[![PyPI version](https://img.shields.io/pypi/v/fluidattacks-tracks.svg)](https://pypi.org/project/fluidattacks-tracks/)

<p align="center">
  <a href="https://fluidattacks.com/" rel="noopener" target="_blank">
  <img width="460px" src="https://res.cloudinary.com/fluid-attacks/image/upload/v1728418266/airs/logo/logo_full.png" alt="Fluid Attacks logo">
  </a>
</p>

This library provides a convenient way to report usage analytics from any Python 3.11+
application.

All operations run in a background thread, and errors are logged but don't propagate to the caller, ensuring your application's flow isn't interrupted.

## Usage

```python
from datetime import datetime, UTC
from fluidattacks_tracks import Tracks
from fluidattacks_tracks.resources.event import Event

client = Tracks()
client.event.create(
    Event(
        action="CREATE",
        author="author",
        date=datetime.now(UTC),
        mechanism="API",
        metadata={"foo": "bar"},
        object="object",
        object_id="object_id",
    )
)
```