lemonade-cryptography 1.0.0__tar.gz

lemonade_cryptography-1.0.0/LICENSE

@@ -0,0 +1,19 @@
+MIT License
+
+Copyright 2026 Vlinho
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the “Software”), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

lemonade_cryptography-1.0.0/PKG-INFO

@@ -0,0 +1,225 @@
+Metadata-Version: 2.4
+Name: lemonade-cryptography
+Version: 1.0.0
+Summary: Lightweight byte-oriented encryption library.
+Author: Vlinho
+License: MIT License
+        
+        Copyright 2026 Vlinho
+        
+        Permission is hereby granted, free of charge, to any person obtaining a copy
+        of this software and associated documentation files (the “Software”), to deal
+        in the Software without restriction, including without limitation the rights
+        to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+        copies of the Software, and to permit persons to whom the Software is
+        furnished to do so, subject to the following conditions:
+        The above copyright notice and this permission notice shall be included in all
+        copies or substantial portions of the Software.
+        THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+        IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+        FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+        AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+        LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+        OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+        SOFTWARE.
+Keywords: cryptography,encryption,experimental
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# 🍋 Lemonade Cryptography
+
+**Lemonade Cryptography** is a lightweight byte-oriented encryption library based on modular arithmetic and symmetric key transformations.
+
+Lemonade transforms readable messages into encrypted data by converting text into bytes and applying mathematical operations using a cryptographic key.
+
+The core concept is:
+
+> Each byte of the message is encrypted by subtracting it from a corresponding byte of a secret key.
+
+The original message can be recovered by applying the reverse operation using the same key.
+
+---
+
+# Installation
+
+Install Lemonade Cryptography using pip:
+
+```bash
+pip install lemonade-cryptography
+```
+
+---
+
+# Quick Start
+
+```python
+from lemonade import encrypt, decrypt
+
+message = "Hello. We are looking for highly intelligent individuals."
+
+crypt, key = encrypt(message)
+
+print("Encrypted:")
+print(crypt)
+
+print("\nKey:")
+print(key)
+
+original = decrypt(crypt, key)
+
+print("\nDecrypted:")
+print(original)
+```
+
+Output:
+
+```
+Encrypted:
+<encrypted data>
+
+Key:
+<secret key>
+
+Decrypted:
+Hello. We are looking for highly intelligent individuals.
+```
+
+---
+
+# Features
+
+- Symmetric key encryption
+- Byte-oriented processing
+- UTF-8 message support
+- Random cryptographic key generation
+- Base64 encoded output
+- Simple Python API
+- Lightweight implementation
+
+---
+
+# API Reference
+
+## `encrypt()`
+
+```python
+encrypt(msg: str) -> tuple[str, str]
+```
+
+Encrypts a message and generates a random key.
+
+### Arguments
+
+| Argument | Type | Description |
+|-|-|-|
+| `msg` | `str` | Message to encrypt |
+
+### Returns
+
+A tuple containing:
+
+```python
+(
+    encrypted_message,
+    encryption_key
+)
+```
+
+Both values are encoded using Base64.
+
+Example:
+
+```python
+crypt, key = encrypt("Hello")
+```
+
+---
+
+## `decrypt()`
+
+```python
+decrypt(crypt: str, key: str) -> str
+```
+
+Decrypts a Lemonade encrypted message using its key.
+
+### Arguments
+
+| Argument | Type | Description |
+|-|-|-|
+| `crypt` | `str` | Encrypted message in Base64 |
+| `key` | `str` | Encryption key in Base64 |
+
+### Returns
+
+The original message:
+
+```python
+str
+```
+
+Example:
+
+```python
+message = decrypt(crypt, key)
+```
+
+---
+
+# How It Works
+
+Lemonade operates directly on byte values.
+
+Example:
+
+```
+A = 65
+B = 66
+C = 67
+```
+
+The encryption operation is:
+
+```
+C = (M - K) mod 256
+```
+
+Where:
+
+| Symbol | Meaning |
+|-|-|
+| `C` | Encrypted byte |
+| `M` | Original message byte |
+| `K` | Key byte |
+
+The decryption operation reverses the transformation:
+
+```
+M = (C + K) mod 256
+```
+
+More technical details can be found in:
+
+```
+docs/algorithm.md
+```
+
+---
+
+# Security Notice
+
+Lemonade Cryptography is an experimental encryption library created for educational purposes and lightweight applications.
+
+It is not intended to replace modern cryptographic standards such as AES or ChaCha20 in security-critical systems.
+
+Always protect your encryption keys. Without the correct key, encrypted messages cannot be recovered.
+
+---
+
+# License
+
+Lemonade Cryptography is licensed under the MIT License.

lemonade_cryptography-1.0.0/README.md

