Cros 2.0.2

Termine la version 2.0.2 de mi Sistema de Rol

Changelog:

  • Migre todo el site a mi blog  (aca) (donde tambien hay descargas)
  • Corregí un par de errores menores.

Pasos a seguir:

  • Estoy empezando a escribir una ambientación y planeo editarlo en papel.
  • Tengo a medio implementar un versión del sistema para usarlo desde Python (link)
  • Seriamente estoy pensando en integrarlo a Pilas. Ya que es tan simple que seria ideal para meterlo en un framework de estas características (podría hacerse en un pycamp).

Leer Más

Pycon Ar 2011 – Call for posters

Pycon Argentina en su edición 2011 se enorgullece en presentar su:

“Call for Posters”

Usted dirá: Que es un póster?

Un póster es un resumen breve de un trabajo en forma de lámina; el cual se
expone de manera permanente en un salón durante toda la Pycon Argentina
2011.

A quien esta dirigido:

  • - A los que quieran presentar trabajos muy breves como para una charla
  • - A los que hicieron charlas que quedaron afuera
  • - A los que tengan pánico escénico.

A Donde envío mi póster:

Deben ser ingresadas, previa registración en el sitio,
para su aprobación en :

http://ar.pycon.org/2011/conference/proposals/submit/

La fecha límite de envío de posters es el

VIERNES 1 DE JULIO DE 2011 inclusive.

En caso de que necesiten hacer consultas o plantear
inconvenientes, por favor contactarse a: *pyconar2011 gmail.com*
o a nuestra lista de correo

https://listas.usla.org.ar/cgi-bin/mailman/listinfo/pyconar2011

– Título

– SELECCIONAR TIPO = “POSTER” EN EL COMBO

– Autor(es): Nombre y apellido, breve descripción de cada uno, foto,
asociación, grupo de usuarios, y organismo o empresa a la que
pertenece, si corresponde.

– Descripción del poster: Uno o dos párrafos donde se explique el
contenido de la presentación.

– Tipo de publico: Desarrolladores avanzados, desarrolladores
principiantes, empresarios, docentes, público en general.

– Conocimientos previos: Especificar que conocimientos previos deberán
tener los asistentes.

– Track: stdlib, web, mobile, cloud, desktop.

– Tags: Académico, Caso de Estudio, Ciencia, Cli, Comunidad, Core,
Educación, Fomento, GUI, Herramientas, Juegos, Lenguaje, Móviles,
Py3k, Redes, Seguridad, Testing, Web.

– Teléfono del/los autor/es: Para poder comunicarnos.

– Ciudad de residencia del/los autor/es.

Consideraciones MUY BÁSICAS al hacer un póster:
– Que sea legible y lo mas “auto explicativo” posible.
– Buena diagramación (tiene que ser tan intuitivo de seguir como un comic)
– QUE TENGAN LOS DATOS DE EL/LOS AUTOR/ES

Muchas mas consideraciones en (hay fotos de pósters):

http://www.swarthmore.edu/NatSci/cpurrin1/posteradvice.htm

Formato:
No hay un lineamiento general por el tamaño, pero cualquier tamaño cercano
al 90 x 120 es bueno (A3 no sera rechazado pero es muy pequeño)

Costos de Impresión:
Una impresión cuesta entre 50 y 100 pesos depende el tipo de
papel y el tratamiento final.
Si bien se pueden hacer con “Fibra y Papel” es mucho mas útil para
que los visitantes se sientan interesados en el trabajo que este impreso en
un lindo formato y papel.
Este costo queda a cargo del presentador del póster. Solo en caso de que no
pueda costearlo la organización analizara el caso.

Leer Más

csvcool 0.1

Laburando en el pyday, tuve que lidiar con varios archivos csv. Los bichitos estos tenian en su primer fila el nombre del campo al cual hacia referencia la columna dada

porjemplo 2 personas con nombre apellido y email aparecia algo asi:

nombre apellido mail
tito puente tito@puente.com
cosme fulanito cosme@fulanito.com

Realmente usar el modulo csv de python me rompia un poco la paciencia, ya que se accedia siempre por indices  y habia que omitir la fila 0

ejemplito:

import csv
csvf = csv.reader(open("/archivo.csv"))
print csvf[1][0] # imprimiria "tito"

Mi solucion: csvcool

