Django Apache mod_python

O mod_python é mais simples de configurar.

1- Apache conf

<VirtualHost ip ou *:80>
  ServerName python.algoritmoweb.com.br
  ServerAdmin webmaster@algoritmoweb.com.br
  DocumentRoot /var/www/html/python
  LogLevel Debug
  SetHandler python-program
  AddHandler mod_python .py
  Header set Pragma "no-cache"
  Header set Cache-Control "no-cache"
  Header set Expires "-1"
  PythonHandler django.core.handlers.modpython
  PythonPath "['/var/www/html/python'] + sys.path"
  SetEnv DJANGO_SETTINGS_MODULE settings
  PythonDebug On
</VirtualHost>

Pronto é só chamar http://python.algoritmoweb.com.br e a aplicação vai executar.

Espero ter ajudado.
Orlando

Django Apache FastCGI

Que surra mais consegui das duas maneira mod_python e FastCGI, primeiro o FastCGI.

1- O VirtualHost.

<VirtualHost ip ou *:80>
  ServerName golias.algoritmoweb.com.br
  ServerAdmin webmaster@algoritmoweb.com.br
  DocumentRoot /var/www/html/golias.algoritmoweb.com.br/www
  ErrorLog /var/www/html/golias.algoritmoweb.com.br/logs/error_log
  TransferLog /var/www/html/golias.algoritmoweb.com.br/logs/access_log
  LogLevel Debug
  Header set Pragma "no-cache"
  Header set Cache-Control "no-cache"
  Header set Expires "-1"
  IPCCommTimeout 40
  IPCConnectTimeout 10
  <Directory /var/www/html/golias.algoritmoweb.com.br/www>
    Options ExecCGI FollowSymLinks
    AllowOverride AuthConfig Indexes Limit
    Order allow,deny
    Allow from all
    AddHandler fcgid-script .fcgi
    RewriteEngine On
    RewriteCond %{REQUEST_FILENAME} !-f
    RewriteRule ^(.*)$ dispatch.fcgi/$1 [QSA,L]
  </Directory>
</VirtualHost>

Com esta configuração basta eu chamar http://golias.algoritmoweb.com.br que a aplicação executa direto sem a necessidade de colocar o /dispatch.fcgi/ no final da URL

2- o Dispatch.fcgi

#!/usr/bin/python
import sys, os
DJANGOPATH = lambda y:os.path.join(os.path.expanduser('~'),y)
PROJECT_PATH = DJANGOPATH('/var/www/html/golias.algoritmoweb.com.br/www')
sys.path.append(PROJECT_PATH)
os.environ['DJANGO_SETTINGS_MODULE'] = "settings"
from fcgi import WSGIServer
from django.core.handlers.wsgi import WSGIHandler
WSGIServer(WSGIHandler()).run()

Pronto sem mistérios.

Espero ter ajudado.
Orlando

FEDORA CORE 8 (7.90)

Acho relevante relatar a surra que tomei para instalar o fc7 no meu servidor amd64, o problema é que ele estava rodando na boa com o fc6, mais quando tentei instalar o fc7 o dito não reconhecia meu HD SATA II. Após muita procura descobri como resolver o problema, então ai vai.

Se você tem uma controladora "SATA controller: VIA Technologies, Inc. VT8251 AHCI/SATA 4-Port Controller" faça o seguinte:

Quando der boot pelo DVD ou CD, pressione o TAB, para ver a linha de boot, acrescente pci=nomsi no final e pressione enter.

Pronto agora o instalador vai mostrar o seu HD.

Espero ter ajudado.
Orlando Cesar

Django RDF Avançado

Eu me deparei com uma situação em que precisava gerar dois RDFs, um seria o Mestre e o outro Detalhe (Tipo nota e itens da nota). Para gerar o Mestre foi simples, basta usar a técnica padrão, mais a parte do Detalhe é um pouco diferente.

O models:

class Modulos( models.Model):
   nome = models.CharField(maxlength=50)
   descricao = models.CharField(maxlength=2048)

   def __str__(self):
       return self.nome

class SubModulos(models.Model):
   modulo =  models.ForeignKey(Modulos, related_name='sub_set')
   nome = models.CharField(maxlength=50)
   descricao = models.CharField(maxlength=2048)

   def __str__(self):
       return self.nome

Baseado no modelo acima, podemos observar que a class Modulos já carrega automaticamente os SubModulos, então quando vamos gerar o nosso RDF basta passar a class Modulos como parâmetro e fazer o seguinte no nosso template Cheetah:

