marearts-crystal 0.0.316016__tar.gz

marearts_crystal-0.0.316016/MANIFEST.in

@@ -0,0 +1,7 @@
+include README.md
+include LICENSE
+global-exclude __pycache__
+global-exclude *.py[cod]
+global-exclude *.cpp
+global-exclude *.c
+global-exclude *.pyc

marearts_crystal-0.0.316016/PKG-INFO

@@ -0,0 +1,137 @@
+Metadata-Version: 2.2
+Name: marearts-crystal
+Version: 0.0.316016
+Summary: marearts crystal for encryption and decryption
+Home-page: https://www.marearts.com
+Author: MareArts
+Author-email: MareArts <hello@marearts.com>
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: <3.12,>=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: cffi==1.16.0
+Requires-Dist: cryptography==43.0.0
+Requires-Dist: pycparser==2.22
+
+# MareArts Crystal
+
+MareArts Crystal is a Python package for encryption, decryption, and serial key management. It provides a simple interface for generating and validating serial keys, encrypting and decrypting strings and files, and performing date-based operations.
+
+## Installation
+
+Install MareArts Crystal using pip:
+
+```bash
+pip install marearts-crystal
+```
+
+## Usage
+
+Here's a comprehensive guide on how to use MareArts Crystal:
+
+```python
+from marearts_crystal import ma_crystal
+
+# Initialize with a secret key
+secret_key = "your_secret_key_here"
+skm = ma_crystal(secret_key)
+
+# Generate a serial key
+username = "john_doe"
+start_date = "2023-07-01"
+end_date = "2023-12-31"
+serial_key = skm.generate_serial_key(username, start_date, end_date)
+print(f"Generated Serial Key: {serial_key}")
+
+# Validate the serial key
+validated_start, validated_end = skm.validate_serial_key(username, serial_key)
+print(f"Validated Start Date: {validated_start}")
+print(f"Validated End Date: {validated_end}")
+
+# Date validation
+if skm.validate_date("2024-07-01", "2024-12-31"):
+    print("Date range is valid")
+else:
+    print("Date range is invalid")
+
+# Get today's date
+print("Today's date:", skm.get_today_date())
+
+# Generate end dates
+print("Tomorrow:", skm.generate_end_date(0, 0, 1))
+print("Next month:", skm.generate_end_date(0, 1, 0))
+print("Next year:", skm.generate_end_date(1, 0, 0))
+
+# Try with an invalid key
+invalid_result = skm.validate_serial_key(username, "invalid_key")
+print(f"Invalid Key Result: {invalid_result}")
+
+invalid_result = skm.validate_serial_key("wrong_name", serial_key)
+print(f"Invalid Key Result: {invalid_result}")
+
+# String encryption and decryption
+original_string = "Hello, MareArts Crystal!"
+encrypted = skm.encrypt_string(original_string)
+print(f"Encrypted: {encrypted}")
+
+decrypted = skm.decrypt_string(encrypted)
+print(f"Decrypted: {decrypted}")
+
+# Decryption with wrong key
+wrong_key = "wrong_secret_key"
+wrong_skm = ma_crystal(wrong_key)
+wrong_decryption = wrong_skm.decrypt_string(encrypted)
+print(f"Decryption with wrong key: {wrong_decryption}")
+
+# File encryption and decryption
+input_filename = "example.bin"  # This can be any file, binary or text
+output_encrypted_filename = "example_encrypted.bin"
+
+# Read and encrypt the file
+with open(input_filename, "rb") as file:
+    file_content = file.read()
+encrypted_content = skm.encrypt_data(file_content)
+
+# Save the encrypted content
+with open(output_encrypted_filename, "wb") as file:
+    file.write(encrypted_content)
+print(f"File '{input_filename}' has been encrypted and saved as '{output_encrypted_filename}'")
+
+# Decrypt the file
+input_encrypted_filename = output_encrypted_filename
+output_decrypted_filename = "example_decrypted.bin"
+
+# Read and decrypt the file
+with open(input_encrypted_filename, "rb") as file:
+    encrypted_content = file.read()
+decrypted_content = skm.decrypt_data(encrypted_content)
+
+if decrypted_content:
+    # Save the decrypted content
+    with open(output_decrypted_filename, "wb") as file:
+        file.write(decrypted_content)
+    print(f"File '{input_encrypted_filename}' has been decrypted and saved as '{output_decrypted_filename}'")
+else:
+    print("Decryption failed. The file might be corrupted or the wrong key was used.")
+```
+
+## Features
+
+- Serial key generation and validation
+- Date validation and manipulation
+- String encryption and decryption
+- File encryption and decryption
+- Secure key management
+
+## License
+
+This project is licensed under the MIT License
+
+
+## Support
+
+www.marearts.com