Que hace esta librería? bueno… omite la fila 0 y transforma  cada fila en un diccionario (entre otras cosas)

Ejemplito 3:

import csvcool
csvf = csvcool.read(open("/archivo.csv"))
print csvf[0]["nombre"] # imprimiria "tito"

Ademas de eso tambien tiene los sigientes features:

  • extraer una sola columna como una tupla.
  • recortar un csv dejando “algunas” columnas o “algunas filas”.
  • agregar filas y columnas.
  • remover filas y columnas.
  • guardar en un archivo.
  • y unas cosas mas.
Como ultimo ejemplo supongamos que solo queremos guardar un csv con los mails y el apellido de las personas:
import csvcool
csvf = csvcool.read(open("/archivo.csv"))
cortado = csvf.cut("apellido", "mail")
csvcool.write(cortado, open("/archivo_cortado.csv", "w"))
Instalar:
PD: hay test… y me olvide de incluirlos en el setup.py (moco)

Leer Más

Regalé un proyecto: “Timba”

Tenia este proyecto dormido en su version 0.0.31 en sourceforge desde hace mas de 2 años, asi que se lo regale a un grupillo de investigacion del LIS de UTN-FRC (Pronósticos).

Timba es un bichito hecho cn java, el cual uno le carga una imagen y seleccionando un color  infiere por metodo de montecarlo, la superficie que ocupa el color en la imagen.

Lo usé para calcular superficies de lagos y alguna que otra mancha de cancer de piel.

[slideshow]

En una de las imagenes se ve que el programa detecta las islas de un mapa en color rojo.

Link del proyecto

Leer Más

Snippet: game_solver.py

Implementación de Teoría de juegos que estoy preparando para un paper

#!/usr/bin/env python
#-*-coding:utf-8-*-

# This program is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation; either version 3 of the License, or
# (at your option) any later version.

# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.

# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
# MA 02110-1301, USA.

#===============================================================================
# DOC
#===============================================================================

"""This code is a simple implementation of an algoritm published in the paper

    "Aplicación de Teoría de Juegos a una Inteligencia Artificial de un Browser
     Game Persistente de Estrategia" (JAIIO 40, 2011, http://www.40jaiio.org.ar)

    (EN: Applying Game Theory to an Artificial Intelligence Persistent Browser
     Strategy Game)

"""

#===============================================================================
# META
#===============================================================================

__version__ = "0.1"
__license__ = "GPL3"
__author__ = "JBC"
__mail__ = "jbc dot develop at gmail dot com"

#===============================================================================
# IMPORTS
#===============================================================================

import operator
import random

#===============================================================================
# FUNCTIONS
#===============================================================================

def liar_solve(mtx):
    """Returns the probability of victory of all strategies with respect to the
    strategies that were not used.

    @param mtx: a matrix where each row represents the strategies of player 1,
    each column the strategies of player 2, and each cell has the advantage that
    the strategies of the row over the column (negative values ​​imply advantages
    in the column on the rows and ​​None values siginifca that these strategies
    never encountered)

    @return A tuple with 2 list, the first one with the probabilities of the
    row strategies, and te second one with the probablities of the colum

    """
    to_percent = lambda values: [(v * 100.0) / sum(values) for v in values]
    row_nones = [l.count(None) for l in mtx]
    col_nones = 1
    return to_percent(row_nones), to_percent(col_nones)

def game_theory_solve(mtx):
    """ Approximate the strategy oddments for 2
    person zero-sum games of perfect information.

    Applies the iterative solution method described
    by J.D. Williams in his classic
    book, The Compleat Strategyst, ISBN 0-486-25101-2.
    See chapter 5, page 180 for details.

    @param mtx: a matrix where each row represents the strategies of player 1,
    each column the strategies of player 2, and each cell has the advantage that
    the strategies of the row over the column (negative values ​​imply advantages
    in the column on the rows)

    @return A tuple with 2 list, the first one with the probabilities of the
    row strategies, and te second one with the probablities of the colum

    Based on the work of:
        @author: Raymond Hettinger
        @contact: http://code.activestate.com/recipes/496825/

    """
    iterations = 100
    transpose = zip(*mtx)
    numrows = len(mtx)
    numcols = len(transpose)
    row_cum_payoff = [0] * numrows
    col_cum_payoff = [0] * numcols
    colpos = range(numcols)
    rowpos = map(operator.neg, xrange(numrows))
    colcnt = [0] * numcols
    rowcnt = [0] * numrows
    active = 0
    for i in xrange(iterations):
        rowcnt[active] += 1
        col_cum_payoff = map(operator.add, mtx[active], col_cum_payoff)
        active = min(zip(col_cum_payoff, colpos))[1]
        colcnt[active] += 1
        row_cum_payoff = map(operator.add, transpose[active], row_cum_payoff)
        active = -max(zip(row_cum_payoff, rowpos))[1]
    return rowcnt, colcnt

