Design Pastebin: Architecture for Text Sharing

import hashlib, base64, time

def generate_url(content: str, salt: str = "") -> str:
    # Hash content + timestamp + salt for uniqueness
    unique = f"{content}{time.time_ns()}{salt}"
    hash_bytes = hashlib.sha256(unique.encode()).digest()
    # Base62 encode first 8 bytes for 11-character URL
    encoded = base64.b64encode(hash_bytes[:8]).decode().rstrip("=")
    # Replace + and / with URL-safe chars
    return encoded.replace("+", "A").replace("/", "B")[:8]

def validate_url(short: str) -> bool:
    return len(short) == 8 and all(c.isalnum() for c in short)

# Examples
for content in ["Hello World", "Code snippet", "Long document"]:
    url = generate_url(content)
    print(f"Content: '{content}' → URL: {url}")

CREATE TABLE pastes (
    id BIGSERIAL PRIMARY KEY,
    short_url VARCHAR(8) UNIQUE NOT NULL,
    user_id BIGINT REFERENCES users(id),
    title VARCHAR(255),
    content_url TEXT NOT NULL,  -- S3 key
    content_length INT NOT NULL,
    content_type VARCHAR(50) DEFAULT 'text/plain',
    password_hash VARCHAR(255),
    created_at TIMESTAMP DEFAULT NOW(),
    expires_at TIMESTAMP,
    view_count INT DEFAULT 0,
    is_flagged BOOLEAN DEFAULT FALSE
);

CREATE INDEX idx_short_url ON pastes(short_url);
CREATE INDEX idx_user_id ON pastes(user_id);
CREATE INDEX idx_expires_at ON pastes(expires_at);

from datetime import datetime, timedelta

class ExpirationManager:
    def __init__(self, db_connection):
        self.db = db_connection

    def cleanup_expired(self):
        query = """
            DELETE FROM pastes
            WHERE expires_at IS NOT NULL
            AND expires_at < NOW()
            RETURNING short_url, content_url
        """
        expired = self.db.execute(query)
        for paste in expired:
            self._delete_from_blob(paste['content_url'])
            self._evict_from_cache(paste['short_url'])
        return len(expired)

    def _delete_from_blob(self, url: str):
        print(f"Deleting blob: {url}")

    def _evict_from_cache(self, short_url: str):
        print(f"Evicting cache: paste:{short_url}")

manager = ExpirationManager(None)
count = manager.cleanup_expired()
print(f"Cleaned up {count} expired pastes")

import time
from collections import defaultdict

class SlidingWindowRateLimiter:
    def __init__(self, max_requests: int = 10, window_seconds: int = 60):
        self.max_requests = max_requests
        self.window_seconds = window_seconds
        self.requests = defaultdict(list)

    def allow(self, client_id: str) -> bool:
        now = time.time()
        window_start = now - self.window_seconds
        client_requests = self.requests[client_id]
        # Remove old requests
        self.requests[client_id] = [t for t in client_requests if t > window_start]
        if len(self.requests[client_id]) >= self.max_requests:
            return False
        self.requests[client_id].append(now)
        return True

limiter = SlidingWindowRateLimiter(max_requests=5, window_seconds=60)
client = "user-42"
for i in range(7):
    allowed = limiter.allow(client)
    print(f"Request {i+1}: {'✓ allowed' if allowed else '✗ rate limited'}")

import hashlib, json, time
from datetime import datetime, timedelta

class SimplePastebin:
    def __init__(self):
        self.store = {}
        self.metadata = {}

    def create(self, content: str, expires_in_hours: int = 24) -> str:
        content_hash = hashlib.md5(content.encode()).hexdigest()[:8]
        timestamp = str(time.time_ns())
        url = hashlib.sha256(f"{content_hash}{timestamp}".encode()).hexdigest()[:8]
        self.store[url] = content
        self.metadata[url] = {
            "created_at": datetime.now().isoformat(),
            "expires_at": (datetime.now() + timedelta(hours=expires_in_hours)).isoformat(),
            "size": len(content),
        }
        return url

    def get(self, url: str) -> dict:
        if url not in self.store:
            return {"error": "Not found"}
        meta = self.metadata[url]
        if datetime.fromisoformat(meta["expires_at"]) < datetime.now():
            del self.store[url]
            del self.metadata[url]
            return {"error": "Expired"}
        return {"content": self.store[url], "metadata": meta}

api = SimplePastebin()
url = api.create("def hello():\n    print('Hello, Pastebin!')", expires_in_hours=1)
print(f"Paste URL: {url}")
paste = api.get(url)
print(f"Content: {paste['content'][:50]}...")
print(f"Expires: {paste['metadata']['expires_at']}")