commit local

alumnos/59104-julia-locamuz/20-04-2021/.vscode/settings.json

@@ -0,0 +1,3 @@
+{
+    "python.pythonPath": "/usr/bin/python3"
+}

alumnos/59104-julia-locamuz/20-04-2021/argparse_ej2.py

@@ -0,0 +1,12 @@
+import argparse
+
+parser = argparse.ArgumentParser()
+parser.add_argument('file', help='file')
+parser.add_argument('nro', type=int, help='nro bytes a leer')
+parser.add_argument('-f',help='funcion file', action='store_true')
+parser.add_argument('-n',help='funcion nro bytes a leer', action='store_true')
+args = parser.parse_args()
+if args.f: 
+    path = args.file
+if args.n: 
+    numero = args.nro

alumnos/59104-julia-locamuz/20-04-2021/ej2.py

@@ -0,0 +1,66 @@
+from multiprocessing import Process, Pipe
+import multiprocessing
+import os
+import argparse
+import math
+import sys
+
+
+def enviar_pipe(humano, leido):
+    print("\nENVIANDO INFORMACION DEL PIPE...")
+    humano.send(leido)
+
+def recibir_pipe(humano):
+    print("\nRECIBIENDO INFORMACION DEL PIPE ")
+    s = humano.recv()
+    if s == b'':
+        sys.exit()
+    print(s, type(s), type(humano))
+
+def cantidad_bloques(path, numOfBytes):
+    stat = os.stat(path).st_size
+    if stat % numOfBytes == 0: 
+        bloques = stat / numOfBytes
+    else: 
+        bloques = math.ceil(stat/ numOfBytes)
+    return bloques
+
+if __name__ == '__main__':
+
+    import argparse_ej2
+
+    path = argparse_ej2.path
+    numOfBytes = argparse_ej2.numero
+
+    padre, hijo = Pipe()
+    ph1 = Process(target=recibir_pipe, args=(hijo,))
+
+    fd = os.open(path, os.O_RDONLY)
+
+    bloques = cantidad_bloques(path, numOfBytes)
+
+    ph1.start()
+    #print(multiprocessing.active_children())
+    bandera = True
+    try:
+        while bandera: 
+            leido = os.read(fd, numOfBytes)
+            enviar_pipe(padre, leido)
+            if len(leido) == 0:
+                print('El pipe esta vacio ya no hay informacion que enviar')
+                sys.exit()
+                break
+            print("bloque de ", len(leido),"enviado al pipe")
+            print(recibir_pipe(hijo))
+            if ph1.is_alive() is False:
+                bandera = False
+        ph1.join()
+    except EOFError as e:
+        print(e.__str__)
+        padre.close()
+        hijo.close() 
+    finally: 
+        print("termino el programa")
+        ph1.terminate()
+        padre.close()
+        hijo.close()

alumnos/59104-julia-locamuz/20-04-2021/multipipeEJ.py

@@ -0,0 +1,25 @@
+
+from multiprocessing import Process, Pipe
+import os
+
+
+def pipe(humano, data):
+    humano.send(data)
+    humano.close()
+
+if __name__ == '__main__':
+
+    padre, hijo = Pipe()
+    ph1 = Process(target=pipe, args=(hijo,['tomate', 22, 'manzana'],))
+    #print(ph1.pid) # None , pq todavia no lo inicializo
+    #ph1.start()
+    #print(ph1.pid)
+    ph1.start()
+    ph2 = Process(target=pipe,args=(hijo,['conejo', 22, 'manzana'],))
+    ph3 = Process(target=pipe, args=(hijo,['tomate', 65, 'Juan'],))
+    print(padre.recv())
+    ph1.join()
+
+    ph2.start()
+    print(padre.recv())
+

alumnos/59104-julia-locamuz/20-04-2021/txt.txt

