import time
import asyncio
import aiohttp
from multiprocessing import Process, Pool
from threading import Thread
from concurrent.futures import ThreadPoolExecutor, ProcessPoolExecutor

# Simular descarga
def download_file_sync(url, file_id):
    """Descarga sincrónica (bloqueante)"""
    print(f"Downloading {url}...")
    time.sleep(2)  # Simular I/O
    return f"Downloaded {file_id}"

# 1. SECUENCIAL (baseline)
def download_sequential(urls):
    start = time.time()
    results = [download_file_sync(url, i) for i, url in enumerate(urls)]
    print(f"⏱️  Sequential: {time.time() - start:.2f}s")
    return results

# 2. MULTIPROCESSING (CPU-bound)
def download_multiprocess(urls):
    start = time.time()
    with ProcessPoolExecutor() as executor:
        results = list(executor.map(download_file_sync, urls, range(len(urls))))
    print(f"⏱️  Multiprocess: {time.time() - start:.2f}s")
    return results

# 3. MULTITHREADING (I/O-bound)
def download_multithread(urls):
    start = time.time()
    with ThreadPoolExecutor(max_workers=5) as executor:
        results = list(executor.map(download_file_sync, urls, range(len(urls))))
    print(f"⏱️  Multithread: {time.time() - start:.2f}s")
    return results

# 4. ASYNC/AWAIT (I/O-bound óptimo)
async def download_file_async(session, url, file_id):
    """Descarga asíncrona (non-blocking)"""
    print(f"Downloading {url}...")
    await asyncio.sleep(2)  # Simular I/O async
    return f"Downloaded {file_id}"

async def download_async(urls):
    start = time.time()
    async with aiohttp.ClientSession() as session:
        tasks = [download_file_async(session, url, i) for i, url in enumerate(urls)]
        results = await asyncio.gather(*tasks)
    print(f"⏱️  Async: {time.time() - start:.2f}s")
    return results

# Prueba
urls = [f"https://example.com/file{i}.zip" for i in range(10)]

download_sequential(urls)      # ~20s (10 archivos × 2s)
download_multiprocess(urls)    # ~4-6s (overhead de procesos)
download_multithread(urls)     # ~4s (paralelismo real)
asyncio.run(download_async(urls))  # ~2s (todo concurrente)

import kotlinx.coroutines.*

// Simular descarga
fun downloadFileSync(url: String, fileId: Int): String {
    Thread.sleep(2_000); return "Downloaded $fileId"
}

// 1. SECUENCIAL (baseline)
fun downloadSequential(urls: List<String>): List<String> {
    val start = System.currentTimeMillis()
    return urls.mapIndexed { i, url -> downloadFileSync(url, i) }
        .also { println("⏱️  Sequential: ${(System.currentTimeMillis() - start) / 1000.0}s") }
}

// 2. THREADS (I/O-bound)
fun downloadThreaded(urls: List<String>): List<String> {
    val start = System.currentTimeMillis()
    val results = urls.indices.map { i ->
        Thread { downloadFileSync(urls[i], i) }.also { it.start() }
    }.map { it.join(); "done" }
    println("⏱️  Threaded: ${(System.currentTimeMillis() - start) / 1000.0}s")
    return results
}

// 3. COROUTINES (I/O-bound óptimo – equivalente Python async/await)
suspend fun downloadFileAsync(url: String, fileId: Int): String {
    delay(2_000); return "Downloaded $fileId"
}

fun downloadCoroutines(urls: List<String>): List<String> = runBlocking {
    val start = System.currentTimeMillis()
    urls.mapIndexed { i, url -> async { downloadFileAsync(url, i) } }
        .awaitAll()
        .also { println("⏱️  Coroutines: ${(System.currentTimeMillis() - start) / 1000.0}s") }
}

val urls = (0 until 10).map { "https://example.com/file$it.zip" }
// downloadSequential(urls)   // ~20s
// downloadThreaded(urls)     // ~4s
downloadCoroutines(urls)       // ~2s

import java.util.*;
import java.util.concurrent.*;

static String downloadFileSync(String url, int id) throws Exception {
    Thread.sleep(2_000); return "Downloaded " + id;
}

