semvec/pypi-packages huggingface dataset:
hasse-diagram 1.2
Plot Hasse Diagram in Python
Requires Python: >=3.10

# Hasse Diagram

This small package helps with plotting Hasse Diagrams and is very useful when presenting results for the MCDA methods.

## Installation

```
pip install hasse-diagram
```

## Example usage

### Networkx

```python
import numpy as np
from hassediagram import plot_hasse

data = np.array([
    [0, 1, 1, 1, 1],
    [0, 0, 1, 0, 1],
    [0, 1, 0, 0, 1],
    [0, 0, 0, 0, 0],
    [0, 0, 0, 0, 0]
])
labels = ["node a", "node b", "node c", "node d", "node e"]
plot_hasse(data, labels)
```

Result:

![img.png](./images/example_plot1.png)

- ### Graphviz dotstring

```python
import numpy as np
from hassediagram import hasse_graphviz

data = np.array([
    [0, 1, 1, 1, 1],
    [0, 0, 1, 0, 1],
    [0, 1, 0, 0, 1],
    [0, 0, 0, 0, 0],
    [0, 0, 0, 0, 0]
])
labels = ["node a", "node b", "node c", "node d", "node e"]
print(hasse_graphviz(data, labels))
```

Result:

```
digraph {
	graph [bgcolor="#FFFFFF"]
	node [color="#E2E8F0" fontname="Segoe UI" fontsize="15 pt" style=filled]
	edge [arrowhead=vee color=black]
	compound=true
	node1 [label="node a"]
	node2 [label="node b, node c"]
	node3 [label="node d"]
	node4 [label="node e"]
	node1 -> node2
	node1 -> node3
	node2 -> node4
	subgraph cluster_1 {
		rank=same
		peripheries=0
	}
	subgraph cluster_2 {
		rank=same
		node1
		peripheries=0
	}
	subgraph cluster_3 {
		rank=same
		node2
		node3
		peripheries=0
	}
	subgraph cluster_4 {
		rank=same
		node4
		peripheries=0
	}
}
```

You can optionally turn off the transitive reduction and change the color of nodes and edges.

## Testing

```
pytest --cov=src --cov-report=term-missing
```

