Marcos Dione: I-got-myself-a-parser

So, only two days later I already have not only (what looks like) a full parser, which has already landed in develop, I also implemented the first big change in the grammar and semantics: keywords are allowed mixed with positional parameters; in case of command execution, they're converted to positional options; in normal function calls they're just put where they belong.

In the future there will be more restrictive checks so the Python part of the language does not change, but right now I'm interested in adding more small changes like that. For instance, as I said before, allowing the options to have the right amount of hyphens (-o, -option or --option), because right now I have code that prefixes with -- to anything longer than 1 character. The alternative would be to have another _special_arg to handle that. And while I'm at it, also allow --long-options. This is only possible because there's an specific check in the code for that. Unluckily this does not mean I can do the same trick for executable names, so I still lack absolute and relative commands, and you still have to write osmpbf-outline as osmpbf_outline. Maybe I'll just depart a little more from the grammar and allow those, but I have to deep think about it (that is, let the problem be in the back of my head for a while). What I can also do is to allow to use several times the same option (git ('comit-tree', p='fae76fae7', p='7aa3f63', 'a6fa33428bda9832') is an example that comes to mind) because it's another check not really done by the grammar.

In any case, it's quite a leap in the language. I just need to test it a little more before doing the next release, which surely will be the 0.5. I'll keep you posted!


ayrton python

Marcos Dione: breaking-off

Having my own version of the python parser has proven, so far, to be clumsy and chaotic. Clumsy because it means that I need a special interpreter just to run my language (which in any case uses an interpreter!), chaotic because the building of such interpreter has proven to not work stably in different machines. This means that currently it only works for me.

Because of this and because I wanted even more control over the parser (who said allowing to write things like rsync(--help)?), I decided to check my options. A friend of mine, more used to playing with languages, suggested using pypy to create my own parser, but that just lead me a little further: why not outright 'steal' pypy's parser? After all, they have their own, which is also generated from Python's Python.adsl.

In fact it took me one hour to port the parser and a couple more porting the AST builder. This included porting them to Python3 (both by running 2to3 and then applying some changes by hand, notably dict.iteritems -> dict.items) and trying to remove as much dependency on the rest of pypy, specially from rpython.

The last step was to migrate from their own AST implementation to Python's, but here's where (again) I hit the last brick wall: the ast.AST class and subclasses are very special. They're implemented in C, but the Python API does not allow to create nodes with the line and column info. for a moment I contemplated the option of creating another extension (that is, written in C) to make those calls, but the the obvious solution came to mind: a massive replacement from:

return ast.ASTClass ([params], foo.lineno, foo.column)

into:

new_node = ast.ASTClass ([params])
new_node.lineno = foo.lineno
new_node.column = foo.column
return new_node

and some other similar changes. See here if you're really interested in all the details . I can only be grateful for regular expressions, capturing groups and editors that support both.

The following code is able to parse and dump a simple python script:

#! /usr/bin/env python3
import ast

from pypy.interpreter.pyparser import pyparse
from pypy.interpreter.astcompiler import astbuilder

info= pyparse.CompileInfo('setup.py', 'exec')
p= pyparse.PythonParser(None)
t= p.parse_source (open ('setup.py').read(), info)
a= astbuilder.ast_from_node (None, t, info)

print (ast.dump (a))

The result is the following (formatted by hand):

Module(body=[
    ImportFrom(module='distutils.core', names=[alias(name='setup', asname=None)], level=0),
    Import(names=[alias(name='ayrton', asname=None)]),
    Expr(value=Call(func=Name(id='setup', ctx=<class '_ast.Load'>), args=None, keywords=[
        keyword(arg='name', value=Str(s='ayrton')),
        keyword(arg='version', value=Attribute(value=Name(id='ayrton', ctx=<class '_ast.Load'>), attr='__version__', ctx=<class '_ast.Load'>)),
        keyword(arg='description', value=Str(s='a shell-like scripting language based on Python3.')),
        keyword(arg='author', value=Str(s='Marcos Dione')),
        keyword(arg='author_email', value=Str(s='mdione@grulic.org.ar')),
        keyword(arg='url', value=Str(s='https://github.com/StyXman/ayrton')),
        keyword(arg='packages', value=List(elts=[Str(s='ayrton')], ctx=<class '_ast.Load'>)),
        keyword(arg='scripts', value=List(elts=[Str(s='bin/ayrton')], ctx=<class '_ast.Load'>)),
        keyword(arg='license', value=Str(s='GPLv3')),
        keyword(arg='classifiers', value=List(elts=[
            Str(s='Development Status :: 3 - Alpha'),
            Str(s='Environment :: Console'),
            Str(s='Intended Audience :: Developers'),
            Str(s='Intended Audience :: System Administrators'),
            Str(s='License :: OSI Approved :: GNU General Public License v3 or later (GPLv3+)'), Str(s='Operating System :: POSIX'),
            Str(s='Programming Language :: Python :: 3'),
            Str(s='Topic :: System'),
            Str(s='Topic :: System :: Systems Administration')
        ],
        ctx=<class '_ast.Load'>))
    ], starargs=None, kwargs=None))
])

