semvec/pypi-packages huggingface dataset:
dosuby 1.6.7
A tool for enumerating subdomains of a parent domain
License: MIT
Requires Python: >=3.10
Keywords: subdomain enumeration security network

# Dosuby

Dosuby is a tool developed in Python that aims to enumerate subdomains of a parent domain. It uses multiple techniques for enumeration, allowing for a comprehensive subdomain scan. Additionally, Dosuby has the option to scan the enumerated domains.

## Installation

```bash
pip install dosuby
```

## Quick Start

Run the tool simply by typing:

```bash
dosuby
```

## Features

- Multiple subdomain enumeration techniques
- Comprehensive domain scanning
- Easy-to-use CLI interface

## Screenshots

Due to PyPI markdown limitations, screenshots are best viewed on the project's GitHub repository:

[View Project Screenshots](https://github.com/deidax/dosuby)

## Usage Example

When you run `dosuby`, you'll be presented with an interactive interface to perform subdomain enumeration.

## Contributing

Contributions are welcome!

If you find a bug or would like to suggest a new feature:

1. Open an issue on GitHub
2. Submit a pull request

## License

This project is licensed under the MIT License.

See the LICENSE file for full details.

## Contact

- GitHub: [deidax/dosuby](https://github.com/deidax/dosuby)
- Email: deidaxtech@gmail.com
ensure-shebang-runtime 0.4.0
Re-executes Python scripts under the interpreter specified in the shebang line.
License: MIT
Requires Python: >=3.6

# ensure-shebang-runtime

A lightweight helper to re-execute a Python script using the interpreter defined in its shebang (`#!`) line — even if it was run via `python script.py`.

## Usage

```python
import ensure_shebang_runtime
ensure_shebang_runtime.reexec_with_shebang(__file__)
# === Your actual logic starts here including imports ===
cookie-api 0.3.0
An API wrapper for the Cookie API
License: MIT
Requires Python: >=3.9
Keywords: discord, bot, cookie, api

# Cookie API
[![](https://img.shields.io/pypi/v/cookie-api.svg?style=for-the-badge&logo=pypi&color=yellow&logoColor=white)](https://pypi.org/project/cookie-api/)
[![](https://img.shields.io/pypi/l/cookie-api?style=for-the-badge&color=5865F2)](https://github.com/tibue99/cookie-api/blob/main/LICENSE)
[![](https://img.shields.io/readthedocs/cookie-api?style=for-the-badge)](https://cookie-api.readthedocs.io/)
[![](https://img.shields.io/badge/Cookie-Website-orange?style=for-the-badge)](https://cookieapp.me/)

Official wrapper for the [Cookie](https://cookieapp.me) API.

## ⚙️ Installation
Python 3.9 or higher is required
```
pip install cookie-api
```

## 🔑 How to get an API key?
1. Invite [Cookie](https://cookieapp.me) to your Discord server or to your Discord account
2. Run `/premium api`

## 🚀 Example Usage
The API key can be passed as a parameter or set as the environment variable `COOKIE_KEY`.
For more information, see to our [documentation](https://cookie-api.readthedocs.io/).

### Sync Example
```python
from cookie import CookieAPI

api = CookieAPI(api_key="[YOUR_API_KEY]")

user_stats = api.get_user_stats(123456789)  # Replace with user ID
```
### Async Example
```python
import asyncio
from cookie import AsyncCookieAPI

api = AsyncCookieAPI(api_key="[YOUR_API_KEY]")

async def main():
    user_stats = await api.get_user_stats(123456789)  # Replace with user ID
    await api.close()

asyncio.run(main())
```
You can also use an asynchronous context manager (recommended)
```python
async def main():
    async with api as con:
        user_stats = await con.get_user_stats(123456789)  # Replace with user ID
```

## ⚡ OpenAPI Docs
If you want to use the API without this wrapper, you can find the OpenAPI docs [here](https://api.cookieapp.me/docs).

The models in this package are automatically generated using the OpenAPI spec:
```
python cookie/_internal/model_generator.py
```
borg-encryption 1.0.0
Borg Encryption System - A multi-layered, adaptive encryption system
License: MIT
Requires Python: >=3.8
Keywords: encryption, security, cryptography, api

# Borg Encryption System

A multi-layered, adaptive encryption system inspired by the Borg from Star Trek. This system uses multiple encryption algorithms in sequence, including post-quantum resistant algorithms, to create an extremely secure encryption mechanism.

## Features

- **Multi-layered encryption** (cascading ciphers)
- **Post-quantum resistant algorithms**
- **Adaptive security measures**
- **Key rotation**
- **Side-channel attack protections**
- **Secure memory management**
- **REST API** for easy integration

## Installation

```bash
pip install borg-encryption
```

## Quick Start

### Command Line Usage

```bash
# Encrypt a text message
borg-encrypt encrypt --text "Resistance is futile" --key "your-password" --local

# Decrypt a text message
borg-encrypt decrypt --file encrypted.txt --key "your-password" --local

# Encrypt a file
borg-encrypt encrypt-file --file secret.pdf --key "your-password" --output secret.encrypted --local

# Decrypt a file
borg-encrypt decrypt-file --file secret.encrypted --key "your-password" --output secret.pdf --local

# Start the API server
borg-encrypt server --port 8000
```

### Python API Usage

```python
from borg_encryption import BorgEncryption

# Create an encryption instance
borg = BorgEncryption("your-password")

# Encrypt data
message = "Resistance is futile. Your biological and technological distinctiveness will be added to our own."
encrypted = borg.encrypt(message)

# Decrypt data
decrypted = borg.decrypt_to_string(encrypted)
print(decrypted)  # Should print the original message
```

### REST API Usage

```python
from borg_encryption.client import BorgAPIClient

# Create a client
client = BorgAPIClient("http://localhost:8000", "your-api-key")

# Encrypt a message
encrypted = client.encrypt_text("Resistance is futile", "your-password")

# Decrypt a message
decrypted = client.decrypt_text(encrypted, "your-password")
```

## Security Features

- **Multi-layered encryption**: Uses AES-GCM, ChaCha20-Poly1305, and XSalsa20-Poly1305 in sequence
- **Secure key derivation**: Uses PBKDF2 and Scrypt with high iteration counts
- **Adaptive defense**: Monitors for attacks and adapts security parameters
- **Secure memory management**: Clears sensitive data from memory when no longer needed
- **Side-channel attack protections**: Implements timing attack countermeasures

## License

MIT License