// 1. SECUENCIAL
static List<String> downloadSequential(List<String> urls) throws Exception {
    long start = System.currentTimeMillis();
    var results = new ArrayList<String>();
    for (int i = 0; i < urls.size(); i++) results.add(downloadFileSync(urls.get(i), i));
    System.out.printf("⏱️  Sequential: %.2fs%n", (System.currentTimeMillis()-start)/1000.0);
    return results;
}

// 2. THREAD POOL (I/O-bound)
static List<String> downloadThreaded(List<String> urls) throws Exception {
    long start = System.currentTimeMillis();
    var executor = Executors.newFixedThreadPool(urls.size());
    var futures = new ArrayList<Future<String>>();
    for (int i = 0; i < urls.size(); i++) {
        final int idx = i;
        futures.add(executor.submit(() -> downloadFileSync(urls.get(idx), idx)));
    }
    var results = futures.stream().map(f -> { try { return f.get(); } catch(Exception e){return "";} }).toList();
    executor.shutdown();
    System.out.printf("⏱️  ThreadPool: %.2fs%n", (System.currentTimeMillis()-start)/1000.0);
    return results;
}

// 3. COMPLETABLE FUTURE (equivalente a async/await)
static List<String> downloadAsync(List<String> urls) throws Exception {
    long start = System.currentTimeMillis();
    var futures = new ArrayList<CompletableFuture<String>>();
    for (int i = 0; i < urls.size(); i++) {
        final int idx = i; final String url = urls.get(idx);
        futures.add(CompletableFuture.supplyAsync(() -> {
            try { return downloadFileSync(url, idx); } catch(Exception e) { return ""; }
        }));
    }
    var results = CompletableFuture.allOf(futures.toArray(new CompletableFuture[0]))
        .thenApply(v -> futures.stream().map(CompletableFuture::join).toList()).get();
    System.out.printf("⏱️  Async: %.2fs%n", (System.currentTimeMillis()-start)/1000.0);
    return results;
}

var urls = new ArrayList<String>();
for (int i = 0; i < 10; i++) urls.add("https://example.com/file" + i + ".zip");
// downloadSequential(urls);   // ~20s
// downloadThreaded(urls);     // ~4s
downloadAsync(urls);            // ~2s

import asyncio
import aiohttp
from bs4 import BeautifulSoup

class AsyncWebScraper:
    """Scraper asíncrono eficiente"""
    
    def __init__(self, max_concurrent=10):
        self.max_concurrent = max_concurrent
        self.semaphore = asyncio.Semaphore(max_concurrent)
    
    async def fetch_page(self, session, url):
        """Descargar una página"""
        async with self.semaphore:  # Limitar concurrencia
            try:
                async with session.get(url, timeout=10) as response:
                    return await response.text()
            except Exception as e:
                print(f"Error fetching {url}: {e}")
                return None
    
    async def scrape_urls(self, urls):
        """Scrapear múltiples URLs concurrentemente"""
        async with aiohttp.ClientSession() as session:
            tasks = [self.fetch_page(session, url) for url in urls]
            results = await asyncio.gather(*tasks)
            return results
    
    async def scrape_and_parse(self, urls):
        """Scrape + parseo"""
        pages = await self.scrape_urls(urls)
        
        parsed_data = []
        for url, html in zip(urls, pages):
            if html:
                soup = BeautifulSoup(html, 'html.parser')
                title = soup.find('title').text if soup.find('title') else "No title"
                parsed_data.append({
                    'url': url,
                    'title': title,
                    'length': len(html)
                })
        
        return parsed_data

# Uso
scraper = AsyncWebScraper(max_concurrent=20)
urls = ["https://example.com", "https://python.org"]
# results = asyncio.run(scraper.scrape_and_parse(urls))

import kotlinx.coroutines.*
import kotlinx.coroutines.sync.Semaphore
import kotlinx.coroutines.sync.withPermit
import java.net.URL

class AsyncWebScraper(private val maxConcurrent: Int = 10) {
    private val semaphore = Semaphore(maxConcurrent)