marearts_crystal-0.0.316016/README.md

@@ -0,0 +1,118 @@
+# MareArts Crystal
+
+MareArts Crystal is a Python package for encryption, decryption, and serial key management. It provides a simple interface for generating and validating serial keys, encrypting and decrypting strings and files, and performing date-based operations.
+
+## Installation
+
+Install MareArts Crystal using pip:
+
+```bash
+pip install marearts-crystal
+```
+
+## Usage
+
+Here's a comprehensive guide on how to use MareArts Crystal:
+
+```python
+from marearts_crystal import ma_crystal
+
+# Initialize with a secret key
+secret_key = "your_secret_key_here"
+skm = ma_crystal(secret_key)
+
+# Generate a serial key
+username = "john_doe"
+start_date = "2023-07-01"
+end_date = "2023-12-31"
+serial_key = skm.generate_serial_key(username, start_date, end_date)
+print(f"Generated Serial Key: {serial_key}")
+
+# Validate the serial key
+validated_start, validated_end = skm.validate_serial_key(username, serial_key)
+print(f"Validated Start Date: {validated_start}")
+print(f"Validated End Date: {validated_end}")
+
+# Date validation
+if skm.validate_date("2024-07-01", "2024-12-31"):
+    print("Date range is valid")
+else:
+    print("Date range is invalid")
+
+# Get today's date
+print("Today's date:", skm.get_today_date())
+
+# Generate end dates
+print("Tomorrow:", skm.generate_end_date(0, 0, 1))
+print("Next month:", skm.generate_end_date(0, 1, 0))
+print("Next year:", skm.generate_end_date(1, 0, 0))
+
+# Try with an invalid key
+invalid_result = skm.validate_serial_key(username, "invalid_key")
+print(f"Invalid Key Result: {invalid_result}")
+
+invalid_result = skm.validate_serial_key("wrong_name", serial_key)
+print(f"Invalid Key Result: {invalid_result}")
+
+# String encryption and decryption
+original_string = "Hello, MareArts Crystal!"
+encrypted = skm.encrypt_string(original_string)
+print(f"Encrypted: {encrypted}")
+
+decrypted = skm.decrypt_string(encrypted)
+print(f"Decrypted: {decrypted}")
+
+# Decryption with wrong key
+wrong_key = "wrong_secret_key"
+wrong_skm = ma_crystal(wrong_key)
+wrong_decryption = wrong_skm.decrypt_string(encrypted)
+print(f"Decryption with wrong key: {wrong_decryption}")
+
+# File encryption and decryption
+input_filename = "example.bin"  # This can be any file, binary or text
+output_encrypted_filename = "example_encrypted.bin"
+
+# Read and encrypt the file
+with open(input_filename, "rb") as file:
+    file_content = file.read()
+encrypted_content = skm.encrypt_data(file_content)
+
+# Save the encrypted content
+with open(output_encrypted_filename, "wb") as file:
+    file.write(encrypted_content)
+print(f"File '{input_filename}' has been encrypted and saved as '{output_encrypted_filename}'")
+
+# Decrypt the file
+input_encrypted_filename = output_encrypted_filename
+output_decrypted_filename = "example_decrypted.bin"
+
+# Read and decrypt the file
+with open(input_encrypted_filename, "rb") as file:
+    encrypted_content = file.read()
+decrypted_content = skm.decrypt_data(encrypted_content)
+
+if decrypted_content:
+    # Save the decrypted content
+    with open(output_decrypted_filename, "wb") as file:
+        file.write(decrypted_content)
+    print(f"File '{input_encrypted_filename}' has been decrypted and saved as '{output_decrypted_filename}'")
+else:
+    print("Decryption failed. The file might be corrupted or the wrong key was used.")
+```
+
+## Features
+
+- Serial key generation and validation
+- Date validation and manipulation
+- String encryption and decryption
+- File encryption and decryption
+- Secure key management
+
+## License
+
+This project is licensed under the MIT License
+
+
+## Support
+
+www.marearts.com

