O Andre Henrique anunciou uma vaga para desenvolvedor Python, com desejável conhecimento de Django para Itu, interior paulista:

Empresa em fase inicial, a atuação da ALTAVIX Digital é voltada ao segmento de Tecnologia da Informação, com foco em sistemas de operação e controle da distribuição de imagem e vídeo. Localiza-se no centro da cidade de Itu, interior de SP.

• Sobre a vaga:

System Message: WARNING/2 (<string>, line 6)

Bullet list ends without a blank line; unexpected unindent.

• Desenvolvimento de sistema web para comunicação digital.
• Conhecimentos desejáveis: Linux, SQL, Django, e Javascript.
• Contratação por prestação de serviço, mas com o objetivo de integração à equipe fixa.

• Sobre o candidato:

System Message: WARNING/2 (<string>, line 11)

Bullet list ends without a blank line; unexpected unindent.

O perfil que buscamos para os integrantes da nossa equipe é aquele que reúna características para o constante crescimento de competências, entre as quais destacamos: iniciativa, dinamismo, estudo, inovação e comprometimento.

Encaminhar currículo para rh_cv em altavix ponto com

O Ari Caldeira anunciou a seguinte oportunidade de trabalho para Sorocaba, interior paulista:

Olá!

Estamos procurando por um programador com conhecimentos em Python e Django, para trabalho em Sorocaba, interior de São Paulo.

Por favor, entrem em contato particular pelo emeio ari@tauga.com.br.

Obrigado!

Ari Caldeira Ta?ga Educação e Tecnologia - www.Tauga.com.br Fone/Fax: +55 (15) 3388-7305 Emeio: ari arroba tauga.com.br

Depois de um longo período apenas mantendo a estabilidade da versão atual, tirei ontem o dia para concluir os ajustes necessários para a versão 0.6 do Yadsel, com foco quase que exclusivo em projetos construídos com Django.

Ocorre que antes disso, o Yadsel trabalhava somente com versões de forma linear, ou seja: uma classe, uma versão.

Isso permaneceu até a versão 0.4, quando implementei o recurso de Extensible Versions (versões extensíveis) e Partial Versions (versões parciais). Essa versão inaugurou a idéia de poder ter várias classes em uma só versão. Melhorou na organização dos arquivos de versões e possibilitou trabalhar várias aplicações compartilhando uma mesma versão.

Mas ainda assim, outro recurso era necessário para o uso cotidiano no Django. No Django, as aplicações são independentes umas das outras, e ainda assim, podem haver eventuais dependências. Isso cria a necessidade de suporte a múltiplas versões em um mesmo projeto, ou seja: cada aplicação, uma versão. Para isso foi necessário implementar o Version Space.

Version Space

O Version Space é um recurso novo do Yadsel que torna possível que cada "espaço" no controle de versões possua sua própria versão, histórico e log. No caso do Django, o version space traduz-se pelo nome da aplicação, em outros aplicações, o desenvolvedor pode implementar como bem quiser.

Em outras palavras: eu posso manter uma aplicação de newsletter em diversos projetos com evolução de versões independentes do restante, incluindo toda a parafernália de DDL e DML que o Yadsel suporta: Tabelas, Domínios, Triggers, Procedures, Views, etc.

Yadsel no Admin

No embalo do Version Space veio o suporte ao Admin. É simples, ao instalar a aplicação 'yadsel.drivers.django_app' em seu INSTALLED_APPS, seu Admin passará a exibir duas seções para visualizar logs e históricos da evolução do banco.

Yadsel pelo manage.py

O Yadsel implementa um novo comando ao manage.py: yadseltool. A lógica de funcionamento é a mesma da yadseltool independente, porém seguindo a sintaxe de comandos baseados aplicações do manage.py:

$ python manage.py help yadseltool
Usage: manage.py yadseltool [options] [appname ...]

Executes Yadsel database version control for the given app name(s).