@@ -0,0 +1,193 @@
+# 🍋 Lemonade Cryptography
+
+**Lemonade Cryptography** is a lightweight byte-oriented encryption library based on modular arithmetic and symmetric key transformations.
+
+Lemonade transforms readable messages into encrypted data by converting text into bytes and applying mathematical operations using a cryptographic key.
+
+The core concept is:
+
+> Each byte of the message is encrypted by subtracting it from a corresponding byte of a secret key.
+
+The original message can be recovered by applying the reverse operation using the same key.
+
+---
+
+# Installation
+
+Install Lemonade Cryptography using pip:
+
+```bash
+pip install lemonade-cryptography
+```
+
+---
+
+# Quick Start
+
+```python
+from lemonade import encrypt, decrypt
+
+message = "Hello. We are looking for highly intelligent individuals."
+
+crypt, key = encrypt(message)
+
+print("Encrypted:")
+print(crypt)
+
+print("\nKey:")
+print(key)
+
+original = decrypt(crypt, key)
+
+print("\nDecrypted:")
+print(original)
+```
+
+Output:
+
+```
+Encrypted:
+<encrypted data>
+
+Key:
+<secret key>
+
+Decrypted:
+Hello. We are looking for highly intelligent individuals.
+```
+
+---
+
+# Features
+
+- Symmetric key encryption
+- Byte-oriented processing
+- UTF-8 message support
+- Random cryptographic key generation
+- Base64 encoded output
+- Simple Python API
+- Lightweight implementation
+
+---
+
+# API Reference
+
+## `encrypt()`
+
+```python
+encrypt(msg: str) -> tuple[str, str]
+```
+
+Encrypts a message and generates a random key.
+
+### Arguments
+
+| Argument | Type | Description |
+|-|-|-|
+| `msg` | `str` | Message to encrypt |
+
+### Returns
+
+A tuple containing:
+
+```python
+(
+    encrypted_message,
+    encryption_key
+)
+```
+
+Both values are encoded using Base64.
+
+Example:
+
+```python
+crypt, key = encrypt("Hello")
+```
+
+---
+
+## `decrypt()`
+
+```python
+decrypt(crypt: str, key: str) -> str
+```
+
+Decrypts a Lemonade encrypted message using its key.
+
+### Arguments
+
+| Argument | Type | Description |
+|-|-|-|
+| `crypt` | `str` | Encrypted message in Base64 |
+| `key` | `str` | Encryption key in Base64 |
+
+### Returns
+
+The original message:
+
+```python
+str
+```
+
+Example:
+
+```python
+message = decrypt(crypt, key)
+```
+
+---
+
+# How It Works
+
+Lemonade operates directly on byte values.
+
+Example:
+
+```
+A = 65
+B = 66
+C = 67
+```
+
+The encryption operation is:
+
+```
+C = (M - K) mod 256
+```
+
+Where:
+
+| Symbol | Meaning |
+|-|-|
+| `C` | Encrypted byte |
+| `M` | Original message byte |
+| `K` | Key byte |
+
+The decryption operation reverses the transformation:
+
+```
+M = (C + K) mod 256
+```
+
+More technical details can be found in:
+
+```
+docs/algorithm.md
+```
+
+---
+
+# Security Notice
+
+Lemonade Cryptography is an experimental encryption library created for educational purposes and lightweight applications.
+
+It is not intended to replace modern cryptographic standards such as AES or ChaCha20 in security-critical systems.
+
+Always protect your encryption keys. Without the correct key, encrypted messages cannot be recovered.
+
+---
+
+# License
+
+Lemonade Cryptography is licensed under the MIT License.

lemonade_cryptography-1.0.0/lemonade/__init__.py

@@ -0,0 +1,9 @@
+from .crypto import encrypt, decrypt
+from .version import __version__
+
+__all__ = [
+    "encrypt",
+    "decrypt",
+    "__version__"
+]
+

lemonade_cryptography-1.0.0/lemonade/crypto.py