<?xml version="1.0" encoding="ISO-8859-1"?>
#from modulos.start.models  import Modulos, SubModulos
<RDF:RDF xmlns:RDF="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
        xmlns:TABELA=" http://www.algoritmoweb.com.br/rdf#">
 <RDF:Bag RDF:about="urn:tabela">
 #for $item in $list
     #set $m = $Modulos.objects.get(pk=$item.id)
     #set $s = $m.sub_set.all()
     #for $sub in $s
     <RDF:li>
         <RDF:Description>
           <TABELA:id>$!sub.id</TABELA:id>
         <TABELA:nome>$!sub.nome</TABELA:nome>
         <TABELA:idModulo>$!m.id</TABELA:idModulo>
         <TABELA:moduloNome>$!m.nome</TABELA:moduloNome>
         <TABELA:descricao>$!sub.descricao</TABELA:descricao>
       </RDF:Description>
     </RDF:li>
      #end for
 #end for
  </RDF:Bag>
</RDF:RDF>

Observe que o processamento fica a cargo do Cheetah, usando dois #for, um para ler os itens do Modulo e o outro para pegar todos os SubModulos.

Espero ter ajudado.
Orlando Cesar

Django e RDF

Existe uma ferramenta para o Python chamada Cheetah, com ela você pode criar o seu RDF apartir de um Template agregado aos dados retornados de uma class Model do Django. Vamos ver como funciona?

Primeiro baixe e instale o Cheetah, conforme instruções contidas no site.

O arquivo views.py.

from Cheetah.Template import Template
rdf = 'entidades.rdf'
vm = 'templates/cheetah/entidades.vm'

def index(request):
   cria_rdf( rdf, Entidades¹, 'fantasia'¹, vm)
   return HttpResponse(template.render(dict()), \
                       mimetype=awlib.tipoXUL)

def cria_rdf( RDF, MODULO, MODULO_FIELD, CHEETAH):
   # aqui fica o caminho e o nome do arquivo RDF que será gerado.
   arq = 'caminho/' + RDF
   # aqui nos pegamos os dados do banco.
   lista = MODULO.objects.all().order_by(MODULO_FIELD)
   # aqui nos pegamos o arquivo template do Cheetah³.
   t = Template(file=CHEETAH)
   # aqui nos colocamos os dados do Models na variavél do template.
   t.list = lista
   # abre o arquivo RDF.
   out = open(arq, 'w')
   # grava os dados da lista.
   out.write(str(t))
   # fecha o arquivo.
   out.close()

Pronto o RDF foi gerado.

¹ Nome da class definida no arquivo models.py.
² Nome do campo que você quer classificar sua lista.
³ Agora vamos ver o Template RDF como fica:

<?xml version="1.0" encoding="ISO-8859-1"?>
<RDF:RDF xmlns:RDF="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
xmlns:TABELA="http://www.algoritmoweb.com.br/rdf#">
<RDF:Bag RDF:about="urn:tabela">
#for $item in $list
    <RDF:li>
        <RDF:Description>
            <TABELA:id>$item.id</TABELA:id>
            <TABELA:nome>$item.nome</TABELA:nome>
            <TABELA:fantasia>$item.fantasia</TABELA:fantasia>
        </RDF:Description>
    </RDF:li>
#end for
</RDF:Bag>
</RDF:RDF>

Quem está acostumado com o Velocity não vai sentir muita diferença.

Espero ter ajudado.
Orlando

Django e XUL

Olá pessoal.

Estou disponibilizando aqui minhas experiências com a Framework DJANGO e sua integração com o XUL.

Em primeiro lugar você deve mandar o Firefox liberar o acesso a sua aplicação, para isto inclua as seguintes linhas no seu arquivo prefs.js:

user_pref("signed.applets.codebase_principal_support", true);
user_pref("capability.principal.codebase.fullaccess.granted", "UniversalXPConnect");
user_pref("capability.principal.codebase.fullaccess.id", "http://ip ou dominio da aplicação");
Exemplo:
user_pref("capability.principal.codebase.fullaccess.id", "http://127.0.0.1");
ou
user_pref("capability.principal.codebase.fullaccess.id", "http://localhost");

Agora vamos ao DJango.

No seu arquivo views.py você deve definir o mimetype do arquivo que deseja exibir no seu navegador.

template = loader.get_template('seu_arquivo.xul')
tipoXUL = 'application/vnd.mozilla.xul+xml;charset=ISO-8859-1'

def index(request):
    return HttpResponse(template.render(dict()), mimetype=tipoXUL)

Pronto, é só executar.

Espero ter ajudado de alguma forma.
Orlando