Options:
  --settings=SETTINGS   The Python path to a settings module, e.g.
                        "myproject.settings.main". If this isn't provided, the
                        DJANGO_SETTINGS_MODULE environment variable will be
                        used.
  --pythonpath=PYTHONPATH
                        A directory to add to the Python path, e.g.
                        "/home/djangoprojects/myproject".
  --traceback           Print traceback on exception
  --action=ACTION       Action of evolution; up=upgrade, down=downgrade
  --from=FROM
  --to=TO
  --mode=MODE           Mode of output; hidden=messages are hidden, steps=step
                        by step, interactive=confirms actions, output=only
                        prints to output
  --test=TEST           Set test mode
  --history=HISTORY     Write history of versions
  --silent=SILENT       Keeps exception messages
  --log=LOG             Write a log of changes
  --version             show program's version number and exit
  -h, --help            show this help message and exit

Exemplo de chamada do yadseltool

$ python manage.py yadseltool minha_aplicacao

Mas como afinal utilizar o Yadsel em meu projeto Django?

Bom, primeiro é necessário baixar a versão 0.6 do Yadsel em sua máquina

http://yadsel.googlecode.com/files/yadsel-0.6-with-django-support.tar.gz

Feito o download, instale o Yadsel numa versão 2.4 ou superior do Python

$ python setup.py install

Em seu projeto, acrescente a seguinte aplicação à setting INSTALLED_APPS do arquivo settings.py

'yadsel.drivers.django_app'

Rode o syndcb

$ python manage.py syncdb

Serão criadas as duas tabelas necessárias para o histórico e log do Yadsel. Entenda que 'histórico' trata-se do controle das versões, é ele que sabe se sua aplicação está na versão X ou Y. O 'log' trata-se de cada comando SQL que é gerado e executado, assim como suas respectivas eventuais mensagens de erro.

Crie a seguinte estrutura de pastas em uma de suas aplicações:

minha_aplicacao/
minha_aplicacao/yadsel_versions/
minha_aplicacao/yadsel_versions/__init__.py
minha_aplicacao/yadsel_versions/versao1.py
minha_aplicacao/yadsel_versions/versao2.py
minha_aplicacao/yadsel_versions/versaoN.py

o arquivo __init__.py deve conter ou importar as classes de versões, que podem ser estruturadas como bem quiser, seja em módulos ou em pacotes.

O conteúdo provável do arquivo __init__.py será este:

from versao1 import *

E o do arquivo versao1.py (ou qualquer outro que contenha classes de versões) será provavelmente este:

from yadsel.core import *

class Version1(Version):
    version_number = 1

    def up(self):
        pass

    def down(self):
        pass

ou como este exemplo:

from yadsel.core import *

class MinhaVersao1(Version):
    version_number = 1

    def up(self):
        CreateTable('minha_tabela_nova',
            id = Integer(primary=True)
            name = Varchar(50, required=True),
        ).append_to(self)

        AlterTable('states',
            Add('percent', Decimal(15, 5, default=0)),
        ).append_to(self)

        ExecuteSQL("""
            Create or Alter Procedure sp_teste...
        """).append_to(self)

    def down(self):
        ExecuteSQL("""
            Drop Procedure sp_teste
        """).append_to(self)

        AlterTable('states',
            DropColumn('percent'),
        ).append_to(self)

        DropTable('minha_tabela_nova').append_to(self)

A minha sugestão é que se use o Yadsel no Django somente para manter a evolução, não para criar tabelas em si. Isso porque o Django o já cria as tabelas muito bem. O que ele não faz é o resto :D

Os campos ManyToManyField são uma beleza: permitem que se selecione diversos registros extrangeiros para um único campo, possibilitando campos clássicos onde normalmente seria necessária uma nova classe com tratamento e manutenção particulares.

No entanto, esse tipo de campo traz um problema consigo: é que o SelectMultiple [1] carrega todas as opções disponíveis para o usuário, o que no caso de grande quantidade de registros, cria uma imensa estrutura em HTML capaz de travar até o mais rápido dos navegadores.

O widget FilteredSelectMultiple [2] oferece alguma organização para isso, mas ainda assim, a carga é a mesma ou ainda maior.