    suspend fun fetchPage(url: String): String? = withContext(Dispatchers.IO) {
        semaphore.withPermit {
            runCatching { URL(url).readText() }
                .onFailure { println("Error fetching $url: ${it.message}") }
                .getOrNull()
        }
    }

    suspend fun scrapeUrls(urls: List<String>): List<String?> = coroutineScope {
        urls.map { async { fetchPage(it) } }.awaitAll()
    }

    suspend fun scrapeAndParse(urls: List<String>): List<Map<String, Any>> {
        return scrapeUrls(urls).zip(urls).mapNotNull { (html, url) ->
            html?.let {
                val title = Regex("<title>(.*?)</title>").find(it)?.groupValues?.get(1) ?: "No title"
                mapOf("url" to url, "title" to title, "length" to it.length)
            }
        }
    }
}

// Uso
val scraper = AsyncWebScraper(maxConcurrent = 20)
val urls    = listOf("https://example.com", "https://kotlinlang.org")
// val results = runBlocking { scraper.scrapeAndParse(urls) }

import java.net.*;
import java.net.http.*;
import java.util.*;
import java.util.concurrent.*;
import java.util.regex.*;

static class AsyncWebScraper {
    private final HttpClient client = HttpClient.newBuilder().build();
    private final Semaphore semaphore;

    AsyncWebScraper(int maxConcurrent) { this.semaphore = new Semaphore(maxConcurrent); }

    CompletableFuture<String> fetchPage(String url) {
        return CompletableFuture.supplyAsync(() -> {
            try {
                semaphore.acquire();
                var req = HttpRequest.newBuilder().uri(URI.create(url)).build();
                return client.send(req, HttpResponse.BodyHandlers.ofString()).body();
            } catch (Exception e) {
                System.out.println("Error fetching " + url + ": " + e.getMessage()); return null;
            } finally { semaphore.release(); }
        });
    }

    List<Map<String,Object>> scrapeAndParse(List<String> urls) throws Exception {
        var futures = urls.stream().map(this::fetchPage).toList();
        CompletableFuture.allOf(futures.toArray(new CompletableFuture[0])).get();
        var results = new ArrayList<Map<String,Object>>();
        for (int i = 0; i < urls.size(); i++) {
            String html = futures.get(i).get(); if (html == null) continue;
            var m = Pattern.compile("<title>(.*?)</title>").matcher(html);
            String title = m.find() ? m.group(1) : "No title";
            results.add(Map.of("url",urls.get(i),"title",title,"length",html.length()));
        }
        return results;
    }
}

var scraper = new AsyncWebScraper(20);
var urls = List.of("https://example.com", "https://java.com");
// var results = scraper.scrapeAndParse(urls);

import socket
import threading
import json
from datetime import datetime

# TCP Chat Server (confiable, ordenado)
class TCPChatServer:
    def __init__(self, host='localhost', port=5000):
        self.host = host
        self.port = port
        self.clients = []
        self.socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
        self.socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
    
    def start(self):
        """Iniciar servidor TCP"""
        self.socket.bind((self.host, self.port))
        self.socket.listen(5)
        print(f"🟢 TCP Server listening on {self.host}:{self.port}")
        
        while True:
            client_socket, address = self.socket.accept()
            print(f"✓ New connection from {address}")
            self.clients.append(client_socket)
            
            # Manejar cliente en thread separado
            thread = threading.Thread(
                target=self.handle_client,
                args=(client_socket, address)
            )
            thread.start()
    
    def handle_client(self, client_socket, address):
        """Manejar mensajes de cliente"""
        while True:
            try:
                message = client_socket.recv(1024).decode('utf-8')
                if not message:
                    break
                
                print(f"📨 From {address}: {message}")
                
                # Broadcast a todos los clientes
                self.broadcast(message, client_socket)
            
            except Exception as e:
                print(f"❌ Error: {e}")
                break
        
        client_socket.close()
        self.clients.remove(client_socket)
        print(f"✗ {address} disconnected")
    
    def broadcast(self, message, sender_socket):
        """Enviar mensaje a todos excepto sender"""
        for client in self.clients:
            if client != sender_socket:
                try:
                    client.send(message.encode('utf-8'))
                except:
                    client.close()
                    self.clients.remove(client)

