Proximo destino

Quiero ir aca (zoom out ;)

Haganme un favor

Cuando estén con migo ponganme en una situación en la que pueda decir touche de manera adecuada.

Siempre quise parecer inteligente diciendo esa palabra

Book meme

Ningún Test lo es. - Sueñan los androides con ovejas eléctricas? Philip K. Dick
link: http://fitoria.net/2008/11/13/book-meme/

• Agarra el libro mas cercano
• Abrelo en la pagina 56.
• Encuentra la quinta oración.
• Postealo junto con estas instrucciones
• No vayas por tu libro favorito solo agarra el que este MAS CERCA
• Poner la url del site donde leíste el meme
  

Xml -> dict -> objetos

En este ejemplo se muestra como convertir un string a una estructura de diccionarios y listas anidadas usando expat, tambien se proveen dos clases que permiten manipular el resultado como si fueran objetos.

primero el codigo

import xml.parsers.expat

class XmlParser(object):
   '''a class that parses a xml string an generates a nested 
    dict/list structure
    '''

   def __init__(self, text):
       '''constructor'''
       self.parser = xml.parsers.expat.ParserCreate()
       self.parser.buffer_text = True

       self.result = None
       self.stack = []
       self.current = None

       self.parser.StartElementHandler = self.start_element
       self.parser.EndElementHandler = self.end_element
       self.parser.CharacterDataHandler = self.char_data
       self.parser.Parse(text)

   def start_element(self, name, attrs):
       '''Start xml element handler'''
       if self.current != None:
           self.stack.append(self.current)

       self.current = {}

       for (key, value) in attrs.iteritems():
           self.current[str(key)] = value

       self.current['tag'] = name
       self.current['childs'] = []

   def end_element(self, name):
       '''End xml element handler'''
       if len(self.stack):
           current = self.stack.pop()
           current['childs'].append(self.current)
           self.current = current
       else:
           self.result = self.current

   def char_data(self, data):
       '''Char xml element handler.
        buffer_text is enabled, so this is the whole text element'''
       self.current['childs'].append(data)

class DictObj(dict):
   '''a class that allows to access a dict as an object
    '''

   def __init__(self, kwargs):
       '''constructor'''
       dict.__init__(self, kwargs)

   def __getattribute__(self, name):
       if name in self:
           obj = self[name]

           if type(obj) == dict:
               return DictObj(obj)
           elif type(obj) == list:
               return ListObj(obj)
          
           return obj
       else:
           return None

class ListObj(list):
   '''a class that allows to access dicts inside a list as objects
    '''

   def __init__(self, args):
       '''constructor'''
       list.__init__(self, args)

   def __getitem__(self, index):
       if index > len(self):
           raise IndexError('list index out of range')

       obj = list.__getitem__(self, index)

       if type(obj) == dict:
           return DictObj(obj)
       elif type(obj) == list:
           return ListObj(obj)

       return obj

   def __iter__(self):
       '''iterate over the list'''

       count = 0

       while count < len(self):
           yield self[count]
           count += 1

def raw_string(dct_):
   '''return a string containing just the string parts removing all the 
    xml stuff'''

   def helper(dct):
       result = []

       for child in dct.childs:
           if type(child) == str or type(child) == unicode:
               result.append(str(child))
           else:
               result = result + helper(child)

       return result

   return ''.join(helper(dct_))

Simplemente creamos un objeto de tipo XmlParser pasandole el string y obtenemos el resultado parseado en la variable result. Si no queremos andar preguntado si las llaves existen antes de accederlas para evitar excepciones podemos usar la clase DictObj que nos permite acceder a las llaves como si fueran atributos, las variables que no existan como llaves contendran None. Aca va un ejemplo en la consola interactiva

>>> import XmlParser
>>> p = XmlParser.XmlParser('google test  !!')
>>> r = p.result
>>> d = XmlParser.DictObj(r)
>>> d
{'childs': [{'childs': [u'go', {'childs': [u'o'], 'tag': u's'}, u'gle'], 'href': u'google.com', 'tag': u'a'}, u' ', {'childs': [u'test'], 'tag': u'i'}, u' ', {'childs': [], 'src': u'foo.png', 'alt': u'foo', 'tag': u'img'}, u' ', {'childs': [u'!'], 'tag': u'u'}, {'childs': [u'!'], 'tag': u's'}], 'tag': u'span'}
>>> d.childs
[{'childs': [u'go', {'childs': [u'o'], 'tag': u's'}, u'gle'], 'href': u'google.com', 'tag': u'a'}, u' ', {'childs': [u'test'], 'tag': u'i'}, u' ', {'childs': [], 'src': u'foo.png', 'alt': u'foo', 'tag': u'img'}, u' ', {'childs': [u'!'], 'tag': u'u'}, {'childs': [u'!'], 'tag': u's'}]
>>> d.childs[0]
{'childs': [u'go', {'childs': [u'o'], 'tag': u's'}, u'gle'], 'href': u'google.com', 'tag': u'a'}
>>> d.childs[0].tag
u'a'
>>> d.childs[0].childs[0]
u'go'
>>> d.childs[0].childs[1].tag
u's'

Controlar el impulso

Metacrap

buen articulo (explica por que nunca use los tags de blogger :P)

http://www.well.com/~doctorow/metacrap.htm

sobre startups

este articulo confirma algunas cosas que tenia en mente y que no sabia si era yo nomas :D

http://www.paulgraham.com/divergence.html

quotes para los fiacosos

The reason startups no longer depend so much on VCs is one that everyone in the startup business knows by now: it has gotten much cheaper to start a startup. There are four main reasons: Moore's law has made hardware cheap; open source has made software free; the web has made marketing and distribution free; and more powerful programming languages mean development teams can be smaller. These changes have pushed the cost of starting a startup down into the noise.

Once you cross the threshold of profitability, however low, your runway becomes infinite. It's a qualitative change, like the stars turning into lines and disappearing when the Enterprise accelerates to warp speed. Once you're profitable you don't need investors' money. And because Internet startups have become so cheap to run, the threshold of profitability can be trivially low. Which means many Internet startups don't need VC-scale investments anymore.

import antigravity

problema: queres pasarle uno o mas archivos a una persona, solo queres que vea archivos de una carpeta determinada y poner apache o samba no tiene sentido para vos.

solucion en una linea de python:

__import__('BaseHTTPServer').HTTPServer(('', 8000), __import__('SimpleHTTPServer').SimpleHTTPRequestHandler).serve_forever()

si lo queres correr desde la consola (te publica el directorio donde corriste el comando):

python -c "__import__('BaseHTTPServer').HTTPServer(('', 8000), __import__('SimpleHTTPServer').SimpleHTTPRequestHandler).serve_forever()"

vamos a admitirlo, es un poco perlish, asi que vamos a ponerlo mas limpio:

import BaseHTTPServer
import SimpleHTTPServer

server = BaseHTTPServer.HTTPServer(('', 8000),   SimpleHTTPServer.SimpleHTTPRequestHandler)
server.serve_forever()

PD: al final lo pasamos en pendrive porque eran 899MB pero cuando haces algo asi en python es con el unico fin de levantarte minas, ej:

*se aproxima a la mujer objetivo en bar, boliche o similar*
- ayer le tenia que pasar un archivo a un amigo y no tenia como
*hace gesto de desinteresada*
- sabes que hice?
*no responde*
*mira para otro lado*
- escribi un servidor web en 4 lineas de python
*lo mira*
*comienza a besarlo apasionadamente*

;)