O novo admin, do branch newforms-admin [4] oferece o ManyToManyRawIdWidget [3], muito leve, mas nada amigável, considerando que este exibe somente o código dos itens selecionados, o que não ajuda de forma alguma o usuário final.

Com um problema para resolver num trabalho onde nos aproximamos de uma base de 20 mil clientes, surgiu a idéia para o Ajax ManyToManyField Widget, um nome meio D. Pedro I, mas que traduz exatamente o que é: uma alternativa leve sem se tornar estranha ao usuário: exibe-se um campo de auto-complete em Ajax, e à medida que o usuário escolhe o item desejado, clica-se no íconde com sinal de "+" e este é adicionado a uma lista logo acima.

Para isso, fiz uso de do plugin de auto-complete [5] disponível para jQuery [6], criado por Dylan Verheul. Com algumas modificações. Após uma conversa com o mesmo, eu soube que as minhas modificações se tornaram desnecessárias ante à nova versão disponível - farei a adaptação em breve.

Verifique os exemples disponíveis, e os arquivos estáticos utilizados. É necessário o jQuery, de preferência em sua versão mais recente.

Por fim, é importante ressaltar os dois elementos principais do widget:

auto_complete_view

Esta é uma generic view necessária para a disponibilização dos dados desejados em formato separado por pipe (|) - este é o formato utilizado pelo plugin de auto-complete - com possibilidade de pesquisa por quantos campos forem necessários:

from django.conf.urls.defaults import *

from apps.utils.ajax_m2m_widget import auto_complete_view
from models import Spare, Category

def spare_auto_query_func(q):
    return Spare.objects.filter(name__startswith=q)

def category_auto_query_func(q):
    return Category.objects.filter(name__startswith=q)

urlpatterns = patterns('apps.spares.views',
    (r'^spare/auto/$', auto_complete_view, {'query_func': spare_auto_query_func, 'desc_field': 'name', 'id_field': 'id'}),

    (r'^category/auto/$', auto_complete_view, {'query_func': category_auto_query_func, 'desc_field': 'name', 'id_field': 'id'}),
)

AjaxMultiSelect

Este é o widget a ser utilizado no admin (que seja on branch newforms-admin) ou em algum form do padrão NewForms. Veja o exemplo abaixo no Admin do newforms-admin:

from django.contrib import admin
from django.contrib.admin.options import ModelAdmin

from apps.spares.models import Category, Spare
from apps.utils.ajax_m2m_widget import AjaxMultiSelect

class SpareAdmin(ModelAdmin):
    list_display = ('name','manufacturer','description')
    list_display_links = ('name',)
    list_filter = ('manufacturer',)
    raw_id_fields = ('manufacturer','specification_sheet',)

    def formfield_for_dbfield(self, db_field, **kwargs):
        if db_field.name == 'categories':
            kwargs['widget'] = AjaxMultiSelect(db_field.verbose_name, Category, '/spares/category/auto/', attrs={'style': 'margin-left: 105px;'})
        elif db_field.name == 'equivalents':
            kwargs['widget'] = AjaxMultiSelect(db_field.verbose_name, Spare, '/spares/spare/auto/', attrs={'style': 'margin-left: 105px;'})

        if 'widget' in kwargs:
            return db_field.formfield(**kwargs)
        else:
            return super(SpareAdmin, self).formfield_for_dbfield(db_field, **kwargs)

admin.site.register(Category)
admin.site.register(Spare, SpareAdmin)

Agora um exemplo em form:

from django import newforms as forms

from apps.spares.models import Category, Spare
from ajax_m2m_widget import AjaxMultiSelect

class MyForm(forms.Form):
    spares = forms.Field(widget=AjaxMultiSelect(db_field.verbose_name, Spare, '/spares/spare/auto/'))
    categories = forms.Field(widget=AjaxMultiSelect(db_field.verbose_name, Category, '/spares/category/auto/'))

O download está disponível em [7] (o Google fez o favor de bloquear minha conta para criação de novos projetos pelas próximas 24 horas por motivos que só deus sabe).

Links relacionados