@@ -0,0 +1,112 @@
+import base64
+import binascii
+import secrets
+
+from . import exceptions as e
+
+
+def encrypt(msg: str) -> tuple[str, str]:
+    """Encrypts a message using Lemonade Encryption.
+
+    Generates a random key with the same byte length as the message.
+
+    Args:
+        msg (str): Text to be encrypted.
+
+    Returns:
+        tuple[str, str]: Encrypted message and its key.
+
+    Raises:
+        LemonadeError: When the message is invalid.
+    """
+
+    if not isinstance(msg, str):
+        raise e.LemonadeError("Message must be a string.")
+
+    try:
+        msg_bytes = msg.encode("utf-8")
+    except UnicodeEncodeError as error:
+        raise e.LemonadeError(
+            "Unable to encode message as UTF-8."
+        ) from error
+
+    key_bytes = secrets.token_bytes(len(msg_bytes))
+
+    crypt_bytes = bytes(
+        (msg_bytes[i] - key_bytes[i]) % 256
+        for i in range(len(msg_bytes))
+    )
+
+    crypt = base64.b64encode(crypt_bytes).decode("ascii")
+    key = base64.b64encode(key_bytes).decode("ascii")
+
+    return crypt, key
+
+
+def decrypt(crypt: str, key: str) -> str:
+    """Decrypts a Lemonade encrypted message.
+
+    Args:
+        crypt (str): Encrypted message in Base64.
+        key (str): Encryption key in Base64.
+
+    Returns:
+        str: Decrypted original message.
+
+    Raises:
+        InvalidCipherError: When the encrypted message is invalid.
+        InvalidKeyError: When the key is invalid.
+        LemonadeError: When decryption fails.
+    """
+
+    if not isinstance(crypt, str):
+        raise e.InvalidCipherError(
+            "Cipher must be a string."
+        )
+
+    if not isinstance(key, str):
+        raise e.InvalidKeyError(
+            "Key must be a string."
+        )
+
+    try:
+        crypt_bytes = base64.b64decode(
+            crypt,
+            validate=True
+        )
+    except (binascii.Error, ValueError) as error:
+        raise e.InvalidCipherError(
+            "Invalid cryptography."
+        ) from error
+
+    try:
+        key_bytes = base64.b64decode(
+            key,
+            validate=True
+        )
+    except (binascii.Error, ValueError) as error:
+        raise e.InvalidKeyError(
+            "Invalid encryption key."
+        ) from error
+
+    if len(key_bytes) != len(crypt_bytes):
+        raise e.InvalidKeyError(
+            "Encryption key length does not match cipher length."
+        )
+
+    try:
+        msg_bytes = bytes(
+            (crypt_bytes[i] + key_bytes[i]) % 256
+            for i in range(len(crypt_bytes))
+        )
+    except IndexError as error:
+        raise e.LemonadeError(
+            "Error while decrypting cipher."
+        ) from error
+
+    try:
+        return msg_bytes.decode("utf-8")
+    except UnicodeDecodeError as error:
+        raise e.LemonadeError(
+            "Decrypted data is not valid UTF-8."
+        ) from error

lemonade_cryptography-1.0.0/lemonade/exceptions.py

@@ -0,0 +1,10 @@
+class LemonadeError(Exception):
+    pass
+
+
+class InvalidKeyError(LemonadeError):
+    pass
+
+
+class InvalidCipherError(LemonadeError):
+    pass

lemonade_cryptography-1.0.0/lemonade/version.py

@@ -0,0 +1 @@
+__version__ = "1.0.0"

lemonade_cryptography-1.0.0/lemonade_cryptography.egg-info/PKG-INFO

