Primer commit

pruebas_conceptos/async/async_con_procesos.py

@@ -0,0 +1,42 @@
+import asyncio
+from multiprocessing import Process
+from datetime import datetime
+import time
+import os
+
+def log(msg):
+    print(f"[{datetime.now().strftime('%H:%M:%S')}] {msg}")
+
+def tarea_pesada_cpu():
+    pid = os.getpid()
+    log(f"🔧 Proceso pesado INICIADO (PID: {pid})")
+    suma = sum(i * i for i in range(10**8))  # Simula carga pesada
+    log(f"🔧 Proceso pesado TERMINADO. Resultado: {suma} (PID: {pid})")
+
+async def tarea_ligera_async(nombre, segundos):
+    log(f"⚡ {nombre} INICIADA")
+    await asyncio.sleep(segundos)
+    log(f"⚡ {nombre} TERMINADA")
+
+async def main():
+    log("🎬 Iniciando tareas")
+
+    # Crear y lanzar un proceso en paralelo (cálculo pesado)
+    proceso = Process(target=tarea_pesada_cpu)
+    proceso.start()
+
+    log(f"🕵️ Proceso pesado lanzado con PID {proceso.pid}. Búscalo en el Administrador de tareas (pestaña Detalles).")
+
+    # Mientras tanto, corremos tareas asincrónicas
+    await asyncio.gather(
+        tarea_ligera_async("Tarea 1", 1),
+        tarea_ligera_async("Tarea 2", 2)
+    )
+
+    # Esperar a que el proceso termine
+    proceso.join()
+
+    log("🏁 Todas las tareas finalizadas")
+
+if __name__ == "__main__":
+    asyncio.run(main())

pruebas_conceptos/async/cliente.py

@@ -0,0 +1,21 @@
+import asyncio
+
+async def enviar_mensajes():
+    reader, writer = await asyncio.open_connection('127.0.0.1', 8888)
+
+    while True:
+        mensaje = input("Escribe un mensaje (o 'salir'): ")
+        if mensaje.lower() == 'salir':
+            break
+
+        writer.write(mensaje.encode())
+        await writer.drain()
+
+        data = await reader.read(100)
+        print(f"💬 Respuesta del servidor: {data.decode()}")
+
+    print("🔚 Cerrando conexión")
+    writer.close()
+    await writer.wait_closed()
+
+asyncio.run(enviar_mensajes())

pruebas_conceptos/async/esperar_await.py

@@ -0,0 +1,37 @@
+import asyncio
+from datetime import datetime
+
+def log(msg):
+    print(f"[{datetime.now().strftime('%H:%M:%S')}] {msg}")
+
+async def tarea_asincrona():
+    log("Tarea asincrónica INICIADA")
+    await asyncio.sleep(5)
+    log("Tarea asincrónica TERMINADA")
+
+async def tarea_paralela():
+    log("Tarea paralela INICIADA")
+    await asyncio.sleep(1)
+    log("Tarea paralela TERMINADA")
+
+async def main():
+    log("Iniciando flujo principal")
+
+    # Lanzar tarea paralela (no bloquea)
+    asyncio.create_task(tarea_paralela())
+
+    # Lanzar tarea asincrónica, pero NO esperarla aún
+    tarea = asyncio.create_task(tarea_asincrona())
+
+    # Hacer otras cosas mientras tanto
+    log("Realizando acción 1 mientras tareas corren...")
+    await asyncio.sleep(1)
+    log("Realizando acción 2 mientras tareas corren...")
+
+    # Ahora sí esperar que tarea_asincrona termine
+    await tarea
+
+    log("Flujo principal FINALIZADO")
+
+# Ejecutar el flujo
+asyncio.run(main())

pruebas_conceptos/async/prueba_async.py

@@ -0,0 +1,14 @@
+import asyncio
+
+async def tarea(nombre, segundos):
+    print(f"{nombre} empieza")
+    await asyncio.sleep(segundos)
+    print(f"{nombre} termina después de {segundos} segundos")
+
+async def main():
+    await asyncio.gather(
+        tarea("Tarea A", 2),
+        tarea("Tarea B", 3)
+    )
+
+asyncio.run(main())

pruebas_conceptos/async/server_loop.py

@@ -0,0 +1,28 @@
+import asyncio
+
+async def manejar_cliente(reader, writer):
+    addr = writer.get_extra_info('peername')
+    print(f"📡 Conexión desde {addr}")
+
+    while True:
+        data = await reader.read(100)
+        if not data:
+            print(f"❌ Cliente {addr} desconectado")
+            break
+        mensaje = data.decode()
+        print(f"📨 Mensaje de {addr}: {mensaje}")
+        writer.write(f"✅ Recibido: {mensaje}".encode())
+        await writer.drain()
+
+    writer.close()
+    await writer.wait_closed()
+
+async def main():
+    server = await asyncio.start_server(manejar_cliente, '127.0.0.1', 8888)
+    addr = server.sockets[0].getsockname()
+    print(f"🚀 Servidor escuchando en {addr}")
+
+    async with server:
+        await server.serve_forever()
+
+asyncio.run(main())