marearts_crystal-0.0.316016/marearts_crystal/__init__.py

@@ -0,0 +1 @@
+from .ma_crystal import ma_crystal

marearts_crystal-0.0.316016/marearts_crystal.egg-info/PKG-INFO

@@ -0,0 +1,137 @@
+Metadata-Version: 2.2
+Name: marearts-crystal
+Version: 0.0.316016
+Summary: marearts crystal for encryption and decryption
+Home-page: https://www.marearts.com
+Author: MareArts
+Author-email: MareArts <hello@marearts.com>
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: <3.12,>=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: cffi==1.16.0
+Requires-Dist: cryptography==43.0.0
+Requires-Dist: pycparser==2.22
+
+# MareArts Crystal
+
+MareArts Crystal is a Python package for encryption, decryption, and serial key management. It provides a simple interface for generating and validating serial keys, encrypting and decrypting strings and files, and performing date-based operations.
+
+## Installation
+
+Install MareArts Crystal using pip:
+
+```bash
+pip install marearts-crystal
+```
+
+## Usage
+
+Here's a comprehensive guide on how to use MareArts Crystal:
+
+```python
+from marearts_crystal import ma_crystal
+
+# Initialize with a secret key
+secret_key = "your_secret_key_here"
+skm = ma_crystal(secret_key)
+
+# Generate a serial key
+username = "john_doe"
+start_date = "2023-07-01"
+end_date = "2023-12-31"
+serial_key = skm.generate_serial_key(username, start_date, end_date)
+print(f"Generated Serial Key: {serial_key}")
+
+# Validate the serial key
+validated_start, validated_end = skm.validate_serial_key(username, serial_key)
+print(f"Validated Start Date: {validated_start}")
+print(f"Validated End Date: {validated_end}")
+
+# Date validation
+if skm.validate_date("2024-07-01", "2024-12-31"):
+    print("Date range is valid")
+else:
+    print("Date range is invalid")
+
+# Get today's date
+print("Today's date:", skm.get_today_date())
+
+# Generate end dates
+print("Tomorrow:", skm.generate_end_date(0, 0, 1))
+print("Next month:", skm.generate_end_date(0, 1, 0))
+print("Next year:", skm.generate_end_date(1, 0, 0))
+
+# Try with an invalid key
+invalid_result = skm.validate_serial_key(username, "invalid_key")
+print(f"Invalid Key Result: {invalid_result}")
+
+invalid_result = skm.validate_serial_key("wrong_name", serial_key)
+print(f"Invalid Key Result: {invalid_result}")
+
+# String encryption and decryption
+original_string = "Hello, MareArts Crystal!"
+encrypted = skm.encrypt_string(original_string)
+print(f"Encrypted: {encrypted}")
+
+decrypted = skm.decrypt_string(encrypted)
+print(f"Decrypted: {decrypted}")
+
+# Decryption with wrong key
+wrong_key = "wrong_secret_key"
+wrong_skm = ma_crystal(wrong_key)
+wrong_decryption = wrong_skm.decrypt_string(encrypted)
+print(f"Decryption with wrong key: {wrong_decryption}")
+
+# File encryption and decryption
+input_filename = "example.bin"  # This can be any file, binary or text
+output_encrypted_filename = "example_encrypted.bin"
+
+# Read and encrypt the file
+with open(input_filename, "rb") as file:
+    file_content = file.read()
+encrypted_content = skm.encrypt_data(file_content)
+
+# Save the encrypted content
+with open(output_encrypted_filename, "wb") as file:
+    file.write(encrypted_content)
+print(f"File '{input_filename}' has been encrypted and saved as '{output_encrypted_filename}'")
+
+# Decrypt the file
+input_encrypted_filename = output_encrypted_filename
+output_decrypted_filename = "example_decrypted.bin"
+
+# Read and decrypt the file
+with open(input_encrypted_filename, "rb") as file:
+    encrypted_content = file.read()
+decrypted_content = skm.decrypt_data(encrypted_content)
+
+if decrypted_content:
+    # Save the decrypted content
+    with open(output_decrypted_filename, "wb") as file:
+        file.write(decrypted_content)
+    print(f"File '{input_encrypted_filename}' has been decrypted and saved as '{output_decrypted_filename}'")
+else:
+    print("Decryption failed. The file might be corrupted or the wrong key was used.")
+```
+
+## Features
+
+- Serial key generation and validation
+- Date validation and manipulation
+- String encryption and decryption
+- File encryption and decryption
+- Secure key management
+
+## License
+
+This project is licensed under the MIT License
+
+
+## Support
+
+www.marearts.com

