pyata – programando o pure data com python

dando continuidade a minha linha de pesquisa sobre Dynamic Patching, desenvolvi um nova ferramenta: o Pyata.

Pyatã (do Tupi, ou ainda Py.thon + Pure D.ata) é um simples módulo python opensource e multiplataforma que permite que o Pure Data (vulgo Pd) seja utilizado como uma API. em outras palavras, se trata de uma abstração do Pd, que permite ao Python utilizar praticamente todas as funcionalidades do Pd, incluindo criar, editar e remover patches, sem a necessidade de interação por parte do usuário com a interface do Pd.

o vídeo abaixo mostra algumas coisas que podem ser feitas com o projeto (a propósito, para uma melhor compreensão, recomendo assistir ao vídeo na página do Youtube, em HD):

a ferramenta em Python é  uma implementação em Python do protocolo FUDI, já citado aqui mesmo no blog, que permite o Dynamic Ptaching . ela também pode ser vista como uma evolução do PyPd (mais completa, enxuta e estável),  ferramenta que implementei durante meu trabalho final de conclusão de curso (por conta disso, o projeto  do Pypd será descontinuado).

dessa forma, o que o módulo faz é receber os comandos do Python e transformá-los numa mensagem FUDI equivalente. Essas mensagens são enviadas para o core do Pd, que as processa num Patch que roda virtualmente dentro da máquina, gerando resultados. Após isso, tais resultados são carregados no programa Python, mantendo a sincronia do programa com o Patch virtual.

com o Pyata é possível:

• criar, editar, remover, mover, clicar, (des)selecionar caixas (objeto, números, symbols, comentários e mensagens);
• pegar do pd o estado de qualquer caixa (números de inlets/outlets, id de cada caixa, além dos valores de números e symbols em tempo real);
• gerenciar conexões (conectar e disconectar);
• operações básicas (copiar, colar, duplicar, cortar e salvar);

maiores informações, incluindo o código fonte e tutoriais, podem ser encontrados no site do projeto:

http://code.google.com/p/pyata/

mais uma vez obrigado ao pessoal da lista do Artesanato de Volts pela ajuda, em específico a Vilson Vieira (e o seu topd)!
abraços!

simulando a Interface do Pd através de mensagens

dando prosseguimento aos estudos sobre Dynamic Patching, resolvi tentar simular todas as possibilidades da interface do Pure Data usando pra isso só troca de mensagens com seu core.

isso nos permitiria operar o Pd sem sua interface gráfica (no-gui mode), de maneira a simular a ação de um usuário, possibilitando, por exemplo, criar APIs para outras linguagens (C++, Python, etc) que permitam programar o Pd (a exemplo do PyPd), criar novas interfaces de interação, criar ferramentas para Live Coding (utilizando o Pd como máquina), criar projetos como o Reactable ou instalações como o The Champions, entre outras loucuras.

a especificação dessa relação interface/mensagens pode ser encontrada no seguinte endereço:

http://jeraman-lab.googlecode.com/files/dynamic%20pathing.zip

o código está dividido em 8 pastas distintas, cada uma abrangendo um aspecto diferente da interface, sendo essas:

• caixas – aborda todos os aspectos relativos a interação do usuário com os tipos básicos de caixas (objetos, números, symbols, mensagens e comentários), abrangendo ações como criar, editar, mover e deletar caixas;
• conexões – aborda os aspectos relativos a conexões entre caixas;
• gui – aborda todos os aspectos relativos a interação do usuário com os tas caixas de interface (bangs, toggles, sliders, etc), abrengendo ações como criar, interagir, alterar propriedades e etc;
• menus – entre as pastas 4 e 7 está descrita a troca de mensagens da interação do usuário com os menus da interface do Pd, sendo esses o File, Edit, Find e Media;
• subpatches – aborda como cria, interagir e remover subpatches dinamicamente, através de mensagens;