The next steps are to continue removing references to pypy code, and make sure it can actually parse all possible code. Then I should revisit the harcoded limitations in the parser (in particular in this loop and then be able to freely format program calls :).

Interesting times are arriving to ayrton!

Update: fixed last link. Thanks nueces!


python ayrton

Facundo Batista: PyCamp 2015, en La Serranita, Córdoba


Como casi siempre a Córdoba, fuí y volví en micro (porque en el colectivo en general duermo pasablemente bien, entonces aprovecho la noche, y no pierdo medio día "para viajar"). Esta vez, por otro lado, fuí un día antes, porque tenía que hacer un trámite en Córdoba Capital, así que estuve el jueves hospedado en la casa de Nati y Matías, trabajando durante el día, jugando juegos de mesa durante la noche.

El viernes a la mañana hicimos el viaje hasta La Serranita con los chicos. Llegamos a media mañana, y ahí se dió la situación de siempre, que es muchas veces esperada: saludar y abrazar a viejos amigos que uno no puede ver tan seguido (y a cuatro o cinco nuevos que uno todavía no conoce :) ).

El grupo recién reunido, charlando sobre las propuestas

Como quedaron planeadas las actividades


El lugar estuvo muy bueno. Quizás me podría quejar que el salón principal era demasiado ajustado, y que las comidas eran en una hostería a cuatro cuadras de distancia, pero el resto estuvo más que bien. No sólo las instalaciones (habitaciones, parque, quincho, etc, etc), sino la atención humana. Un lujo.

Hasta buena internet tuvimos en este PyCamp, ya que estábamos en la red vecinal abierta que Nico Echaniz y amigos montaron en La Quintana y ciudades aledañas. Eso sí, notamos que cuando teníamos problemas con lo que era comunicaciones el tema estaba en el router que estábamos usando (y eso que terminamos poniendo uno muy bueno). Decidimos que había que invertir en hardware un poco más pro (no algo "de uso hogareño bueno" sino algo "profesional")... veremos cuanto cuesta, pero creo que vamos a gastar unos mangos ahí, ya que nos queda no sólo para el PyCamp sino para otros eventos.

Una terraza dos niveles más arriba que la sala de laburo

Pequeño parque en uno de los niveles

A nivel proyectos y Python: lo de siempre... se hacen mil cosas, desde laburar en proyectos estables hasta delirar con cosas nuevas, se mejoran cosas arrancadas de antes, se agregan funcionalidades, se empiezan proyectos que se terminan en esos cuatro días, se arrancan cosas que luego duran mucho tiempo, etc... pero lo más importante no pasa por ahí.

El núcleo del evento es humano. Charlar con gente que conocés de siempre, y podés delirar ideas, proyectos nuevos, o simplemente charlar. Y conocer gente nueva. Pibes que están haciendo cosas locas o no, con laburos copados o no, con vidas interesantes o no. Pero charlar, compartir tiempo, ver como las otras personas encaran un proyecto, qué aportan, como ayudarlos, como transmitirles experiencias.

El programar Python es casi una excusa para que todo lo otro suceda. Y digo "casi" porque sí, claro, lo que se programa y hace está buenísimo también :D

En el comedor, almorzando

En la sala principal de laburo (no era grande, pero no era la única)

En ese aspecto, yo estuve principalmente con dos proyectos. Por un lado filesync server, recientemente liberado open source, con un cambio muy grande que empecé el jueves mismo estando en la casa de Nati y continué intermitentemente durante los cuatro días de PyCamp.

