semvec/pypi-packages huggingface dataset:
veribits 1.0.0
Official Python SDK for VeriBits API
Requires Python: >=3.8
Keywords: veribits, security, threat-intelligence, malware, sandbox, sbom, api

# VeriBits Python SDK

Official Python SDK for the [VeriBits](https://veribits.com) security API.

## Installation

```bash
pip install veribits
```

## Quick Start

```python
from veribits import VeriBits

# Initialize client
client = VeriBits(api_key="your_api_key")

# Threat intelligence lookup
result = client.threat_intel.lookup("d41d8cd98f00b204e9800998ecf8427e")
print(f"Threat score: {result['threat_score']}")

# Submit file to sandbox
scan = client.sandbox.submit("/path/to/suspicious/file.exe")
print(f"Task ID: {scan['task_id']}")

# Generate SBOM for your project
sbom = client.cicd.generate_sbom(format="cyclonedx")
```

## Features

### Threat Intelligence
```python
# Lookup hash
result = client.threat_intel.lookup("sha256_hash")

# Batch lookup
results = client.threat_intel.batch_lookup(["hash1", "hash2", "hash3"])

# Search threats
threats = client.threat_intel.search(query="ransomware", limit=10)
```

### Malware Sandbox
```python
# Submit file for analysis
submission = client.sandbox.submit("/path/to/file", analysis_type="full")

# Check status
status = client.sandbox.status(submission['task_id'])

# Get results
results = client.sandbox.result(submission['task_id'])
```

### CI/CD Integration
```python
# Generate SBOM
sbom = client.cicd.generate_sbom(format="cyclonedx")

# Scan dependencies for vulnerabilities
vulns = client.cicd.scan_dependencies("requirements.txt")

# Scan for hardcoded secrets
secrets = client.cicd.scan_secrets("./src")
```

### Cryptographic Services
```python
# Publish a public key
key_info = client.crypto.publish_key(pgp_key, key_type="pgp")

# Lookup a key
key = client.crypto.lookup_key("user@example.com")

# Verify signature
result = client.crypto.verify_signature(data, signature)

# Validate certificate
validation = client.crypto.validate_certificate(cert_pem)
```

## Error Handling

```python
from veribits import VeriBits, APIError, AuthenticationError, RateLimitError

client = VeriBits(api_key="your_api_key")

try:
    result = client.threat_intel.lookup("hash")
except AuthenticationError:
    print("Invalid API key")
except RateLimitError as e:
    print(f"Rate limited. Retry after {e.retry_after} seconds")
except APIError as e:
    print(f"API error: {e.status_code} - {e}")
```

## Configuration

```python
# Custom API endpoint
client = VeriBits(
    api_key="your_api_key",
    api_url="https://custom.veribits.com"
)
```

## Requirements

- Python 3.8+
- requests >= 2.28.0

## License

MIT License - see [LICENSE](LICENSE) for details.

## Links

- [VeriBits Platform](https://veribits.com)
- [API Documentation](https://docs.veribits.com)
- [GitHub](https://github.com/veribits/python-sdk)
etcd3gw 2.5.0
A python client for etcd3 grpc-gateway v3 API
Requires Python: >=3.9

========================
Team and repository tags
========================

.. image:: https://governance.openstack.org/tc/badges/oslo.config.svg
    :target: https://governance.openstack.org/tc/reference/tags/index.html

.. Change things from this point on

===========================
etcd3 gateway Python Client
===========================

.. image:: https://img.shields.io/pypi/v/etcd3gw.svg
     :target: https://pypi.org/project/etcd3gw/
     :alt: Latest version

.. image:: https://img.shields.io/pypi/dm/etcd3gw.svg
     :target: https://pypi.org/project/etcd3gw/
     :alt: Downloads

The etcd3gw library provides a python client for etcd3 grpc-gateway v3 API.

* License: Apache License, Version 2.0
* Documentation: https://docs.openstack.org/etcd3gw/latest/
* Source: https://opendev.org/openstack/etcd3gw/
* Bugs: https://bugs.launchpad.net/python-etcd3gw
* Release notes:  https://docs.openstack.org/releasenotes/etcd3gw/
cuda-toolkit 13.1.1
CUDA Toolkit meta-package
Keywords: cuda, nvidia

# cuda-toolkit 13.1.1

### [NVIDIA CUDA Toolkit](https://developer.nvidia.com/cuda-toolkit)

> The NVIDIA CUDA Toolkit provides a development environment for creating high-performance, GPU-accelerated applications. With it, you can develop, optimize, and deploy your applications on GPU-accelerated embedded systems, desktop workstations, enterprise data centers, cloud-based platforms, and supercomputers. The toolkit includes GPU-accelerated libraries, debugging and optimization tools, a C/C++ compiler, and a runtime library.

### `cuda-toolkit` package

The `cuda-toolkit` package is a meta-package (a package that contains no software and only installs other packages) to install all or part of the NVIDIA CUDA Toolkit.

For instructions on how to use the `cuda-toolkit` package, please refer to the [NVIDIA CUDA Toolkit documentation](https://docs.nvidia.com/cuda/) and follow the installation guide for your platform. A summary of usage is also available below.

### Using the `cuda-toolkit` package

The `cuda-toolkit` package uses package extras to install all or part of the CUDA Toolkit.
Some examples of using the `cuda-toolkit` meta-package with extras:

Install all of the CUDA Toolkit
```
pip install cuda-toolkit[all]
```

Install just the CUDA Runtime
```
pip install cuda-toolkit[cudart]
```

Install cuBLAS, cuSOLVER, and cuSPARSE
```
pip install cuda-toolkit[cublas,cusolver,cusparse]
```

### Available extras

| Extra | Package | Version |
|-------|---------|---------|
| `all` | All packages below |  |
| cccl | nvidia-cuda-cccl | 13.1.115  |
| crt | nvidia-cuda-crt | 13.1.115  |
| cublas | nvidia-cublas | 13.2.1.1  |
| cudart | nvidia-cuda-runtime | 13.1.80  |
| cufft | nvidia-cufft | 12.1.0.78  |
| cufile | nvidia-cufile | 1.16.1.26  |
| culibos | nvidia-cuda-culibos | 13.1.115  |
| cupti | nvidia-cuda-cupti | 13.1.115  |
| curand | nvidia-curand | 10.4.1.81  |
| cusolver | nvidia-cusolver | 12.0.9.81  |
| cusparse | nvidia-cusparse | 12.7.3.1  |
| cuxxfilt | nvidia-cuda-cuxxfilt | 13.1.115  |
| npp | nvidia-npp | 13.0.3.3  |
| nvcc | nvidia-cuda-nvcc | 13.1.115  |
| nvfatbin | nvidia-nvfatbin | 13.1.115  |
| nvjitlink | nvidia-nvjitlink | 13.1.115  |
| nvjpeg | nvidia-nvjpeg | 13.0.3.75  |
| nvml | nvidia-nvml-dev | 13.1.115  |
| nvptxcompiler | nvidia-nvptxcompiler | 13.1.115  |
| nvrtc | nvidia-cuda-nvrtc | 13.1.115  |
| nvtx | nvidia-nvtx | 13.1.115  |
| nvvm | nvidia-nvvm | 13.1.115  |
| opencl | nvidia-cuda-opencl | 13.1.115  |
| profiler | nvidia-cuda-profiler-api | 13.1.115  |
| sanitizer | nvidia-cuda-sanitizer-api | 13.1.118  |
| tileiras | nvidia-cuda-tileiras | 13.1.80  |
sessionsync 0.1.2
CLI to export and archive coding agent sessions to multiple formats.
Requires Python: >=3.12
Keywords: claude-code, cli, coding-agent, export, json, markdown, opencode, session

# SessionSync

SessionSync exports AI coding agent sessions to standardized file formats. It reads session data from Claude Code, OpenCode, and Pi, then converts them to Markdown, JSON, or TOON format.

## Problem

AI coding agents store session data in different formats and locations. This makes it difficult to:

- Review past conversations across multiple agents
- Search and organize session history
- Share, back up or archive coding sessions
- Analyze tool usage patterns

Long sessions also cause agents to enter the "[DUMB ZONE](https://www.youtube.com/watch?v=rmvDxxNubIg&t=355s)". Short sessions avoid this but lose context. SessionSync exports sessions to files so agents can read them back, giving them memory through the filesystem.

## Supported Agents

- Claude Code
- OpenCode
- Pi

## Export Formats

| Format | Description |
|--------|-------------|
| Markdown | Human-readable with YAML frontmatter containing session metadata |
| JSON | Structured data for programmatic access and analysis |
| TOON | Binary format for compact storage |

## Installation

### PyPI

```sh
pip install sessionsync
```

Or with uv:

```sh
uv tool install sessionsync --prerelease=allow
```

## Usage

Export all sessions from the current workspace:

```sh
sessionsync
```

Export sessions from a specific agent:

```sh
sessionsync --agent claude
sessionsync --agent opencode
sessionsync --agent pi
```

Export to a specific format:

```sh
sessionsync --format json
sessionsync --format toon
```

Filter by git branch:

```sh
sessionsync --branch main
```

Watch mode for continuous export:

```sh
sessionsync --watch
```

### Options

| Option | Short | Description |
|--------|-------|-------------|
| `--agent` | `-a` | Agent to sync: `claude`, `opencode`, `pi`, or `all` (default: `all`) |
| `--output` | `-o` | Output directory (default: `.sessions`) |
| `--format` | `-f` | Export format: `markdown`, `json`, or `toon` (default: `markdown`) |
| `--workspace` | `-w` | Filter by workspace path (default: current directory) |
| `--branch` | `-b` | Filter by git branch |
| `--no-subagents` | | Exclude subagent sessions |
| `--no-tools` | | Exclude tool use and result messages |
| `--no-thinking` | | Exclude assistant thinking messages |
| `--no-attachments` | | Exclude file attachments |
| `--watch` | | Watch for changes and sync continuously |
| `--verbose` | `-v` | Enable debug logging |

### Examples

Export only main sessions without subagents:

```sh
sessionsync --no-subagents
```

Export without tool calls and thinking blocks:

```sh
sessionsync --no-tools --no-thinking
```

Export all Claude Code sessions to JSON:

```sh
sessionsync --agent claude --format json
```

## License

[MIT](LICENSE)
data-entry2 0.1.9
Tool for spreadsheet-like data entry in Jupyter notebooks
Requires Python: >=3.7

 # data_entry2.py

- A spreadsheet interface for data entry in Python/Jupyter 


Requires: ipydatagrid

To use:

      import data_entry2

      de = data_entry2.sheet("name")

This creates or loads name.csv and presents as a "live"
spreadsheet-like interface. This is for data entry only, no
 calculations are possible in the spreadsheet.

Put a # in front of a row to comment it out
Put a $ in front of a column name to comment out the column (useful for
non-numeric columns)

Simple expressions can be evaluated, eg: =1+3/np.sqrt(3)

Generate Vectors generates a series of arrays for each non-commented
column.

Two pandas data frames are also created:

- one is self.df that contains just the data in the vectors.
- the other, self.fdf is strings that has everything in the whole table.

To take a snapshot of a current sheet and generate a new one:
    de2 = data_entry2.sheet_copy("old", "new")

if new.csv exists, it gets loaded, if not, old.csv is copied to new.csv.

Add Row and Add Column do what they claim. To *remove* unwanted
empty rows and columns, just re-run the cell that sets up the
sheet. empty rows and columns will be deleted.

Copy & Paste only work for single cells.

To edit a cell - click and start typing. If you want to edit a current
value: try double clicking - doesn't always take, might need a few tries.
Or click and press F2.

After editing a cell, enter moves to next cell down, probably want Tab to
move to next cell to right. (shift tab goes left).

There is a top row of cell headers shown that allows: column
widths to be adjusted, and filters and sorting. Probably the
sorting and filters should not be available. Display of these
headers can be disabled by setting: header_visibility='row' in the
call to DataGrid, but then the widths can't be adjusted...
Can always restore the correct order by sorting key by ascending.
To make that work there are some extra spaces included in front of
the Variable and Units row headers

In order to help avoid disasterous data loss: every time Generate
Vectors is pressed, a snapshot of the current sheet is saved in
csv_backups (as long as it is different from the most recent
backup).  You can poke around in there and make copies of the
backups, rename them and move up to where the notebook can use it.

BUGS: the sheet will only render when the notebook is exported if
Settings->Auto Save Widget State is toggled on.

To output all sheets: call
   display_sheets()
As long as each sheet was created with a different variable name,
they will all be displayed.
soul-engine 0.1.0
The engine that powers intelligent agents.
Requires Python: >=3.10

# SoulEngine

**The engine that powers intelligent agents.**

SoulEngine is a lightweight, extensible, and powerful runtime kernel for building autonomous AI agents. It provides a robust foundation for task execution, state management, and intelligent routing.

## Installation

```bash
pip install soul-engine
```

## Usage

```python
import soulengine

print(soulengine.__version__)
```

## License

Apache 2.0
graphtec-api 1.0.0
Librería en Python para el control y adquisición de datos del Datalogger GL100
Requires Python: >=3.13

# Graphtec-API
```
Graphtec-API
├─ graphtec
│  ├─ api
│  │  ├─ public.py
│  │  └─ __init__.py
│  ├─ config
│  │  └─ config_manager.py
│  ├─ connection
│  │  ├─ base.py
│  │  ├─ serial_connection.py
│  │  ├─ usb_connection.py
│  │  ├─ wlan_connection.py
│  │  └─ __init__.py
│  ├─ core
│  │  ├─ commands.py
│  │  ├─ device
│  │  │  ├─ alarm.py
│  │  │  ├─ amp.py
│  │  │  ├─ base.py
│  │  │  ├─ common.py
│  │  │  ├─ data.py
│  │  │  ├─ file.py
│  │  │  ├─ interface.py
│  │  │  ├─ logic.py
│  │  │  ├─ measure.py
│  │  │  ├─ option.py
│  │  │  ├─ status.py
│  │  │  ├─ transfer.py
│  │  │  ├─ trigger.py
│  │  │  └─ __init__.py
│  │  ├─ exceptions.py
│  │  └─ __init__.py
│  ├─ io
│  │  ├─ capture.py
│  │  ├─ decoder.py
│  │  ├─ realtime.py
│  │  └─ __init__.py
│  ├─ utils
│  │  ├─ logger.py
│  │  ├─ utils.py
│  │  └─ __init__.py
│  ├─ _version.py
│  └─ __init__.py
├─ LICENSE
├─ main.py
├─ pytest.ini
├─ README.md
├─ requirements-dev.txt
├─ requirements.txt
└─ tests
   ├─ conftest.py
   ├─ integration
   │  └─ test_public_api.py
   ├─ mocks
   │  ├─ mock_connection.py
   │  └─ responses.py
   └─ unit
      ├─ test_amp.py
      ├─ test_common.py
      ├─ test_data.py
      ├─ test_logic.py
      ├─ test_option.py
      ├─ test_status.py
      └─ test_trigger.py

```
zip2tz 0.1.2
A simple timezone lookup by zip code
Requires Python: >=3.9

# zip2tz

Fast, zero-dependency US zip code to timezone lookup for Python.

- **38,000+ zip codes** mapped to IANA timezones
- **Zero dependencies** — pure Python, works everywhere
- **O(1) lookup** — instant hash table lookups, no database or file I/O
- **Tiny footprint** — ~100KB installed, loads in milliseconds
- **Type-annotated** — full type hints included

## Installation

```bash
pip install zip2tz
```

Or with [uv](https://docs.astral.sh/uv/):

```bash
uv add zip2tz
```

## Usage

```python
import zip2tz

# Get timezone for a zip code
tz = zip2tz.timezone("90210")
print(tz)  # America/Los_Angeles

tz = zip2tz.timezone("10001")
print(tz)  # America/New_York

# Works with integers too
tz = zip2tz.timezone(60601)
print(tz)  # America/Chicago

# Returns None if zip code not found
tz = zip2tz.timezone("00000")
print(tz)  # None
```

## Why zip2tz?

Most timezone lookup libraries require external databases, network calls, or heavy dependencies. `zip2tz` bakes the data directly into Python bytecode — just import and go.

| Feature | zip2tz | Other libraries |
|---------|--------|-----------------|
| Dependencies | 0 | Often requires `pytz`, databases, or APIs |
| Lookup speed | O(1) hash | Varies (file I/O, network, etc.) |
| Install size | ~100KB | Often MB+ |
| Offline | Yes | Sometimes requires network |

## API

### `timezone(zipcode: str | int) -> str | None`

Returns the IANA timezone string (e.g., `"America/New_York"`) for the given US zip code, or `None` if not found.

**Parameters:**
- `zipcode` — A 5-digit US zip code as a string or integer

**Returns:**
- IANA timezone string, or `None` if the zip code is not in the database

## Coverage

Covers all 50 US states plus DC, including:
- All continental US timezones
- Alaska (9 timezones)
- Hawaii
- Indiana's complex county-level timezone boundaries
- North Dakota's split counties

## Data Accuracy

This library provides timezone mappings on a **best-effort basis**. While we strive for accuracy, we make no guarantees that the data is complete or correct. Timezone boundaries can be complex (especially in states like Indiana and Arizona), and zip codes occasionally span multiple timezones.

If you find an incorrect mapping or missing zip code, please [open an issue](https://github.com/3S-LoPro/zip2tz/issues) with:
- The zip code in question
- The expected timezone
- A source for the correct mapping (if available)

## Contributing

Contributions are welcome! If you'd like to improve the data or code:

1. Fork the repository
2. Make your changes
3. Open a pull request

For data corrections, please include a reliable source for the timezone mapping.

## License

MIT License — see [LICENSE](LICENSE) for details.
arm-pyart 2.2.0
Py-ART: Python ARM Radar Toolkit
Requires Python: >=3.10

a growing collection of weather radar algorithms and utilities build on top of
the Scientific Python stack and distributed under the 3-Clause BSD license.
Py-ART is used by the Atmospheric Radiation Measurement (ARM) Climate Research
Facility for working with data from a number of precipitation and cloud radars,
but has been designed so that it can be used by others in the radar and
atmospheric communities to examine, processes, and analyse data from many types
of weather radars.