semvec/pypi-packages huggingface dataset:
spytial-diagramming 0.6.7
sPyTial: Spatial Python visualization with declarative constraints
License: MIT
Requires Python: >=3.8
Keywords: visualization, diagrams, spatial, constraints, data-structures

# sPyTial: Lightweight Diagrams for Structured Python Data

```
pip install spytial-diagramming
```


Sometimes you just want to see your data.

You’re working with a tree, a graph, a recursive object -- maybe an AST, a neural network, or a symbolic term. You don’t need an interactive dashboard or a production-grade visualization system. You just need a diagram, something that lays it out clearly so you can understand what’s going on.

That’s what `sPyTial` is for. It’s designed for developers, educators, and researchers who work with structured data and need to make that structure visible — to themselves or to others — with minimal effort. 

## Why Spatial Representation Matters

There’s strong evidence — from cognitive science, human-computer interaction, and decades of programming tool design — that **spatial representations help people understand structure**. When elements are placed meaningfully in space — grouped, aligned, oriented — we can spot patterns, detect errors, and reason more effectively. This idea shows up in research from Barbara Tversky, Larkin & Simon, and in the design of tools like Alloy and Scratch. 

`sPyTial` gives you that kind of spatial layout **by default**. When you visualize a Python object, the diagram reflects how the parts are connected, not just how they're stored. You get:
- A **box-and-arrow diagram** that shows the shape of your data
- A layout that follows cognitive and structural conventions
- A tool that knows when something doesn't make sense

## Quick Start

```python
import spytial

# Visualize any Python object
data = {
    'name': 'root',
    'children': [
        {'value': 1},
        {'value': 2},
        {'value': 3}
    ]
}

# Opens in browser or inline if in a jupyter notebook.
spytial.diagram(data)

# Or save to file
spytial.diagram(data, method='file')
```

## Documentation

User-facing documentation is available at https://sidprasad.github.io/spytial/ and is generated with MkDocs from the codebase and Markdown guides.


## License
This project is licensed under the MIT License. See the LICENSE file for details.
phoskhemia 0.1.5
Library for the handling and analysis of chemical spectroscopic data.
License: MIT
Requires Python: >=3.13

# PhosKhemia

A library for the handling and analysis of spectroscopic data.

## Use Cases

PhosKhemia is a library with routines and utilities for the analysis
of UV-Vis absorption spectra, steady-state fluorescence data,
nanosecond transient absorption spectra, time-correlated single-photon
counting, and various other spectra.

## Installation

```python
pip install phoskhemia
```

## Bugs and Feedback

As this library is still under construction, feel free to reach out if
there are any bugs, issues, or for general feedback.
signedshot 0.1.9
Validator for SignedShot media authenticity proofs
License: MIT
Requires Python: >=3.8
Keywords: signedshot, media, authenticity, validation, cryptography

# SignedShot

Verify SignedShot media authenticity proofs in Python.

[![PyPI](https://img.shields.io/pypi/v/signedshot)](https://pypi.org/project/signedshot/)

## Installation

```bash
pip install signedshot
```

## Quick Start

```python
import signedshot

# Validate from files
result = signedshot.validate_files("photo.sidecar.json", "photo.jpg")

print(result.valid)   # True if all checks pass
print(result.error)   # Error message if validation failed
```

## Usage

### Validate from Files

```python
result = signedshot.validate_files("photo.sidecar.json", "photo.jpg")
```

### Validate from Bytes

```python
with open("photo.sidecar.json") as f:
    sidecar_json = f.read()
with open("photo.jpg", "rb") as f:
    media_bytes = f.read()

result = signedshot.validate(sidecar_json, media_bytes)
```

### Validate with Pre-loaded JWKS

Avoid HTTP calls by providing JWKS directly:

```python
import requests

jwks = requests.get("https://api.signedshot.io/.well-known/jwks.json").text
result = signedshot.validate_with_jwks(sidecar_json, media_bytes, jwks)
```

## Validation Result

```python
result = signedshot.validate_files("photo.sidecar.json", "photo.jpg")

# Overall result
result.valid      # True/False
result.version    # Sidecar format version
result.error      # Error message (if any)

# Capture trust (JWT verification)
trust = result.capture_trust
trust["signature_valid"]   # JWT signature verified
trust["issuer"]            # API that issued the token
trust["publisher_id"]      # Publisher ID
trust["device_id"]         # Device ID
trust["capture_id"]        # Capture session ID
trust["method"]            # "sandbox", "app_check", or "app_attest"
trust["app_id"]            # App bundle ID (if attested)
trust["issued_at"]         # Unix timestamp

# Media integrity (content verification)
integrity = result.media_integrity
integrity["content_hash_valid"]   # SHA-256 hash matches
integrity["signature_valid"]      # ECDSA signature verified
integrity["capture_id_match"]     # Capture IDs match
integrity["content_hash"]         # SHA-256 of media
integrity["captured_at"]          # ISO8601 timestamp

# Export
result.to_dict()   # Convert to dictionary
result.to_json()   # Convert to JSON string
```

## What It Validates

1. **Capture Trust (JWT)**
   - Fetches JWKS from issuer
   - Verifies ES256 signature
   - Extracts attestation claims

2. **Media Integrity**
   - Computes SHA-256 of media
   - Verifies ECDSA signature
   - Confirms capture_id matches

## Links

- [Documentation](https://signedshot.io/docs)
- [GitHub](https://github.com/SignedShot/signedshot-validator)
- [Website](https://signedshot.io)

## License

MIT