# UDP Game Server (rápido, puede perder paquetes)
class UDPGameServer:
    """Servidor UDP para posiciones de jugadores en tiempo real"""
    
    def __init__(self, host='localhost', port=5001):
        self.host = host
        self.port = port
        self.socket = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
        self.socket.bind((self.host, self.port))
        self.players = {}  # {address: player_data}
    
    def start(self):
        """Iniciar servidor UDP"""
        print(f"🟢 UDP Server listening on {self.host}:{self.port}")
        
        while True:
            try:
                data, address = self.socket.recvfrom(1024)
                message = json.loads(data.decode('utf-8'))
                
                # Actualizar posición del jugador
                self.players[address] = {
                    'position': message.get('position'),
                    'timestamp': datetime.now().isoformat()
                }
                
                # Enviar estado del juego a todos (broadcast)
                self.broadcast_game_state()
            
            except Exception as e:
                print(f"❌ Error: {e}")
    
    def broadcast_game_state(self):
        """Enviar posiciones de todos los jugadores"""
        game_state = {
            'players': [
                {
                    'address': str(addr),
                    'position': data['position']
                }
                for addr, data in self.players.items()
            ]
        }
        
        message = json.dumps(game_state).encode('utf-8')
        
        for address in self.players.keys():
            self.socket.sendto(message, address)

# Cliente TCP
def tcp_client(host='localhost', port=5000):
    client = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    client.connect((host, port))
    
    while True:
        message = input("You: ")
        client.send(message.encode('utf-8'))
        
        response = client.recv(1024).decode('utf-8')
        print(f"Received: {response}")

# Cliente UDP (enviar posición cada frame)
def udp_game_client(host='localhost', port=5001):
    client = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
    
    position = [0, 0]  # x, y
    
    while True:
        # Simular movimiento
        position[0] += 1
        position[1] += 0.5
        
        message = json.dumps({'position': position})
        client.sendto(message.encode('utf-8'), (host, port))
        
        # Recibir estado del juego
        data, _ = client.recvfrom(4096)
        game_state = json.loads(data.decode('utf-8'))
        print(f"Players: {len(game_state['players'])}")
        
        time.sleep(0.016)  # ~60 FPS

import java.net.*
import java.io.*
import kotlinx.coroutines.*
import kotlinx.coroutines.Dispatchers

// TCP Chat Server (confiable, ordenado)
class TCPChatServer(private val port: Int = 5000) {
    private val clients = mutableListOf<PrintWriter>()

    fun start() = ServerSocket(port).use { server ->
        println("TCP Server listening on port $port")
        while (true) {
            val client = server.accept()
            GlobalScope.launch(Dispatchers.IO) { handleClient(client) }
        }
    }

    private fun handleClient(socket: Socket) {
        val writer = PrintWriter(socket.getOutputStream(), true).also { clients.add(it) }
        val reader = BufferedReader(InputStreamReader(socket.getInputStream()))
        try {
            var line: String?
            while (reader.readLine().also { line = it } != null) broadcast(line!!, writer)
        } finally { clients.remove(writer); socket.close() }
    }

    private fun broadcast(message: String, sender: PrintWriter) =
        clients.filter { it != sender }.forEach { it.println(message) }
}

// UDP Game Server (rápido, puede perder paquetes)
class UDPGameServer(private val port: Int = 5001) {
    private val socket  = DatagramSocket(port)
    private val players = mutableMapOf<String, String>()

    fun start() {
        val buffer = ByteArray(1024)
        while (true) {
            val packet = DatagramPacket(buffer, buffer.size)
            socket.receive(packet)
            val address = "${packet.address}:${packet.port}"
            players[address] = String(packet.data, 0, packet.length)
            broadcastGameState()
        }
    }

    private fun broadcastGameState() {
        val state = "Players: ${players.size}".toByteArray()
        // En producción: parsear direcciones y enviar a cada jugador
    }
}

import java.net.*;
import java.io.*;
import java.util.*;
import java.util.concurrent.*;

// TCP Chat Server (Java 21 Virtual Threads)
static class TCPChatServer {
    private final int port;
    private final List<PrintWriter> clients = Collections.synchronizedList(new ArrayList<>());