@@ -0,0 +1,15 @@
+Python fue creado a finales de los ochenta4​ por Guido van Rossum en el Centro para las Matemáticas y la Informática (CWI, Centrum Wiskunde & Informatica), en los Países Bajos, como un sucesor del lenguaje de programación ABC, capaz de manejar excepciones e interactuar con el sistema operativo Amoeba.5​
+
+El nombre del lenguaje proviene de la afición de su creador por los humoristas británicos Monty Python.6​
+
+Guido Van Rossum es el principal autor de Python, y su continuo rol central en decidir la dirección de Python es reconocido, refiriéndose a él como Benevolente Dictador Vitalicio (en inglés: Benevolent Dictator for Life, BDFL); sin embargo el 12 de julio de 2018 declinó de dicha situación de honor sin dejar un sucesor o sucesora y con una declaración altisonante:7​
+
+Entonces, ¿qué van a hacer todos ustedes? ¿Crear una democracia? ¿Anarquía? ¿Una dictadura? ¿Una federación?
+Guido van Rossum8​
+El 20 de febrero de 1991, van Rossum publicó el código por primera vez en alt.sources, con el número de versión 0.9.0.9​ En esta etapa del desarrollo ya estaban presentes clases con herencia, manejo de excepciones, funciones y los tipos modulares, como: str, list, dict, entre otros. Además en este lanzamiento inicial aparecía un sistema de módulos adoptado de Modula-3; van Rossum describe el módulo como «una de las mayores unidades de programación de Python».4​ El modelo de excepciones en Python es parecido al de Modula-3, con la adición de una cláusula else.5​ En el año 1994 se formó comp.lang.python, el foro de discusión principal de Python, marcando un hito en el crecimiento del grupo de usuarios de este lenguaje.
+
+Python alcanzó la versión 1.0 en enero de 1994. Una característica de este lanzamiento fueron las herramientas de la programación funcional: lambda, reduce, filter y map. Van Rossum explicó que «hace 12 años, Python adquirió lambda, reduce(), filter() y map(), cortesía de Amrit Perm, un hacker informático de Lisp que las implementó porque las extrañaba».10​
+
+
+
+

alumnos/59104-julia-locamuz/20-04-2021/txt2.txt

@@ -0,0 +1,17 @@
+ME GUSTA LA PIZZA
+
+LAS EMPANADAS
+
+IR A YOGA
+
+
+
+CANTARRRRRRRR Y 
+MUCHO MAS
+
+
+KAAJAJAJJAA
+
+
+
+CHAU

alumnos/59104-julia-locamuz/Asyncio/chained/chained.md

@@ -0,0 +1,53 @@
+Para poder explicar 'chained.py' primero hay que explicar 3 conceptos muy importantes del modulo asyncio,
+dando por hecho que se conoce la funcionalidad del mismo: 
+    'asyncio is a library to write concurrent code using the async/await syntax'
+
+There are three main types of awaitable objects: coroutines, Tasks, and Futures.
+
+*Coroutines
+
+Python coroutines are awaitables and therefore can be awaited from other coroutines
+a coroutine function: an async def function;
+
+*Tasks
+
+Tasks are used to schedule coroutines concurrently.
+When a coroutine is wrapped into a Task with functions like asyncio.create_task() the coroutine is automatically scheduled to run soon
+
+*Futures
+
+A Future is a special low-level awaitable object that represents an eventual result of an asynchronous operation.
+When a Future object is awaited it means that the coroutine will wait until the Future is resolved in some other place.
+
+Teniendo estos conceptos claros, se puede ver en el script que hay 4 couroutines, siendo main()  'the top-level entry point “main()” function' 
+Las otras tres son 'primera', 'segunda' y 'chained'
+
+EXPLICACION DEL CODIGO chained.py
+
+En primer lugar se ejecuta el bloque de se encuentra en 'if __name__ = '__main__'':
+    1) random.seed(414) 
+        La función semilla (seed) se usa para guardar el estado de una función aleatoria, de modo que pueda generar los mismos números aleatorios en múltiples ejecuciones del código en la misma máquina o en diferentes máquinas (para un valor semilla específico)
+    2) Se importa el modulo sys y se hace uso de sys.argv (lista de argumentos de la línea de comandos pasados a un script de Python. argv[0] es el nombre del script ) 
+        si no se le pasa argumentos al script (es decir si len(argv) == 1) se toma como parametros una lista dada, 
+        si no se toman esos argumentos proporcionados por el usuario convirtiendolos en int con un mapeo 
+    3) se inicia un contador 
+    4) se utiliza asyncio.run(main()) para correr la funcion principal (top-level entry point “main()” function) 
+        proporcionandole una lista de argumentos
+
+Al ejecutarse la funcion main() se ejecuta un ' awaitable asyncio.gather ' , lo que hace es programar tres llamadas al mismo tiempo, es decir ejecutar los 'awaitable objects' en la secuencia de los args pasados como parametro al mismo tiempo (If any awaitable in aws is a coroutine, it is automatically scheduled as a Task)
+En este caso se llama n veces a la corrutina chain(n) dependiendo de cuantos parametros le pase al programa, por defecto 3 veces, y se las envuelve en tasks.
+
+Por cada llamada a chain:
+    - se inicia 'cronometro'
+    - se llama mediante un await a la corutina 'primera' pasandole como parametro n (prim = await primera(n))
+        - dentro de primera se ejecuta un await asyncio.sleep(i) siendo i  un numero random del 0 al 9 
+        -->  Pausará la tarea actual y permitirá que se ejecuten otras tasks
+            Esta función toma un solo parámetro que es un número de segundos, y devuelve un **futuro** que aún no está marcado como hecho, pero que será cuando haya pasado el número especificado de segundos. 
+
+            Al usar asyncio.sleep con un parámetro distinto de cero, vale la pena señalar que el hecho de que el futuro se haga cuando haya pasado el número de segundos no significa que su tarea siempre se reactivará en ese momento. De hecho, puede volver a activarse en cualquier momento después de ese tiempo, ya que solo puede activarse cuando no se está ejecutando ninguna otra tarea en el bucle de eventos.
+
+            The distinction between a Coroutine and a Future is important. A Coroutine’s code will not be executed until it is awaited. A future represents something that is executing anyway, and simply allows your code to wait for it to finish, check if it has finished, and fetch the result if it has.
+
+    - al haberse devuelto un valor en la funcion, es decir al haber finalizado la misma, se ejecuta corrutina segunda (segu = await segunda(n, prim)) pasandole como parametro prim (objeto futuro)
+
+Estas llamadas se van ejecutando de manera concurrente, el orden se basa en su parametro i, la de menor i sera la primera en pasar a la corrutina 'primera' y 'segunda'. Cada chain debe completar la corrutina 'primera' para pasar a la 'segunda' (por eso el nombre del programa chained.py) pero las distintas llamadas a chain son asincronas. Pueden terminar en cualquier orden (depende del numero random)