El otro proyecto en el que invertí mucho tiempo es fades que desarrollo principalmente con Nico. Es que se enganchó mucha gente que le gustaba lo que fades ofrece, y aportaron un montón de ideas buenísimas. ¡Y no sólo ideas! También código, branches que mergeamos o que todavía tenemos que revisar. Ya iremos metiendo todo, y queremos hacer un release en las próximas semanas. Estén atentos, porque fades ahora hace cosas que te vuela la peluca :D

Pero no sólo trabajé en eso. También porté Tritcask a que trabaje simultaneamente con Python 2 y Python 3 (arranqué sólo con esto, pero el 70% del laburo lo hicimos juntos con SAn). Y estuvimos buscando cómo hacer para detectar cuanto de un subtítulo matchea con las voces de un video, de manera de poder determinar si está bien sincronizado o no. Y estuve haciendo algo de código asincrónico usando asyncio. Y estuve charlando con SAn, DiegoM, Bruno y Nico Echaniz sobre una especie de Repositorio Federado de Contenido Educativo. Y estuve ayudando a gente a trabajar en Python mismo durante un cortito Python Bug Day (Jairo solucionó un issue y medio!!).

Camino al río

Recorriendo la vera del río, saltando de piedra en piedra

El mejor asado de un PyCamp, ever

Y tomé sol. Y tuve en mis manos una espada de verdad por primera vez. Y caminé por el costado del río saltando de piedra en piedra. Y comí un asadazo (entre el centenar de kilos de comida que ingeríamos por día por persona). Y conocí La Serranita. Y charlé mil. Y usé un sistema de realidad virtual. Y jugué a muchos juegos de mesa.

Y abracé amigos.

Manuel Kaufmann (Humitos): Paseando por la TV

Durante toda esta semana nos estuvimos paseando con @EllaQuimica por diferentes canales de televisión de aquí de Cochabamba, Bolivia. Incluso, fuimos a uno que sale a nivel nacional :D

El motivo: dar a conocer los cursos y talleres que dimos durante esta semana.

Aquí pueden ver los videos que subimos a YouTube como para que quede algún registro:


Ese día lo publicaba en el canal de Python Argentina:

20:41 <Facu> humitos, es un screener! cuando sale en DVD así lo bajo bien?

20:42 <humitos> Facu: primero se tiene que estrenar en cines

También el día de hoy 20 de Agosto, salimos en la edición impresa del diario "Los tiempos" de Cochabamba, Bolivia.

IMG_20150820_163716.thumbnail.jpg

Nota en el diario "Los tiempos" (link)

Además, unos pocos minutos antes de que comience la charla de "Introducción a Pyhon" ayer en el mARTadero, me hicieron una entrevista que salió publicada en "Urbana Web"

Vale la pena decir que salimos en otros tres programas más de televisión que no pudimos grabar y que tampoco conseguimos los archivos en formato digital por parte de los canales.

Entonces, ¿Cuántas veces has visto que se hable de Python, Ciencia, Django y programación en la Televisión? Bueno, creo que hoy, entre todos, lo estamos logrando y estamos pudiendo acercar la programación de computadoras a más personas.

¡Gracias a todos ustedes por apoyar esta locura itinerante! Además, hay que destacar el trabajo de Jhade, nuestro contacto de prensa del Proyecto mARTadero.

Mariano Guerra: Enabling CORS in Solr in a Cloudera environment

This is a continuation of this post: Enable CORS in Apache Solr but this time for an instance that is running in cloudera.

No idea how it was installed since it was already there, but doing some investigation and avoiding reading the docs at all costs I arrived at this solution.

The idea of this post is to make you avoid reading the docs too!

First I will give names to some things that may be different for you:

CDH=/opt/cloudera/parcels/CDH-5.3.2-1.cdh5.3.2.p0.10/
CDH_USER=cloudera-scm
CDH_GROUP=cloudera-scm

Now do:

cd $CDH/jars/
wget http://repo1.maven.org/maven2/org/eclipse/jetty/jetty-servlets/9.1.5.v20140505/jetty-servlets-9.1.5.v20140505.jar
wget http://repo1.maven.org/maven2/org/eclipse/jetty/jetty-util/9.1.5.v20140505/jetty-util-9.1.5.v20140505.jar

cd $CDH/lib/bigtop-tomcat/lib/
ln -s $CDH/jars/jetty-servlets-9.1.5.v20140505.jar
ln -s $CDH/jars/jetty-util-9.1.5.v20140505.jar

