semvec/pypi-packages huggingface dataset:
SafeSeal 1.1.0
A multi-layered encryption and decryption library in Python.
Requires Python: >=3.6

# SafeSeal

**SafeSeal** is a Python encryption library that securely encrypts and decrypts data using multiple layers of encoding and compression.

## 🚀 Features
- Multi-layered encryption: `pickle` → `marshal` → `base64` → `zlib` → `gzip`
- Multi-layered decryption: `gzip` → `zlib` → `base64` → `marshal` → `pickle`
- Simple and Pythonic API
- Handles errors gracefully

## 🔧 Installation

Install SafeSeal using pip:

```bash
pip install SafeSeal
```

Or clone the repository:

```bash
git clone https://github.com/Altikrity/SafeSeal.git
cd SafeSeal
python setup.py install
```

## 📦 Usage

### Import SafeSeal

```python
from SafeSeal import Cencrypt, Cdecrypt
```

### Encrypt Data

```python
data = "Hello, SafeSeal!"
encrypted_data = Cencrypt(data)
print(f"Encrypted: {encrypted_data}")
```

### Decrypt Data

```python
decrypted_data = Cdecrypt(encrypted_data)
print(f"Decrypted: {decrypted_data}")
```

## 🔍 Example

```python
from SafeSeal import Cencrypt, Cdecrypt

# Original data
data = "This is a secret message."

# Encrypt the data
encrypted = Cencrypt(data)
print("Encrypted Data:", encrypted)

# Decrypt the data
decrypted = Cdecrypt(encrypted)
print("Decrypted Data:", decrypted)
```

## ⚠️ Notes
- This library is designed for obfuscation and lightweight encryption.
- `marshal` is Python-version-dependent, so encrypted data may not be compatible across different Python versions.
- Not recommended for high-security applications — for that, consider using `cryptography` or `pycryptodome`.

## 🛠️ Contributing
Pull requests are welcome! For major changes, please open an issue first to discuss what you’d like to change.

## 📜 License
This project is licensed under the MIT License.

---

✨ Built with ❤️ by Abdullah.

---

Ready to keep your secrets safe? Seal them with **SafeSeal**! 🔐
ip2cidr 0.1.0
A tool to convert IP addresses to /24 CIDR notation
Requires Python: >=3.8

# ip2cidr

A Python tool to convert IP addresses to /24 CIDR notation.

## Installation

```bash
pip install ip2cidr
```

## Usage

The tool can be used from the command line:

```bash
# Convert a single IP
ip2cidr -i "10.200.2.132"

# Convert multiple IPs (comma-separated)
ip2cidr -i "10.200.2.132,192.168.1.100,172.16.5.200"

# Use a different separator for output (default is comma)
ip2cidr -i "10.200.2.132,192.168.1.100" -s " "
```

### Arguments

- `-i, --ips`: Required. Comma-separated list of IP addresses to convert
- `-s, --separator`: Optional. Output separator (default: comma)

### Example Output

```bash
$ ip2cidr -i "10.200.2.132,192.168.1.100,172.16.5.200"
10.200.2.0/24,172.16.5.0/24,192.168.1.0/24

$ ip2cidr -i "10.200.2.132,192.168.1.100" -s " "
10.200.2.0/24 192.168.1.0/24
```

## Python Usage

You can also use the tool in your Python code:

```python
from ip_converter import ip_to_cidr

# Convert IPs to CIDR
ips = "10.200.2.132,192.168.1.100"
cidrs = ip_to_cidr(ips)
print(cidrs)  # ['10.200.2.0/24', '192.168.1.0/24']
```

## Development

### Running Tests

To run the tests, first install the development dependencies:

```bash
pip install -e ".[test]"
```

Then run the tests with pytest:

```bash
pytest
```

This will run all tests and generate a coverage report. The tests cover various scenarios including:
- Single IP conversion
- Multiple IP conversion
- Duplicate network handling
- Invalid IP handling
- Empty input
- Whitespace handling
- Partial IP addresses
- Special IP addresses (localhost, etc.)

## Features

- Converts IP addresses to their corresponding /24 CIDR networks
- Handles multiple IP addresses
- Removes duplicates and sorts the output
- Customizable output separator
- Error handling for invalid IP addresses
- Comprehensive test suite with 100% coverage

## Requirements

- Python 3.8 or higher
- argparse>=1.4.0

## License

MIT License
notionize 0.2.4
Add your description here
Requires Python: >=3.10

# Notionize

A Python library for converting Markdown text to Notion blocks.

## Description

Notionize is a tool that helps you transform Markdown text into Notion-compatible blocks, making it easy to integrate your Markdown content with the Notion API.

## Installation

```bash
pip install notionize
```

## Usage

````python
from notionize import notionize

markdown = """# Main Heading

This is a paragraph with formatting and a [link](https://example.com).

> Here's a blockquote
> With multiple lines

- List item 1
  - Nested item
- List item 2

```python
def hello_world():
    print("Hello World!")
```

| Header 1 | Header 2 |
| -------- | -------- |
| Cell 1   | Cell 2   |

"""

notion_blocks = notionize(markdown)

````

## Contributing

Contributions are welcome! Please feel free to submit a Pull Request.

## License

This project is licensed under the MIT License - see the LICENSE file for details.
sunsoft-utils 0.1.0
Shared utilities for Sunsoft packages
Requires Python: >=3.8

# sunsoft-utils

Shared utilities for Sunsoft packages.

## Installation

```bash
pip install sunsoft-utils
```

## Usage

### Download Tracking

```python
from sunsoft import send_first_run_stats

def main():
    # Send first run statistics
    send_first_run_stats(
        script_name='your-package-name',
        version='1.0.0'
    )

    # Your code here...
```

### Features

- Anonymous download tracking
- First-run detection
- Version tracking
- Support for `--no-track-install` flag
- Colored console output

### Configuration

The tracking data is stored in `~/.sunsoft.json` and includes:
- First run date
- Registration date
- Version information
- Installation status

## Requirements

- Python 3.8 or higher
- requests>=2.32.3
- termcolor>=2.3.0

## License

MIT License