def best_strategy(mtx, plyr):
    """Returns the suggested strategy for a given player. If all of the values
    ​​of all non-null lamatris used game theory is used otherwise a selection to
    try to encourage the elimination of null values​​.

    @param mtx: a matrix where each row represents the strategies of player 1,
    each column the strategies of player 2, and each cell has the advantage that
    the strategies of the row over the column (negative values ​​imply advantages
    in the column on the rows and ​​None values siginifca that these strategies
    never encountered)

    @param plyr: Two values are accepted. "0" for the "row" player and "1" for the
    column player.

    @return An integer that represents the strategy n-th of row or column

    """
    probs = None
    solver = None

    # Verify if matrix are empty
    if not any([l.count(None) for l in mtx]):
        probs = game_theory_solve(mtx)[plyr]
        solver = "game_theory_solver"
    else:
        probs = liar_solve(mtx)[plyr]
        solver = "liar_solver"

    # Calculate the cumulative frequency
    for idx, prob in enumerate(probs):
        cum = probs[idx-1][1] if idx != 0 else 0
        probs[idx] = (idx, prob + cum)

    # Find E*
    while True:
        roll = random.randint(1, 100)
        for stg, prob in probs:
            if roll < prob:
                return stg, solver

def update_mtx(mtx, row, column, plyr):
    """Update the matrix to improve decisions.

    @param mtx: The matrif to update.

    @param row: The index of the row strategy.

    @param column: The index of the column strategy.

    @patam player: Two values are accepted.
        0: for the "row" player the mtx[row][column] must be incremented in 1
        1: for the "column" player the mtx[row][column] must be decremented in 1

    """
    value = mtx[row][column] or 0
    if plyr == 0:
        value += 1
    elif plyr == 1:
        value -= 1
    else:
        raise ValueError("'plyr' must be '0' or '1', found: %s" % str(plyr))
    mtx[row][column] = value

#===============================================================================
# TEST
#===============================================================================

FULL_MTX = ([4,    0,     1],
            [100,  23,    2],
            [5,    23,    1],
            [1,    1,     0])

INC_MTX = ([4,      0,    1],
            [100,   None, 2],
            [5,     23,    None],
            [None, 1,     None])

print best_strategy(FULL_MTX, 0)
print best_strategy(INC_MTX, 1)

Aplicación de Teoría de Juegos a una Inteligencia Artificial de un Browser Game Persistente de Estrategia

Leer Más

Snippet: caller.py (0.2)

Durante la Organizacion del Pyday hice unos cuantos snippets que me sirvieron para generar cosas y demas, uno de ellos es este.

Para X-ip caller.py 0.2, en el cual elimine la clase Caller y la reemplace por una funcion.

#!/usr/bin/env python
# -*- coding: utf-8 -*-

# caller.py

__author__ = "jbc <jbc.develop@gmail.com>"
__version__ = "0.2"
__license__ = "lgpl3"

import subprocess
import shlex


class CallError(Exception):

    def __init__(self, cmd, stderr, code):
        msg = "External call '%s' fail with code '%i'. Cause: '%s'" % (cmd, code, stderr)
        super(CallError, self).__init__(msg)
        self.cmd = cmd
        self.stderr = stderr
        self.code = code


def call(cmd):
    """Execute the cmd an return the standar output or raises an exception

    """
    pcmd = shlex.split(cmd)
    p = subprocess.Popen(pcmd, stdout=subprocess.PIPE,
                         stderr=subprocess.PIPE)
    stdout, stderr = p.communicate()
    if p.returncode:
        raise CallError(cmd, stderr, p.returncode)
    return stdout

uso:

import caller
print caller.call("ls -lia")

Leer Más