chown $CDH_USER.$CDH_GROUP jetty-servlets-9.1.5.v20140505.jar
chown -h $CDH_USER.$CDH_GROUP jetty-servlets-9.1.5.v20140505.jar

chown $CDH_USER.$CDH_GROUP jetty-util-9.1.5.v20140505.jar
chown -h $CDH_USER.$CDH_GROUP jetty-util-9.1.5.v20140505.jar

Then create $CDH/lib/bigtop-tomcat/bin/setenv.sh with your favorite text editor and put in it the following:

CLASSPATH="$CATALINA_HOME"/lib/jetty-util-9.1.5.v20140505.jar:"$CATALINA_HOME"/lib/jetty-servlets-9.1.5.v20140505.jar:"$CATALINA_HOME"/lib/servlet-api.jar

Open $CDH/etc/solr/tomcat-conf.dist/WEB-INF/web.xml with your text editor and follow the instructions at Enable CORS in Apache Solr

The way to know if it worked is to open the Solr admin panel, if it loads it works, if it doesn't look at the logs, mine are at /var/log/solr/. To be sure that the classpath was set correctly from setenv.sh look in the solr admin page in the "Java Properties" section for the java.class.path variable, it should have the class path you set in setenv.hs plus some extra stuff (mainly bootstrap.jar).

If the admin page doesn't load (tomcat 404) look at the logs, some class loading error may be happening, comment the config you added in web.xml and restart.

The version I'm using of the jetty jars is because newer versions are compiled for java 1.8 and I have 1.7, use older/newer depending on your java version.

Martín Gaitán: Curso de Python para ciencias e ingeniería, nueva edición

/images/Newsletter4-Banner_20120705_12-44-50-800.jpg

¡Atención!

¿Estás interesado en que dicte este curso, de manera intensiva, en tu laboratorio o empresa? Contactame.

Está abierta la inscripción para el nuevo dictado de mi curso de introducción a Python para ciencias e ingenierías, en la Facultad de Ciencias Exáctas, Físicas y Naturales de la Universidad Nacional de Córdoba (aprobado como curso de extensión - Resolución 1272/2015, bajo el nombre "Python como herramienta para la ingeniería") desde el miércoles 14 de ocubre de 18 a 22hs, durante 5 semanas.

Este curso una versión mejorada del que dicté en la Facultad de Matemática, Física y Astronomía en mayo pasado, avalado como curso de extensión (Resolución HCD 107/2015)

El precio está absolutamente subsidiado por las ganas de que más ingenieros e investigadores programen Python. No te demores en anotarte , los cupos son muy limitados!

Se entregarán certificados a quienes completen asistencia.

Lo que hay que saber

Fecha de inicio:
  miércoles 14 de octibre de 2015, 18hs.
Lugar: Laboratorio de computación (aula 112), FCEFyN.
Duración: 5 clases de 4hs (incluye coffee break), miércoles de 18 a 22hs
Docente: Ing. Martín Gaitán
Material: https://github.com/mgaitan/curso-python-cientifico

Aranceles

  • $500.– estudiantes y docentes de la UNC.
  • $750.– estudiantes y docentes de otras universidades públicas.
  • $1.000.– público en general.

Inscripción

Deberá completar este formulario

Luego se deberá abonar a través de un depósito o transferencia bancaria a la siguiente cuenta:

Titular: UNC - Fac. Cs. Exactas, Físicas y Naturales
CBU: 01102132 20021319046022
CUIT: 30-54667062-3
cuenta Corriente Bco. Nación Argentina - Suc. Córdoba  213-19046/02
Sucursal Nro. 1570

Una vez realizado el pago, deben enviarnos el comprobante de pago y documento que acredite el descuento (si aplica) a los emails escueladecomputacion@efn.uncor.edu y gaitan@gmail.com

Resumen

En las últimas décadas la computación se ha convertido en un pilar de la ingeniería y el desarrollo científico-tecnológico. En la mayoría de las áreas, el trabajo computacional es un complemento fundamental de la experimentación tradicional y de la teoría, ya que cada vez más se involucra simulaciones numéricas y modelado computacional. Frecuentemente, la tarea de los profesionales involucra el uso de aplicaciones específicas que requieren un gran trabajo de procesamiento de los datos de entrada y un post-procesamiento de los resultados utilizando otras herramientas.