    TCPChatServer(int port) { this.port = port; }

    void start() throws Exception {
        try (var server = new ServerSocket(port);
             var executor = Executors.newVirtualThreadPerTaskExecutor()) {
            System.out.println("TCP Server on port " + port);
            while (true) {
                Socket client = server.accept();
                executor.submit(() -> handleClient(client));
            }
        }
    }

    private void handleClient(Socket socket) {
        try (var writer = new PrintWriter(socket.getOutputStream(), true);
             var reader = new BufferedReader(new InputStreamReader(socket.getInputStream()))) {
            clients.add(writer);
            String line;
            while ((line = reader.readLine()) != null) broadcast(line, writer);
        } catch (Exception e) { /* client disconnected */ }
    }

    private void broadcast(String msg, PrintWriter sender) {
        clients.stream().filter(c -> c != sender).forEach(c -> c.println(msg));
    }
}

// UDP Game Server
static class UDPGameServer {
    private final DatagramSocket socket;
    private final Map<String,String> players = new ConcurrentHashMap<>();

    UDPGameServer(int port) throws Exception { this.socket = new DatagramSocket(port); }

    void start() throws Exception {
        byte[] buf = new byte[1024];
        while (true) {
            var packet = new DatagramPacket(buf, buf.length);
            socket.receive(packet);
            players.put(packet.getAddress() + ":" + packet.getPort(),
                new String(packet.getData(), 0, packet.getLength()));
        }
    }
}

import requests
from flask import Flask, request, jsonify

app = Flask(__name__)

# Base de datos simulada
users = {}

# GET - Obtener recursos (idempotente, cacheable)
@app.route('/users/<int:user_id>', methods=['GET'])
def get_user(user_id):
    """Obtener usuario por ID"""
    user = users.get(user_id)
    if user:
        return jsonify(user), 200
    return jsonify({"error": "User not found"}), 404

# POST - Crear nuevo recurso (no idempotente)
@app.route('/users', methods=['POST'])
def create_user():
    """Crear nuevo usuario"""
    data = request.json
    user_id = len(users) + 1
    users[user_id] = {
        'id': user_id,
        'name': data['name'],
        'email': data['email']
    }
    return jsonify(users[user_id]), 201  # 201 Created

# PUT - Actualizar completamente (idempotente)
@app.route('/users/<int:user_id>', methods=['PUT'])
def update_user(user_id):
    """Reemplazar usuario completamente"""
    if user_id not in users:
        return jsonify({"error": "User not found"}), 404
    
    data = request.json
    users[user_id] = {
        'id': user_id,
        'name': data['name'],
        'email': data['email']
    }
    return jsonify(users[user_id]), 200

# PATCH - Actualizar parcialmente (idempotente)
@app.route('/users/<int:user_id>', methods=['PATCH'])
def patch_user(user_id):
    """Actualizar campos específicos"""
    if user_id not in users:
        return jsonify({"error": "User not found"}), 404
    
    data = request.json
    users[user_id].update(data)  # Solo actualizar campos provistos
    return jsonify(users[user_id]), 200

# DELETE - Eliminar recurso (idempotente)
@app.route('/users/<int:user_id>', methods=['DELETE'])
def delete_user(user_id):
    """Eliminar usuario"""
    if user_id not in users:
        return jsonify({"error": "User not found"}), 404
    
    del users[user_id]
    return '', 204  # 204 No Content

# HEAD - Como GET pero solo headers (para verificar existencia)
@app.route('/users/<int:user_id>', methods=['HEAD'])
def head_user(user_id):
    """Verificar si usuario existe sin traer body"""
    if user_id in users:
        return '', 200
    return '', 404

# OPTIONS - Descubrir métodos soportados
@app.route('/users/<int:user_id>', methods=['OPTIONS'])
def options_user(user_id):
    """Retornar métodos HTTP permitidos"""
    return '', 200, {'Allow': 'GET, PUT, PATCH, DELETE, HEAD, OPTIONS'}

if __name__ == '__main__':
    app.run(debug=True)

