2. Upload your first file

import requests

# 1. Create a test file
with open('test.txt', 'w') as f:
    f.write("This is a test file for upload.")

# 2. Open in binary mode and upload
with open('test.txt', 'rb') as f:
    files = {'file': f}
    response = requests.post("https://httpbin.org/post", files=files, timeout=10)

# 3. Inspect the response
print(f"Status: {response.status_code}")
print(f"Content-Type sent: {response.request.headers.get('Content-Type')}")
print(f"File received by server: {response.json()['files']}")

Status: 200
Content-Type sent: multipart/form-data; boundary=...
File received by server: {'file': 'This is a test file for upload.'}

import requests

# Note: You need an actual image file for this
# For testing, create a small dummy binary file:
with open('profile.jpg', 'wb') as f:
    f.write(b'\xFF\xD8\xFF\xE0')  # JPEG header bytes

# Upload with metadata
with open('profile.jpg', 'rb') as f:
    files = {'profile_image': f}
    data = {
        'user_id': '12345',
        'description': 'Profile photo taken at conference'
    }
    
    response = requests.post(
        "https://httpbin.org/post", 
        files=files,
        data=data,  # Metadata goes in 'data', not 'json'
        timeout=15
    )

result = response.json()
print(f"Files: {result['files']}")
print(f"Form data: {result['form']}")

Files: {'profile_image': ...}
Form data: {'user_id': '12345', 'description': 'Profile photo taken at conference'}

import os
from pathlib import Path
import mimetypes
import requests

class ProfilePictureUploader:
    """
    A production-style profile picture uploader with:
      - Extension and size limits
      - Basic header validation (magic bytes)
      - Safe filenames
      - Proper MIME types
      - Clear (success, message, url) return structure
    """

    # Maximum file size: 5MB
    MAX_FILE_SIZE = 5 * 1024 * 1024

    # Allowed image extensions
    ALLOWED_EXTENSIONS = {'.jpg', '.jpeg', '.png', '.gif'}

    def __init__(self, user_id):
        self.user_id = user_id

    def upload_profile_picture(self, filepath):
        """
        Upload a profile picture with comprehensive validation.

        Returns:
            tuple: (success: bool, message: str, url: str or None)
        """

        # STEP 1: File existence check
        if not os.path.exists(filepath):
            return (False, "File not found", None)

        # STEP 2: Extension validation
        file_ext = Path(filepath).suffix.lower()
        if file_ext not in self.ALLOWED_EXTENSIONS:
            allowed = ', '.join(self.ALLOWED_EXTENSIONS)
            return (False, f"Invalid file type. Allowed: {allowed}", None)

        # STEP 3: File size validation
        file_size = os.path.getsize(filepath)
        if file_size > self.MAX_FILE_SIZE:
            max_mb = self.MAX_FILE_SIZE / (1024 * 1024)
            actual_mb = file_size / (1024 * 1024)
            return (False, f"File too large ({actual_mb:.1f}MB). Max: {max_mb}MB", None)

        # STEP 4: Basic content validation (is it really an image?)
        try:
            with open(filepath, 'rb') as f:
                header = f.read(10)

            if not self._is_valid_image_header(header, file_ext):
                return (False, "File content does not match a valid image format", None)
        except Exception as e:
            return (False, f"Failed to read file header: {str(e)}", None)

        # STEP 5: Prepare safe filename
        safe_filename = self._build_safe_filename(file_ext)

        # STEP 6: Determine correct MIME type
        mime_type = self._get_mime_type(file_ext)

        # STEP 7: Upload to remote API
        try:
            with open(filepath, 'rb') as f:
                files = {
                    'file': (safe_filename, f, mime_type)
                }

                response = requests.post(
                    "https://httpbin.org/post",
                    files=files,
                    timeout=30
                )
                response.raise_for_status()

                # In a real system, you'd parse the response to get the final URL.
                # Here we just return a pretend URL.
                uploaded_url = f"https://cdn.example.com/profile_pics/{safe_filename}"
                return (True, "Upload successful", uploaded_url)

        except requests.exceptions.Timeout:
            return (False, "Upload timed out - please try again", None)

        except requests.exceptions.RequestException as e:
            return (False, f"Upload failed: {str(e)}", None)

    def _is_valid_image_header(self, header, extension):
        """Check if file header matches the claimed extension"""
        # JPEG: FF D8 FF
        if extension in {'.jpg', '.jpeg'} and header[:3] == b'\xFF\xD8\xFF':
            return True
        # PNG: 89 50 4E 47 0D 0A 1A 0A
        if extension == '.png' and header[:8] == b'\x89PNG\r\n\x1a\n':
            return True
        # GIF: 47 49 46 38 37 61 or 47 49 46 38 39 61
        if extension == '.gif' and header[:6] in (b'GIF87a', b'GIF89a'):
            return True
        return False

    def _get_mime_type(self, extension):
        """Get proper MIME type for extension"""
        mime_types = {
            '.jpg': 'image/jpeg',
            '.jpeg': 'image/jpeg',
            '.png': 'image/png',
            '.gif': 'image/gif'
        }
        return mime_types.get(extension, 'application/octet-stream')

    def _build_safe_filename(self, extension):
        """
        Build a safe filename that does not leak original names
        (which might contain personal data).
        """
        return f"user_{self.user_id}_profile{extension}"

# Usage Example
if __name__ == "__main__":
    # Create a tiny fixture so the success path runs end-to-end.
    # Real apps receive the path from a file-upload form or CLI argument.
    test_image = "test_profile_picture.jpg"
    with open(test_image, "wb") as f:
        f.write(b"\xFF\xD8\xFF\xE0" + b"\x00" * 1024)  # JPEG header + filler

    uploader = ProfilePictureUploader(user_id=12345)
    success, message, url = uploader.upload_profile_picture(test_image)
    print("Success:", success)
    print("Message:", message)
    print("URL:", url)