marearts_crystal-0.0.316016/marearts_crystal.egg-info/SOURCES.txt

@@ -0,0 +1,12 @@
+LICENSE
+MANIFEST.in
+README.md
+pyproject.toml
+setup.cfg
+setup.py
+marearts_crystal/__init__.py
+marearts_crystal.egg-info/PKG-INFO
+marearts_crystal.egg-info/SOURCES.txt
+marearts_crystal.egg-info/dependency_links.txt
+marearts_crystal.egg-info/requires.txt
+marearts_crystal.egg-info/top_level.txt

marearts_crystal-0.0.316016/marearts_crystal.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

marearts_crystal-0.0.316016/marearts_crystal.egg-info/requires.txt

@@ -0,0 +1,3 @@
+cffi==1.16.0
+cryptography==43.0.0
+pycparser==2.22

marearts_crystal-0.0.316016/marearts_crystal.egg-info/top_level.txt

@@ -0,0 +1 @@
+marearts_crystal

marearts_crystal-0.0.316016/pyproject.toml

@@ -0,0 +1,29 @@
+[build-system]
+requires = ["setuptools>=61.0", "wheel", "cython"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "marearts-crystal"
+version = "0.0.316016"
+authors = [
+    {name = "MareArts", email = "hello@marearts.com"}
+]
+description = "marearts crystal for encryption and decryption"
+readme = "README.md"
+requires-python = ">=3.9, <3.12"
+classifiers = [
+    "Programming Language :: Python :: 3.9",
+    "Programming Language :: Python :: 3.10", 
+    "Programming Language :: Python :: 3.11",
+    "License :: OSI Approved :: MIT License",
+    "Operating System :: OS Independent"
+]
+
+dependencies = [
+    "cffi==1.16.0",
+    "cryptography==43.0.0",
+    "pycparser==2.22"
+]
+
+[tool.setuptools]
+packages = ["marearts_crystal"]

marearts_crystal-0.0.316016/setup.cfg

@@ -0,0 +1,35 @@
+[metadata]
+name = marearts-crystal
+version = 0.0.316016
+author = MareArts
+author_email = hello@marearts.com
+description = marearts crystal for encryption and decryption
+long_description = file: README.md
+long_description_content_type = text/markdown
+url = https://www.marearts.com
+classifiers = 
+	Programming Language :: Python :: 3.9
+	Programming Language :: Python :: 3.10
+	Programming Language :: Python :: 3.11
+	License :: OSI Approved :: MIT License
+	Operating System :: OS Independent
+
+[options]
+packages = find:
+python_requires = >=3.9, <3.12
+install_requires = 
+	cffi==1.16.0
+	cryptography==43.0.0
+	pycparser==2.22
+include_package_data = true
+
+[bdist_wheel]
+universal = 1
+
+[options.packages.find]
+where = .
+
+[egg_info]
+tag_build = 
+tag_date = 0
+

marearts_crystal-0.0.316016/setup.py

@@ -0,0 +1,30 @@
+from setuptools import setup, Extension
+from Cython.Build import cythonize
+from wheel.bdist_wheel import bdist_wheel
+
+class BdistWheelCommand(bdist_wheel):
+    def finalize_options(self):
+        bdist_wheel.finalize_options(self)
+        self.root_is_pure = False
+        self.plat_name_supplied = True
+
+# Define the extension
+ext_modules = [
+    Extension(
+        "marearts_crystal.ma_crystal", 
+        ["marearts_crystal/ma_crystal.pyx"]
+    )
+]
+
+# Compile the extension
+compiled_ext_modules = cythonize(
+    ext_modules, 
+    compiler_directives={'language_level': "3"}
+)
+
+if __name__ == '__main__':
+    setup(
+        ext_modules=compiled_ext_modules,
+        cmdclass={'bdist_wheel': BdistWheelCommand},
+        include_package_data=True,
+    )