infelizmente o código não está tão bem organizado e parametrizado quando deveria, peço desculpas! no entanto, acredito que ele deva estar claro o suficiente pra entender a relação interface/mensagens…

qualquer sugestão, crítica, problema, dúvida, colaboração, será extremamente bem vinda!

muito obrigado a Jarbas Jácome e a Alexandre Porres (e seu Tutorial de Pure Data) pela ajuda! valeu galera!

e os estudos continuam!

tutorial sobre iemguts

apesar do resultado com o PyPd ter sido interessante para meu propósito na época, no tocante a utilização intensiva a biblioteca não ficou tão estável e completa, quanto desejado inicialmente. com o objetivo de corrigir tais problemas, decidir retomar meus estudos sobre Dynamic Patching.

através de uma dica do pessoal do Artesanato de Volts, tomei conhecimento de uma bilbioteca para o Pure Data chamada iemguts, sobre a qual falarei um pouco neste post.

iemguts

criada por IOhannes m Zmölnig em 2007, a iemguts é uma coleção de objetos que visa dar “Reflexividade” ao Pd, dando-lhe características como meta-programação – ou seja, criação de objetos do Pd a partir do próprio Pd – e “consciência” – na qual variáveis internas ao Pd ficam acessíveis ao programador. dessa forma, o Dynamic Patching acaba sendo uma das suas possibilidades do iemguts, mas não seu foco principal.

eis um exemplo de trabalho feito com o iemguts, desenvolvido pelo próprio IOhannes:

tutorial

ao começar a estudar a tecnologia, uma coisa fica logo evidente: a escassez de material de refererência. não existe um site para o projeto, nem todas as caixas da biblioteca possuem help disponível, tampouco os documentos escritos pelo autor são inteiramente esclarecedores.

pensando nisso, baseado em tais documentos disponíveis aliados a um pouco de experimentação, criei um pequeno tutorial que explica as funcionalidades de cada um dos objetos do iemguts. ele está disponível através do link:

http://jeraman-lab.googlecode.com/files/tutorial%20iemguts.zip

conclusão

ainda não sei se utilizarei o iemguts para corrigir os problemas citados do PyPd: ainda é preciso estudar mais para chegar a uma conclusão definitiva. no entanto, o processo para aprendê-la me foi tão custoso que achei razoável dedicar um post a ele, compartilhando um pouco do que aprendi. não é lá grande coisa, mas certamente teria me ajudado a desbravar mais facilmente essa biblioteca poderosa, mas enigmática.

a biblioteca está atualmente disponível na versão 0.42.5 do Pd Extended ou, alternativamente, pode ser obtido por svn pelo seguinte link:

https://pure-data.svn.sourceforge.net/svnroot/pure-data/trunk/externals/iem/iemguts/

além disso, finalizando este post, deixo aqui o link de uma página que estou escrevendo no Estúdio Livre sobre o dynamic pathcing, contando sobre o que é, links para tutoriais, ferramentas existentes, entre outras coisas.

http://www.estudiolivre.org/tiki-index.php?page=Dynamic+Patching

quem sabe não é útil a mais alguém?

pyPd – using Pure Data inside Python!

this tool is out-of-date. please, check out Pyata project! http://code.google.com/p/pyata/

today i have a great announcement: pyPd! this is the project that has been keeping me busy for a while…

pyPd is a multi-platform and open-source python library that allows people to use Pure Data just like an API. in other words, it is an abstraction to Pd, that can be used for doing everything that Pd can do, but without opening Pd interface in a direct way.

sample of Pd patch. with pypd, you can now build one of this using python!

it was developed using a technique known as “dynamic patching” (already cited in this blog), which is based on dynamic creation of Pd objects realized through sockets. this means, for example, that we can create a [osc~ 440] object sending to Pd a specific message through sockets.

so what basically the library does is to receive the commands given by users, transforming them into the equivalent message. these messages are sent to Pd, that processes them like they were a patch running inside Pd (a virtual patch), generating results. after that, these results are reloaded again into the python program through simple file reading, what allows it to be always updated according the “virtual patch”.