import io.ktor.server.application.*
import io.ktor.server.routing.*
import io.ktor.server.response.*
import io.ktor.server.request.*
import io.ktor.http.*
import io.ktor.server.engine.*
import io.ktor.server.netty.*

val users = mutableMapOf<Int, MutableMap<String, Any>>()

fun Application.configureRouting() {
    routing {
        // GET – Obtener recurso (idempotente, cacheable)
        get("/users/{id}") {
            val id   = call.parameters["id"]?.toInt() ?: return@get call.respond(HttpStatusCode.BadRequest)
            val user = users[id]  ?: return@get call.respond(HttpStatusCode.NotFound, mapOf("error" to "Not found"))
            call.respond(user)
        }

        // POST – Crear recurso (no idempotente)
        post("/users") {
            val data = call.receive<Map<String, Any>>()
            val id   = users.size + 1
            users[id] = (mapOf("id" to id) + data).toMutableMap()
            call.respond(HttpStatusCode.Created, users[id]!!)
        }

        // PUT – Reemplazar completamente (idempotente)
        put("/users/{id}") {
            val id = call.parameters["id"]?.toInt() ?: return@put call.respond(HttpStatusCode.BadRequest)
            if (id !in users) return@put call.respond(HttpStatusCode.NotFound)
            val data = call.receive<Map<String, Any>>()
            users[id] = (mapOf("id" to id) + data).toMutableMap()
            call.respond(users[id]!!)
        }

        // PATCH – Actualizar parcialmente
        patch("/users/{id}") {
            val id = call.parameters["id"]?.toInt() ?: return@patch call.respond(HttpStatusCode.BadRequest)
            if (id !in users) return@patch call.respond(HttpStatusCode.NotFound)
            val data = call.receive<Map<String, Any>>()
            users[id]!!.putAll(data)
            call.respond(users[id]!!)
        }

        // DELETE – Eliminar recurso
        delete("/users/{id}") {
            val id = call.parameters["id"]?.toInt() ?: return@delete call.respond(HttpStatusCode.BadRequest)
            if (id !in users) return@delete call.respond(HttpStatusCode.NotFound)
            users.remove(id)
            call.respond(HttpStatusCode.NoContent)
        }
    }
}

fun main() {
    embeddedServer(Netty, port = 8080, module = Application::configureRouting).start(wait = true)
}

import org.springframework.web.bind.annotation.*;
import org.springframework.http.*;
import java.util.*;

@RestController
@RequestMapping("/users")
public class UserController {
    private final Map<Integer,Map<String,Object>> users = new HashMap<>();

    // GET – Obtener recurso (idempotente, cacheable)
    @GetMapping("/{id}")
    ResponseEntity<?> getUser(@PathVariable int id) {
        var user = users.get(id);
        return user != null ? ResponseEntity.ok(user) : ResponseEntity.notFound().build();
    }

    // POST – Crear recurso (no idempotente)
    @PostMapping
    ResponseEntity<?> createUser(@RequestBody Map<String,Object> data) {
        int id = users.size() + 1;
        var user = new HashMap<>(data); user.put("id", id);
        users.put(id, user);
        return ResponseEntity.status(HttpStatus.CREATED).body(user);
    }

    // PUT – Reemplazar completamente (idempotente)
    @PutMapping("/{id}")
    ResponseEntity<?> updateUser(@PathVariable int id, @RequestBody Map<String,Object> data) {
        if (!users.containsKey(id)) return ResponseEntity.notFound().build();
        var user = new HashMap<>(data); user.put("id", id);
        users.put(id, user); return ResponseEntity.ok(user);
    }

    // PATCH – Actualizar parcialmente
    @PatchMapping("/{id}")
    ResponseEntity<?> patchUser(@PathVariable int id, @RequestBody Map<String,Object> data) {
        if (!users.containsKey(id)) return ResponseEntity.notFound().build();
        users.get(id).putAll(data); return ResponseEntity.ok(users.get(id));
    }

    // DELETE – Eliminar recurso
    @DeleteMapping("/{id}")
    ResponseEntity<Void> deleteUser(@PathVariable int id) {
        if (!users.containsKey(id)) return ResponseEntity.notFound().build();
        users.remove(id); return ResponseEntity.noContent().build();
    }
}