alumnos/59104-julia-locamuz/Asyncio/chained/chained.py

@@ -0,0 +1,77 @@
+import asyncio
+import random
+import time
+
+async def primera(n: int) -> str:
+
+    # con gather se ejecutan concurrentemente cada corrutinas por cada parametro proporcionado
+
+    i = random.randint(0, 10)
+    print(f"primera({n}) esperando {i}s.")
+
+    # will pause the current task and allow other tasks to be executed
+    #   This function takes a single parameter which is a number of seconds, 
+    # and returns a future which is not marked done yet but which will be when the specified
+    # number of seconds have passed
+
+    # las tasks (n tasks) le otorgan el procesamiento a otra task de la pila aqui 
+    await asyncio.sleep(i)
+    '''
+    Lanzando primera
+    primera(1) esperando 6s.
+    Lanzando primera
+    primera(2) esperando 5s.
+    Lanzando primera
+    primera(3) esperando 9s.
+
+    '''
+
+    result = f"result{n}-A"
+    print(f"Retornando primera({n}) == {result}.")
+    return result
+
+async def segunda(n: int, arg: str) -> str:
+    i = random.randint(0, 10)
+    print(f"segunda{n, arg} esperando {i}s.")
+    await asyncio.sleep(i)
+    result = f"result{n}-B => {arg}"
+    print(f"Retornando segunda{n, arg} => {result}.")
+    return result
+
+async def chain(n: int) -> None:
+    start = time.perf_counter()
+    print("Lanzando primera")
+    # If the process the future ( creado a partir de el  await asyncio.sleep(i)) 
+    # represents has finished and returned a value then 
+    # the await statement immediately returns that value.
+    prim = await primera(n)
+
+    # se ejecuta el codigo anterior al sleep de cada task y se procede... 
+
+    # recien cuando se devuelve un valor en la funcion a los i segundos 
+    print("Lanzando Segunda")
+
+    # le pasamos como resultado el result que es un objeto futuro que a los i segundos habra finalizado (f.done() returns True)
+
+    segu = await segunda(n, prim)
+    '''
+    el del i mas pequeno: 
+    Lanzando Segunda
+    segunda(2, 'result2-A') esperando 3s.
+    '''
+    end = time.perf_counter() - start
+    print(f"-->Encadenado result{n} => {segu} (tomó {end:0.2f} s).")
+
+async def main(*args):
+    await asyncio.gather(*(chain(n) for n in args))
+    # asyncio.gather( chain(n1), chain(n2), chain(n3), ...)
+    # default: asyncio.gather( chain(1), chain(2), chain(3))
+
+if __name__ == "__main__":
+    import sys
+    random.seed(414)
+    args = [1, 2, 3] if len(sys.argv) == 1 else map(int, sys.argv[1:])
+    start = time.perf_counter()
+    asyncio.run(main(*args))
+    end = time.perf_counter() - start
+    print(f"Program finished in {end:0.2f} seconds.")