it’s important to notice that no gui is shown during this process. Pd runs in -nogui mode, so all interaction happens through messages by sockets and file reading!

this first version is quite simple. it includes just:

• object creation, edition and remotion (object, number, comments, symbols and messages)
• connection management (connect and disconnect objects).

for further reading, the project (including the source) is available at:

http://code.google.com/p/pypd/

get started reading the tutorial! it’s not hard indeed!

ps: pyPd… till now i don’t have a better name… suggestions?

further informations

[1] about Pure Data

[2] pyPd project on google code

[3] getting started with pyPd

[4] about dynamic patching

——

i’ve got a lot of news… here comes some of them:

• yeah… i was not selected to participate of gsoc this year, but that’s ok… maybe next year? the entire list of projects selected by NUIGroup can be checked here. congrats and good luck for all students!
• but… anniec, member of wouwlabs, had her proposal accepted! this is just awesome! congrats anniec!!! we all are with you!!!
• well… i’m fired! crisis to blame… now i have more time to lead with my thesis… =P
• a new tbeta (aka CCV –Community Core Vision) is out! go and check it!
• it’s been a long time without posts and i’m sorry for that. i spent the last three weeks taking care of my life and thinking about what the hell i’m gonna do after graduated… so i didn’t give too much attention to the blog…

how to use Pure Data as an API

important:  this post is old and the code can be out-of-date. use it at your own risk.

this post will explain how to extend Pd functionalities to other languages, allowing us to use it something like an API. with this, we could for example create a [osc~] and connect it to a [dac~] using for this just a python program. this is possible due to dynamic creation of Pd objects (aka dynamic patching) realized through sockets.

it’s important to notice that this is different from simple exchanging values of variables through sockets. if you want this, i advice you to take a look on netsend and netreceive objects.

to make things more clear, i’m going to use some examples. they can be found through svn at:

http://jeraman-lab.googlecode.com/svn/trunk/dynamicPatching/

1. putting pd to work without gui

well… that’s it! this simple step makes Pd run without any gui. you can do this running pd in command line with -nogui parameter. to illustrate how we can use it, execute remote.pd file according the above. after it, just execute normally client.pd and see what happens.

running pd on -nogui mode

this is important if you dont want to see any pd patch appearing on the screen during the execution of your non-pd program. if this doesn’t make sense to you, just skip this step.

2. dynamic creation of patchs and objects

this second step is about dynamic patching itself. it consists on sending messages to pd, that interpretes and tranfosms them into pd objects as soon they are sent. these messages are sent by [send], what means that we could send them through socket from another program (we’ll do this in next step). you can notice that the messages are almost the same to the lines you see when you open a pd patch with a text editor (if you never did this, try it!).

sending the messages to pd

to see how it works, just open sample1.pd. the second file, sample2.pd, is a little bit more complex, with more objects. if you need to create others, i advice you to read damien’s tutorial or yet put the desirable object on a pd file, save and open it in a text editor (remember: the messages are almost the same).

3. the mix!

now, it’s time to make the two steps above together! the stuff works almost like i already described, but now instead using [send] object, we’ll use pdsend file (available in pure data directory) to connect to pd, or yet a simple tcp client. despites, we will initialize a simple server (it contains just a receive object) in -nogui mode. this is the patch we are going to modify dynamicly, so it’s our entrance to pd program.

the python program that creates pd objects dynamically

to show that the stuff really works, i wrote a simple program in python that allows you to create and connect pd objects. to put it to work,  just open it and change the given place to where are pdsend and server.pd (variables pdsendDir and serverDir) files.

that’s all! i hope this could be usefull!

thanks to: jarbas jacome, for his tips, and damien henry, for his brilliant tutorial about dynamic pathing!

further informations:

[1] about puredata

[2] damein henry’s tutorial about dynamic patching;