import requests
from requests.adapters import HTTPAdapter
from requests.packages.urllib3.util.retry import Retry

class RobustHTTPClient:
    """Cliente HTTP con retry automático y timeout"""
    
    def __init__(self, base_url, timeout=10, max_retries=3):
        self.base_url = base_url
        self.timeout = timeout
        
        # Configurar retry strategy
        retry_strategy = Retry(
            total=max_retries,
            backoff_factor=1,  # Esperar 1s, 2s, 4s...
            status_forcelist=[429, 500, 502, 503, 504],
            allowed_methods=["HEAD", "GET", "PUT", "DELETE", "OPTIONS", "TRACE"]
        )
        
        adapter = HTTPAdapter(max_retries=retry_strategy)
        self.session = requests.Session()
        self.session.mount("http://", adapter)
        self.session.mount("https://", adapter)
    
    def get(self, endpoint, **kwargs):
        """GET request con manejo de errores"""
        url = f"{self.base_url}{endpoint}"
        try:
            response = self.session.get(url, timeout=self.timeout, **kwargs)
            response.raise_for_status()  # Lanzar excepción si 4xx/5xx
            return response.json()
        except requests.exceptions.Timeout:
            print(f"⏱️  Timeout al conectar a {url}")
            raise
        except requests.exceptions.ConnectionError:
            print(f"❌ Error de conexión a {url}")
            raise
        except requests.exceptions.HTTPError as e:
            print(f"❌ HTTP Error: {e.response.status_code}")
            raise
    
    def post(self, endpoint, data, **kwargs):
        """POST request"""
        url = f"{self.base_url}{endpoint}"
        response = self.session.post(
            url,
            json=data,
            timeout=self.timeout,
            **kwargs
        )
        response.raise_for_status()
        return response.json()

# Uso
client = RobustHTTPClient("https://api.example.com", timeout=5, max_retries=3)

try:
    users = client.get("/users")
    new_user = client.post("/users", {"name": "Alice", "email": "alice@example.com"})
except Exception as e:
    print(f"Failed: {e}")

import java.net.URI
import java.net.http.*
import java.time.Duration

class RobustHTTPClient(
    private val baseUrl:    String,
    private val timeout:    Duration = Duration.ofSeconds(10),
    private val maxRetries: Int = 3
) {
    private val client = HttpClient.newBuilder()
        .connectTimeout(timeout)
        .followRedirects(HttpClient.Redirect.NORMAL)
        .build()

    fun get(endpoint: String): String = withRetry {
        val req = HttpRequest.newBuilder()
            .uri(URI.create("$baseUrl$endpoint"))
            .timeout(timeout).GET().build()
        client.send(req, HttpResponse.BodyHandlers.ofString())
            .also { if (it.statusCode() !in 200..299) throw RuntimeException("HTTP ${it.statusCode()}") }
            .body()
    }

    fun post(endpoint: String, body: String): String = withRetry {
        val req = HttpRequest.newBuilder()
            .uri(URI.create("$baseUrl$endpoint"))
            .timeout(timeout)
            .header("Content-Type", "application/json")
            .POST(HttpRequest.BodyPublishers.ofString(body)).build()
        client.send(req, HttpResponse.BodyHandlers.ofString()).body()
    }

    private fun <T> withRetry(block: () -> T): T {
        repeat(maxRetries - 1) { attempt ->
            runCatching { return block() }.onFailure {
                println("⚠️  Attempt ${attempt + 1} failed: ${it.message}")
            }
        }
        return block()
    }
}

val httpClient = RobustHTTPClient("https://api.example.com", timeout = Duration.ofSeconds(5))
// val users   = httpClient.get("/users")
// val newUser = httpClient.post("/users", """{"name":"Alice","email":"alice@example.com"}""")

import java.net.*;
import java.net.http.*;
import java.time.*;

static class RobustHTTPClient {
    private final String baseUrl;
    private final Duration timeout;
    private final int maxRetries;
    private final HttpClient client;