@@ -0,0 +1,225 @@
+Metadata-Version: 2.4
+Name: lemonade-cryptography
+Version: 1.0.0
+Summary: Lightweight byte-oriented encryption library.
+Author: Vlinho
+License: MIT License
+        
+        Copyright 2026 Vlinho
+        
+        Permission is hereby granted, free of charge, to any person obtaining a copy
+        of this software and associated documentation files (the “Software”), to deal
+        in the Software without restriction, including without limitation the rights
+        to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+        copies of the Software, and to permit persons to whom the Software is
+        furnished to do so, subject to the following conditions:
+        The above copyright notice and this permission notice shall be included in all
+        copies or substantial portions of the Software.
+        THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+        IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+        FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+        AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+        LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+        OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+        SOFTWARE.
+Keywords: cryptography,encryption,experimental
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# 🍋 Lemonade Cryptography
+
+**Lemonade Cryptography** is a lightweight byte-oriented encryption library based on modular arithmetic and symmetric key transformations.
+
+Lemonade transforms readable messages into encrypted data by converting text into bytes and applying mathematical operations using a cryptographic key.
+
+The core concept is:
+
+> Each byte of the message is encrypted by subtracting it from a corresponding byte of a secret key.
+
+The original message can be recovered by applying the reverse operation using the same key.
+
+---
+
+# Installation
+
+Install Lemonade Cryptography using pip:
+
+```bash
+pip install lemonade-cryptography
+```
+
+---
+
+# Quick Start
+
+```python
+from lemonade import encrypt, decrypt
+
+message = "Hello. We are looking for highly intelligent individuals."
+
+crypt, key = encrypt(message)
+
+print("Encrypted:")
+print(crypt)
+
+print("\nKey:")
+print(key)
+
+original = decrypt(crypt, key)
+
+print("\nDecrypted:")
+print(original)
+```
+
+Output:
+
+```
+Encrypted:
+<encrypted data>
+
+Key:
+<secret key>
+
+Decrypted:
+Hello. We are looking for highly intelligent individuals.
+```
+
+---
+
+# Features
+
+- Symmetric key encryption
+- Byte-oriented processing
+- UTF-8 message support
+- Random cryptographic key generation
+- Base64 encoded output
+- Simple Python API
+- Lightweight implementation
+
+---
+
+# API Reference
+
+## `encrypt()`
+
+```python
+encrypt(msg: str) -> tuple[str, str]
+```
+
+Encrypts a message and generates a random key.
+
+### Arguments
+
+| Argument | Type | Description |
+|-|-|-|
+| `msg` | `str` | Message to encrypt |
+
+### Returns
+
+A tuple containing:
+
+```python
+(
+    encrypted_message,
+    encryption_key
+)
+```
+
+Both values are encoded using Base64.
+
+Example:
+
+```python
+crypt, key = encrypt("Hello")
+```
+
+---
+
+## `decrypt()`
+
+```python
+decrypt(crypt: str, key: str) -> str
+```
+
+Decrypts a Lemonade encrypted message using its key.
+
+### Arguments
+
+| Argument | Type | Description |
+|-|-|-|
+| `crypt` | `str` | Encrypted message in Base64 |
+| `key` | `str` | Encryption key in Base64 |
+
+### Returns
+
+The original message:
+
+```python
+str
+```
+
+Example:
+
+```python
+message = decrypt(crypt, key)
+```
+
+---
+
+# How It Works
+
+Lemonade operates directly on byte values.
+
+Example:
+
+```
+A = 65
+B = 66
+C = 67
+```
+
+The encryption operation is:
+
+```
+C = (M - K) mod 256
+```
+
+Where:
+
+| Symbol | Meaning |
+|-|-|
+| `C` | Encrypted byte |
+| `M` | Original message byte |
+| `K` | Key byte |
+
+The decryption operation reverses the transformation:
+
+```
+M = (C + K) mod 256
+```
+
+More technical details can be found in:
+
+```
+docs/algorithm.md
+```
+
+---
+
+# Security Notice
+
+Lemonade Cryptography is an experimental encryption library created for educational purposes and lightweight applications.
+
+It is not intended to replace modern cryptographic standards such as AES or ChaCha20 in security-critical systems.
+
+Always protect your encryption keys. Without the correct key, encrypted messages cannot be recovered.
+
+---
+
+# License
+
+Lemonade Cryptography is licensed under the MIT License.

lemonade_cryptography-1.0.0/lemonade_cryptography.egg-info/SOURCES.txt

@@ -0,0 +1,12 @@
+LICENSE
+README.md
+pyproject.toml
+lemonade/__init__.py
+lemonade/crypto.py
+lemonade/exceptions.py
+lemonade/version.py
+lemonade_cryptography.egg-info/PKG-INFO
+lemonade_cryptography.egg-info/SOURCES.txt
+lemonade_cryptography.egg-info/dependency_links.txt
+lemonade_cryptography.egg-info/top_level.txt
+tests/test_crypto.py

lemonade_cryptography-1.0.0/lemonade_cryptography.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

lemonade_cryptography-1.0.0/lemonade_cryptography.egg-info/top_level.txt

@@ -0,0 +1 @@
+lemonade

lemonade_cryptography-1.0.0/pyproject.toml

@@ -0,0 +1,29 @@
+[build-system]
+requires = ["setuptools>=68"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "lemonade-cryptography"
+version = "1.0.0"
+description = "Lightweight byte-oriented encryption library."
+readme = "README.md"
+license = { file = "LICENSE" }
+requires-python = ">=3.10"
+
+authors = [
+    {name="Vlinho"}
+]
+
+keywords = [
+    "cryptography",
+    "encryption",
+    "experimental"
+]
+
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "Operating System :: OS Independent"
+]
+
+[tool.setuptools]
+packages = ["lemonade"]

lemonade_cryptography-1.0.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

lemonade_cryptography-1.0.0/tests/test_crypto.py

@@ -0,0 +1,38 @@
+import pytest
+from lemonade import encrypt, decrypt
+from lemonade.exceptions import InvalidKeyError
+
+
+def test_invalid_key():
+    with pytest.raises(InvalidKeyError):
+        decrypt("YWJj", "invalid")
+        
+        
+def test_basic_encryption():
+    message = "Hello Lemonade"
+    crypt, key = encrypt(message)
+    result = decrypt(crypt, key)
+
+    assert result == message
+
+
+def test_unicode():
+    message = "🍋 Se a vida te der limões, faça uma limonada >w< 世界"
+    crypt, key = encrypt(message)
+
+    assert decrypt(crypt, key) == message
+    
+    
+def test_long_message():
+    message = "LIMÃO" * 2000
+    crypt, key = encrypt(message)
+
+    assert decrypt(crypt, key) == message
+    
+
+def test_empty_message():
+    message = ""
+    crypt, key = encrypt(message)
+
+    assert decrypt(crypt, key) == message
+