Este curso brindará una introducción al poderoso lenguaje de programación Python (http://python.org) y a las herramientas fundamentales del "ecosistema científico" (IPython, Numpy, Matplotlib, Scipy) que conforman un entorno de programación interactivo de vanguardia, simple, libre, gratuito y multiplataforma.

Sobre el docente

Martín Gaitán es Ingeniero en Computación por la Universidad Nacional de Córdoba (2011). Socio fundador de Phasety, emprendimiento incubado en la UNC entre 2012 y 2015, donde desarrolló software de simulación especializado para la industria del petróleo y el gas. Pythonista desde hace una década, es especialista en el framework web Django y cree entender las necesidades del software científico. Es frecuente orador en eventos de software libre.

Más información en su blog

Programa

Clase 1:
Características de Python. Instalación de entorno en Windows/Linux. Modos de usar Python. Anaconda. Introducción a Ipython Notebook. Tipos de datos: enteros, floats, complejos, strings. Estructuras de datos incorporadas: listas, tuplas, diccionarios, conjuntos. Packing, indexing, slicing. Conceptos de mutabilidad, inmutabilidad, secuencia, iterador. Control de flujo: if, for, while. Estructuras por comprensión.
Clase 2:
Funciones: definición, argumentos posicionales y nominales. Generadores. Funciones incorporadas: zip, range, enumerate, etc. Manejo de I/O: lectura y escritura de archivos. Manejo de excepciones. Manejadores de contexto.
Clase 3:
Estructura de proyectos: módulos, paquetes, importación. Paseo por la biblioteca estandar: math, CSV, json, pickle Conceptos básicos de programacion orientada a objetos. Introduccion a Matplotlib y Numpy.
Clase 4:
Numpy: introducción al objeto Array. Slicing extendido, métodos y funciones importantes, importación de datos. Concepto de vista. Máscaras y fancy indexing. Aplicación de Numpy en álgebra lineal. Resolución de sistemas de ecuaciones lineales. Matplotlib: generación de gráficos cartesianos continuos, puntos, histogramas. Matplotlib avanzado: API orientada a objetos. Manipulación del formato y apariencia. Gráficos 3D, otros tipos de gráficos 2D. Exportación con calidad de publicación.
Clase 5:
Vectorización de funciones. Scipy: algoritmos optimización, integración, procesamiento de imágenes, ajuste de curvas etc. Sympy, cálculo simbólico de precisión arbitraria con Python. Evaluación numérica de expresiones Sympy con Numpy y otras herramientas de alta performance

Martín Gaitán: Curso de Python para ciencias e ingeniería, nueva edición

/images/Newsletter4-Banner_20120705_12-44-50-800.jpg

¡Atención!

¿Estás interesado en que dicte este curso, de manera intensiva, en tu laboratorio o empresa? Contactame.

Está abierta la inscripción para el nuevo dictado de mi curso de introducción a Python para ciencias e ingenierías, en la Facultad de Ciencias Exáctas, Físicas y Naturales de la Universidad Nacional de Córdoba (aprobado como curso de extensión - Resolución 1272/2015, bajo el nombre "Python como herramienta para la ingeniería") desde el miércoles 14 de ocubre de 18 a 22hs, durante 5 semanas.

Este curso una versión mejorada del que dicté en la Facultad de Matemática, Física y Astronomía en mayo pasado, avalado como curso de extensión (Resolución HCD 107/2015)

El precio está absolutamente subsidiado por las ganas de que más ingenieros e investigadores programen Python. No te demores en anotarte , los cupos son muy limitados!

Se entregarán certificados a quienes completen asistencia.

Lo que hay que saber

Fecha de inicio:
  miércoles 14 de octibre de 2015, 18hs.
Lugar: Laboratorio de computación (aula 112), FCEFyN.
Duración: 5 clases de 4hs (incluye coffee break), miércoles de 18 a 22hs
Docente: Ing. Martín Gaitán
Material: https://github.com/mgaitan/curso-python-cientifico

Aranceles

  • $500.– estudiantes y docentes de la UNC.
  • $750.– estudiantes y docentes de otras universidades públicas.
  • $1.000.– público en general.

Inscripción

Deberá completar este formulario

Luego se deberá abonar a través de un depósito o transferencia bancaria a la siguiente cuenta:

Titular: UNC - Fac. Cs. Exactas, Físicas y Naturales
CBU: 01102132 20021319046022
CUIT: 30-54667062-3
cuenta Corriente Bco. Nación Argentina - Suc. Córdoba  213-19046/02
Sucursal Nro. 1570

Una vez realizado el pago, deben enviarnos el comprobante de pago y documento que acredite el descuento (si aplica) a los emails escueladecomputacion@efn.uncor.edu y gaitan@gmail.com

Resumen

En las últimas décadas la computación se ha convertido en un pilar de la ingeniería y el desarrollo científico-tecnológico. En la mayoría de las áreas, el trabajo computacional es un complemento fundamental de la experimentación tradicional y de la teoría, ya que cada vez más se involucra simulaciones numéricas y modelado computacional. Frecuentemente, la tarea de los profesionales involucra el uso de aplicaciones específicas que requieren un gran trabajo de procesamiento de los datos de entrada y un post-procesamiento de los resultados utilizando otras herramientas.

Este curso brindará una introducción al poderoso lenguaje de programación Python (http://python.org) y a las herramientas fundamentales del "ecosistema científico" (IPython, Numpy, Matplotlib, Scipy) que conforman un entorno de programación interactivo de vanguardia, simple, libre, gratuito y multiplataforma.

Sobre el docente

Martín Gaitán es Ingeniero en Computación por la Universidad Nacional de Córdoba (2011). Socio fundador de Phasety, emprendimiento incubado en la UNC entre 2012 y 2015, donde desarrolló software de simulación especializado para la industria del petróleo y el gas. Pythonista desde hace una década, es especialista en el framework web Django y cree entender las necesidades del software científico. Es frecuente orador en eventos de software libre.

Más información en su blog

Programa

Clase 1:
Características de Python. Instalación de entorno en Windows/Linux. Modos de usar Python. Anaconda. Introducción a Ipython Notebook. Tipos de datos: enteros, floats, complejos, strings. Estructuras de datos incorporadas: listas, tuplas, diccionarios, conjuntos. Packing, indexing, slicing. Conceptos de mutabilidad, inmutabilidad, secuencia, iterador. Control de flujo: if, for, while. Estructuras por comprensión.
Clase 2:
Funciones: definición, argumentos posicionales y nominales. Generadores. Funciones incorporadas: zip, range, enumerate, etc. Manejo de I/O: lectura y escritura de archivos. Manejo de excepciones. Manejadores de contexto.
Clase 3:
Estructura de proyectos: módulos, paquetes, importación. Paseo por la biblioteca estandar: math, CSV, json, pickle Conceptos básicos de programacion orientada a objetos. Introduccion a Matplotlib y Numpy.
Clase 4:
Numpy: introducción al objeto Array. Slicing extendido, métodos y funciones importantes, importación de datos. Concepto de vista. Máscaras y fancy indexing. Aplicación de Numpy en álgebra lineal. Resolución de sistemas de ecuaciones lineales. Matplotlib: generación de gráficos cartesianos continuos, puntos, histogramas. Matplotlib avanzado: API orientada a objetos. Manipulación del formato y apariencia. Gráficos 3D, otros tipos de gráficos 2D. Exportación con calidad de publicación.
Clase 5:
Vectorización de funciones. Scipy: algoritmos optimización, integración, procesamiento de imágenes, ajuste de curvas etc. Sympy, cálculo simbólico de precisión arbitraria con Python. Evaluación numérica de expresiones Sympy con Numpy y otras herramientas de alta performance

Manuel Kaufmann (Humitos): Compartir videos con tu co-equiper

Viajamos mucho y muchas veces tenemos poca conectividad a internet. Entonces, necesitamos una forma de poder descargar la mayor cantidad de datos de internet cuando sí tenemos internet.

Para eso, hemos implementado varias ideas pequeñas que nos permiten trabajan Offline y sincronizarnos cuando estamos Online. Por ejemplo, muchas veces queremos bajar videos para ver cuando no tenemos internet.

Acá viene la cuestión. Siempre pasa que nos decimos: "¿Bajaste el video que te pedí?" y siempre tiene la misma respuesta: "¡Uh! Me re colgué". Finalmente, nunca tenemos nada para ver.

¡Basta! ¡Me cansé! Necesito hacer un programa que me ayude. Para eso combiné: Dropbox + youtube-dl + bash magic. Primero, creamos un archivo llamado urls-videos.txt y lo compartimos con Dropbox entre los dos. Cada uno agrega, cuando quiere/puede, un link al video que quiere bajar (uno por línea). Luego, en mi máquina me hice un one-line-bash-script que lo que hace es:

  1. Tomar la primera línea
  2. Bajar el video
  3. Borrar la primera línea (si tuvo éxito la descarga)
  4. Volver al primer paso

El script:

URLS=urls-videos.txt
youtube-dl --restrict-filenames --retries 50 --continue \
           --write-sub --sub-lang "en,es" --batch-file $URLS \
           --exec "tail -n +2 $URLS > /tmp/urls.txt ; mv /tmp/urls.txt $URLS ; ls"

La descripción:

--restrict-filenames:
  restringe el nombre de los archivos a algo más compatible (sin caracteres raros)
--retries 50: intenta un máximo de 50 veces
--continue: resume la descarga en caso de haberse cancelado por cualquier motivo
--write-subs: escribe los subtítulos en un archivo
--sub-lang: selecciona solo los subtítulos de los lenguajes "English" y "Español"
--batch-file: utiliza un archivo como entrada de urls a descargar
--exec: (acá está la magia) mediante tail -n +2 elimino la primera línea del archivo de urls y lo guardo en un archivo temporal. Luego, muevo ese archivo temporal al archivo original de urls (urls-videos.txt). Finalmente, pongo un ls porque youtube-dl concatena el nombre del archivo recién descargado, y como yo no quiero hacer nada con ese archivo, simplemente lo muestro en pantalla.

Así, cuando tengo internet se actualiza (con toda la magia de Dropbox) el archivo urls-videos.txt que yo modifiqué en mi máquina y también el que modificó Johanna. Después yo corro ese simple script y comienza el proceso.

¡Tenemos videos para ver! (sobre todo charlas TEDx)

Manuel Kaufmann (Humitos): Introducción a Python en Cochabamba

El próximo Miércoles 19 de Agosto estaremos dando una charla "Introducción a Python" en Cochabamba, Bolivia con el proyecto Argentina en Python.

La idea principal de esta charla es crear una comunidad local de programadores o entusiastas de Python. Para eso, se mostrará uno de los lenguajes de programación del momento que se está expandiendo en diferentes ámbitos: desde el desarrollo de un sitio web, hasta un software para controlar robots.

Las charlas de Python están orientadas normalmente a estudiantes del último año del secundario y primeros años de las universidades de carreras referidas a sistemas, dónde los asistentes tienen un mínimo conocimiento sobre qué es programar aunque no necesariamente sepan programar.

flyer.thumbnail.png

Flyer de la charla "Introducción a Python"

Tené en cuenta que...

  • ... es necesario registrarse (cupos limitados) mediante el formulario para poder participar.
  • ... la charla es de entrada libre y gratuita, aunque también se reciben donaciones para el proyecto.

¿Dónde y cuándo?

Programa de la charla

  • ¿Qué es Python?
  • Comunidad
  • Intérprete interactivo
  • Herramientas básicas
  • Manipulación básica de datos
  • Estructuras de control
  • Documentación complementaria

Si tenés ganas de empezar a aprender Python, podés ingresar a: Quiero aprender Python, donde vas a encontrar un montón de tutoriales, guías para principiantes y hasta libros más avanzados :)

¡Los esperamos!

Juanjo Conti: Hoy tuve una suerte pequeña

Una suerte pequeña, Claudia PiñeiroHoy, casi de noche. Estaba fresco pero me había abrigado. Caminé por la peatonal de Santa Fe haciendo tiempo, paseando un rato. Entré a la librería sin nada en mente, revisé las mesas con los títulos nuevos, pasé la mano por algunas letras de model. Llegué a la estantería con las obras completas de Borges y leí un poema al azar. Al costado, en un anaquel, las novelas de Claudia Piñeiro. La única que no leí es la última que publicó, Una suerte pequeña. La tomo y ya se que voy a comprarla, leo el primer párrafo y ya se me creo esa necesidad de leerla. Empiezo a leer el primer capítulo ahí, parado en la intersección entre dos pasillos. Recibo un mensaje, tengo que ponerme en camino. Voy hasta la caja sin soltarlo. “Me podés decir el precio de este (libro)”, digo tratando de disimular mi ansiedad, como un chico que no quiere que la chica se de cuenta que le gusta. “Si es 150 o menos me lo llevo”. “200”, me responde. “Bueno, lo llevo”.
Me pasa con algunos autores, una vez que leo uno de sus libros, tengo que leerlos todos.