alumnos/59104-julia-locamuz/Asyncio/chained/example.py

@@ -0,0 +1,46 @@
+import asyncio
+
+async def fetch_data():
+    print('start fetching')
+    # sleep() always suspends the current task, allowing other tasks to run.
+    await asyncio.sleep(2) # otorga procesamiento a otra task de la pila --> print_numbers
+    print('done fetching') # dsps de dormir 2 segundos y darle procesamiento a print_numbers (le alcanzo para imprimir 4 digitos)
+    return {'data': 1} # finaliza --> control a otra task de la pila
+
+async def print_numbers():
+    print('start printing') # tengo 2 segundos 
+    for i in range(10):
+        print(i)
+        await asyncio.sleep(0.5) # con mis 2 segundos puedo imprimir 4 numeros --> sigue fetch_data --> finaliza --> sigo imprimiendo
+
+async def main():
+    # The asyncio.create_task() function to run coroutines concurrently as asyncio Tasks.
+
+    # When a coroutine is wrapped into a Task with functions like asyncio.create_task()
+    # the coroutine is automatically scheduled to run soon
+    task2 = asyncio.create_task(print_numbers())  # crea task pero no la corre hasta que no se realiza await 
+
+    # en mi "pila de tasks" tengo 2 tasks...
+    await fetch_data() # corre fetch data
+    await task2
+
+
+# event loop to run the program 
+# The asyncio.run() function to run the top-level entry point “main()” function
+asyncio.run(main())
+
+'''
+start fetching
+start printing
+0
+1
+2
+3
+done fetching
+4
+5
+6
+7
+8
+9
+'''

alumnos/59104-julia-locamuz/Asyncio/chained/intro.md

@@ -0,0 +1,38 @@
+https://rico-schmidt.name/pymotw-3/asyncio/index.html
+
+Mientras que el módulo threading implementa concurrencia a través de hilos de aplicación y multiprocessing implementa la concurrencia usando procesos del sistema, asyncio utiliza un enfoque de un solo hilo y un solo proceso en el que partes de una aplicación cooperan para cambiar tareas explícitamente en momentos óptimos.
+
+async def = coroutine object que se puede ejecutar
+
+
+There are three main types of awaitable objects: coroutines, Tasks, and Futures.
+
+*Coroutines
+
+Python coroutines are awaitables and therefore can be awaited from other coroutines
+a coroutine function: an async def function;
+
+*Tasks
+
+Tasks are used to schedule coroutines concurrently.
+When a coroutine is wrapped into a Task with functions like asyncio.create_task() the coroutine is automatically scheduled to run soon
+
+*Futures
+
+A Future is a special low-level awaitable object that represents an eventual result of an asynchronous operation.
+When a Future object is awaited it means that the coroutine will wait until the Future is resolved in some other place.
+
+
+
+$$$ sleep() always suspends the current task, allowing other tasks to run.
+coroutine asyncio.sleep(delay, result=None)
+-Block for delay seconds.
+-If result is provided, it is returned to the caller when the coroutine completes.
+
+
+Running Tasks Concurrently
+
+$$$ awaitable asyncio.gather(*aws, return_exceptions=False)
+-Run awaitable objects in the aws sequence concurrently.
+-If any awaitable in aws is a coroutine, it is automatically scheduled as a Task. IMPORTANTE: no necesito crear las tasks
+-If all awaitables are completed successfully, the result is an aggregate list of returned values. The order of result values corresponds to the order of awaitables in aws.