This package is inspired by a similar one for R: [hasseDiagram](https://github.com/kciomek/hasseDiagram)
warborne 1.0.0
A simple hashing library based on vowel counting
Requires Python: >=3.7

# WarBorne

A simple hashing library that generates hashes based on vowel counting.

## Installation
```bash
pip install warborne
```
## Usage

```python
from warborne import WarBorne

# Create a WarBorne instance
wb = WarBorne()

# Hash a string
hash_value = wb.hash("Hello, World!")
print(hash_value)

# Hash a file
file_hash = wb.hash_file("path/to/file.txt")
print(file_hash)
```

## License MIT
verify-crypto-signature 0.0.1
A comprehensive Python library to verify crypto wallet signatures
Requires Python: >=3.7
Keywords: verify, crypto, signature, wallet, blockchain, solana, ethereum, cryptography

# Verify Crypto Signature

A Python library for verifying and working with cryptographic signatures, currently supporting EVM and Solana blockchain signatures.

## Features

- Verify message signatures from EVM and Solana addresses
- Sign messages using private keys
- Recover wallet addresses from signatures (Only supports EVM)
- Validate EVM and Solana addresses

## Installation

```bash
pip install verify-crypto-signature
```

## Dependencies

- eth_account
- eth_utils
- eth_keys
- solders

## Usage

### Verifying an EVM Signature

```python
from verify_crypto_signature.evm import VerifyEVM

# Verify if a message was signed by a specific address
wallet_address = "0x..."  # Example address
message = "Hello, world!"
signature = "0x..."  # Signature obtained from the wallet

# Verify the signature
is_valid = VerifyEVM.verify_signature(wallet_address, message, signature)
if is_valid:
    print("Signature is valid")
else:
    print("Signature is invalid")
```

### Signing a Message

```python
from verify_crypto_signature.evm import VerifyEVM

# Sign a message with a private key
private_key = "0x..."  # Your private key (keep this secret!)
message = "Hello, world!"

# Sign the message
signed_message = VerifyEVM.sign_message(message, private_key)
signature = signed_message.signature.hex()
print(f"Signature: {signature}")
```

### Recovering an Address from a Signature (Only supports EVM)

```python
from verify_crypto_signature.evm import VerifyEVM

# Recover the signer's address
message = "Hello, world!"
signature = "0x..."  # The signature

address = VerifyEVM.get_address_from_message(message, signature=signature)
print(f"Signer address: {address}")
```

### Verifying a Solana Signature

```python
from verify_crypto_signature.sol import VerifySOL

# Verify if a message was signed by a specific address
wallet_address = "5yQ6...."  # Example address
message = "Hello, world!"
signature = "4K2...."  # Signature obtained from the wallet

# Verify the signature
is_valid = VerifySOL.verify_signature(wallet_address, message, signature)
```

### Signing a Message

```python
from verify_crypto_signature.sol import VerifySOL

# Sign a message with a private key
private_key = "4K2...."  # Your private key (keep this secret!)
message = "Hello, world!"

# Sign the message
signed_message = VerifySOL.sign_message(message, private_key)
```
## License

[MIT License](LICENSE)

## Contributing

Contributions are welcome! Please feel free to submit a Pull Request.
pyclothoids 0.2.0
A library for clothoid curves in Python

# pyclothoids
A Python library for clothoid curves

[Read the Documentation!](https://pyclothoids.readthedocs.io/en/latest/)

Clothoid curves have some remarkable mathematical properties that make them desirable for use in many areas of physics and engineering.  Not only is a clothoid parameterized by arc length, but it has closed form expressions for its tangent angle and curvature.  These remarkable properties come at a cost.  The cartesian coordinates of a clothoid can only be expressed in closed form in terms of the Fresnel integrals, and cannot in general be evaluated exactly.  

There has been significant research into numerical algorithms to evaluate, construct, and manipulate these curves.  Software packages exist for this purpose but are often difficult to master.  This package takes a different approach, aiming to be easy to pick up and experiment with.  The ultimate goal is to provide a simple, intuitive, and pythonic interface to state of the art numerical software that allows you to leverage the latest research without the learning curve.

If you have a problem that you think could be solved using clothoid curves, this package aims to handle all the complexities of clothoid geometry for you so that you can focus on the top level problem you are trying to solve.  

That said, clothoid curves aren't always well behaved, and there are many other simpler curves that are far easier to understand and manipulate.  Before you use this library for a project, be sure that other simpler geometric constructs such as B-splines will not fulfill your needs.

The main design goals of pyclothoids are minimalism and simplicity.  For that reason, the top level API for this module consists of only one class - Clothoid.  To prevent common errors and further simplify the interface, Clothoid was designed to be immutable from the top level.  This means any methods that transform a Clothoid will return a new Clothoid with the desired modifications while leaving the original Clothoid intact.
shapesqr 0.0.3
This is a test task module for shapes square calculation.
Requires Python: >=3.10

# Shape Square Calculation Library #

## What is this? ##
The test task which should calculate square of circle by its radius and triangle by its sides.

## Quick Guide ##
Set up the library

```
pip install shapesqr
```

Then import ShapeFabric from the library and pass into its constructor a tuple, containing one or three integers or floats.

```
from shapesqr import ShapeFabric


circle = ShapeFabric().get_shape((1.0,))

triangle = ShapeFabric().get_shape((4, 3, 5))
```


----------


### Using ###


Using the library is as simple and convenient as possible:

```
    from shapesqr import ShapeFabric


    circle = ShapeFabric().get_shape((1.0,))
    circle.get_shape_type()  # "circle"
    
    circle.calculate_square()
    status, result = shape.get_calculated_result()  # 1 - for OK, -1 - for NOK, 0 - default
```


----------


## Developer ##
My site: [link](https://github.com/DmitriyReztsov)