    RobustHTTPClient(String baseUrl, Duration timeout, int maxRetries) {
        this.baseUrl = baseUrl; this.timeout = timeout; this.maxRetries = maxRetries;
        this.client = HttpClient.newBuilder()
            .connectTimeout(timeout)
            .followRedirects(HttpClient.Redirect.NORMAL).build();
    }

    String get(String endpoint) throws Exception {
        return withRetry(() -> {
            var req = HttpRequest.newBuilder()
                .uri(URI.create(baseUrl + endpoint)).timeout(timeout).GET().build();
            var resp = client.send(req, HttpResponse.BodyHandlers.ofString());
            if (resp.statusCode() < 200 || resp.statusCode() >= 300)
                throw new RuntimeException("HTTP " + resp.statusCode());
            return resp.body();
        });
    }

    String post(String endpoint, String body) throws Exception {
        return withRetry(() -> {
            var req = HttpRequest.newBuilder()
                .uri(URI.create(baseUrl + endpoint)).timeout(timeout)
                .header("Content-Type", "application/json")
                .POST(HttpRequest.BodyPublishers.ofString(body)).build();
            return client.send(req, HttpResponse.BodyHandlers.ofString()).body();
        });
    }

    private <T> T withRetry(java.util.concurrent.Callable<T> fn) throws Exception {
        for (int i = 0; i < maxRetries-1; i++) {
            try { return fn.call(); }
            catch (Exception e) { System.out.println("⚠️  Attempt " + (i+1) + " failed: " + e.getMessage()); }
        }
        return fn.call();
    }
}

var client = new RobustHTTPClient("https://api.example.com", Duration.ofSeconds(5), 3);
// var users   = client.get("/users");
// var newUser = client.post("/users", "{\"name\":\"Alice\"}");

# Configurar headers comunes
headers = {
    # Autenticación
    'Authorization': 'Bearer eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9...',
    
    # Content negotiation
    'Content-Type': 'application/json',
    'Accept': 'application/json',
    
    # Caching
    'Cache-Control': 'max-age=3600',
    'ETag': '"33a64df551425fcc55e4d42a148795d9f25f89d4"',
    
    # CORS
    'Access-Control-Allow-Origin': '*',
    'Access-Control-Allow-Methods': 'GET, POST, PUT, DELETE',
    
    # Rate limiting
    'X-RateLimit-Limit': '100',
    'X-RateLimit-Remaining': '95',
    
    # Security
    'Strict-Transport-Security': 'max-age=31536000',
    'X-Content-Type-Options': 'nosniff',
}

// Headers HTTP comunes – configuración en Ktor o java.net.http
val headers = mapOf(
    // Autenticación
    "Authorization"                to "Bearer eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9...",

    // Content negotiation
    "Content-Type"                 to "application/json",
    "Accept"                       to "application/json",

    // Caching
    "Cache-Control"                to "max-age=3600",
    "ETag"                         to "\"33a64df551425fcc55e4d42a148795d9f25f89d4\"",

    // CORS
    "Access-Control-Allow-Origin"  to "*",
    "Access-Control-Allow-Methods" to "GET, POST, PUT, DELETE",

    // Rate limiting
    "X-RateLimit-Limit"            to "100",
    "X-RateLimit-Remaining"        to "95",

    // Security
    "Strict-Transport-Security"    to "max-age=31536000",
    "X-Content-Type-Options"       to "nosniff",
)

// Aplicar en java.net.http:
// val reqBuilder = HttpRequest.newBuilder()
// headers.forEach { (k, v) -> reqBuilder.header(k, v) }

import java.net.*;
import java.net.http.*;
import java.util.*;

// Headers HTTP comunes en java.net.http
var headers = Map.of(
    "Authorization",             "Bearer eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9...",
    "Content-Type",              "application/json",
    "Accept",                    "application/json",
    "Cache-Control",             "max-age=3600",
    "X-RateLimit-Limit",         "100",
    "X-RateLimit-Remaining",     "95",
    "Strict-Transport-Security", "max-age=31536000",
    "X-Content-Type-Options",    "nosniff"
);

// Aplicar a una petición:
var reqBuilder = HttpRequest.newBuilder().uri(URI.create("https://api.example.com/users"));
headers.forEach(reqBuilder::header);
var request = reqBuilder.GET().build();