3+ script in python semplici e utili per sviluppatori

Avete scritto un solo file o un intero progetto i cui sorgenti sono suddivisi tra 100 directory e subdirectory?
Avete dimenticato di includere una delle licenze GPL all'inizio del file?
Avete dimenticato la shebang a inizio file?
Avete dimenticato di includere la vim modeline alla fine dei vostri file?

Allora questa serie di (per ora) 3 script scritti in python vi potrebbe essere utile.
Segnalate tranquillamente errori/miglioramenti/idee per altri script.
Sono nati in modo molto spartano per esigenze personali, li pubblico perchè potrebbero servire ad altre persone:

bzr branch lp:~lorenzosfarra/+junk/simpledevelutils

Un terminale reale nel browser con JQuery e Django, parte II

Mentre la prima parte è incentrata sull'HTML, il codice javascript e il CSS, in questa seconda parte ci si concentrerà sul lato server-side, ovvero il codice python associato al framework Django.

Per la spiegazione del funzionamento di Django ovviamente rimando al sito ufficiale, in questo articolo vengono riportati solo i passaggi principali.
Vediamo innanzitutto il contenuto del file urls.py, che descrive lo schema delle URL di questa applicazione (molto semplice):

 # Copyright (C) 2010 Lorenzo Sfarra (lorenzosfarra@ubuntu.com)
 #
 # 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 2
 # 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.
 #


from django.conf.urls.defaults import *
from django.conf import settings

MEDIA_ROOT = settings.MEDIA_ROOT

urlpatterns = patterns('',
    (r'^cmd/(?P.*)$', 'terminaljs.terminal.views.cmd'),
    (r'^media/(?P.*)$', 'django.views.static.serve',
                            {'document_root': MEDIA_ROOT}),
    (r'^$', 'terminaljs.terminal.views.index'),
)

Definiamo quindi che una URL con cmd/ iniziale richiama la view cmd con un parametro "command", il comando da eseguire. Definiamo inoltre che le URL con "media/" iniziale devono essere processate staticamente, ed infine definiamo la URL predefinita che richiama la view index.

Passiamo quindi a vedere il codice delle view, definito nel file views.py:

# Copyright (C) 2010 Lorenzo Sfarra (lorenzosfarra@ubuntu.com)
 #
 # 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 2
 # 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.
 #


from django.shortcuts import render_to_response
from django.http import HttpResponse
from commands import getoutput
import os.path

# global variable
CWD = "/home/lorenzo"

def index(request):
    return render_to_response("index.html")

def is_trusted_command(command):
    #TODO: check if it's a trusted command
    return True

def cmd(request, command):
    global CWD
    if command.startswith("cd "):
        new_path = command.split(" ")[1]
        if not new_path.startswith("/"):
            # relative path
            new_path = os.path.join(CWD, new_path)
        if os.path.isdir(new_path):
            CWD = new_path
            output = ""
        else:
            output = "cd: " + new_path + ": No such file or directory"
    elif is_trusted_command(command):
        output = getoutput("cd %s; %s" %(CWD,command))
    else:
        output = "Untrusted command."
    return HttpResponse(output)

Da sottolineare, così come fatto nella prima parte, la funzione is_trusted_command che deve essere implementata anche server-side.

Ovviamente il tutto è puramente dimostrativo, per chi fosse interessato a migliorarlo è presente tutto il codice su Google Code.

Un terminale reale nel browser con JQuery e Django, parte I

Nell'articolo vediamo come realizzare un terminale che accetta comandi e che li esegue effettivamente su una macchina reale.
Questa prima parte si concentra sull'HTML, il codice Javascript e il CSS necessario.
La seconda parte verrà invece incentrata sul lato della programmazione python con il framework Django.
Il lato server è stato realizzato con il web framework Python Django, il lato client sfrutta la libreria JS JQuery anche per le chiamate AJAX.

L'HTML è piuttosto semplice e si trova nel file templates/index.html

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en-US" lang="en-US">
   <head>
       <title>Lorenzo Sfarra :: DJSterminal</title>
       <link rel="stylesheet" href="/media/css/terminal.css"/>
       <script type="text/javascript"
               src="http://www.google.com/jsapi"></script>
       <script type="text/javascript">
         // You may specify partial version numbers, such as "1" or "1.3",
         //  with the same result. Doing so will automatically load the
         //  latest version matching that partial revision pattern
         //  (e.g. 1.3 would load 1.3.2 today and 1 would load 1.4.2).
         google.load("jquery", "1.4.2");


       </script>

       <script src="/media/js/terminal.js" type="text/javascript">/* Terminal */</script>

       <script type="text/javascript">
         google.setOnLoadCallback(function() {
           /* Handle the enter keycode */
           $("#commandline").keypress(function(event) {
               if (event.keyCode == '13') {
                   event.preventDefault();
                   onEnterKey();
               }
           });
         });
       </script>
   </head>

   <body>
       <div id="terminal">
           <div id="terminaltop"><img src="/media/css/imgs/buttons.png" alt="buttons" align="left"/> <br/>Javascript Terminal</div>

<!-- Command line -->
           <textarea id="commandline" cols="80" rows="15">lorenzo@josie:~$ </textarea>
<!-- End command line -->
       </div>
   </body>
</html>

Nelle prime righe importiamo i file necessari. In particolare sfruttiamo Google per caricare la libreria JQuery.
Nelle linee 20-29 catturiamo il tasto Invio per gestire l'input come una riga di comando.

Il file terminal.js che contiene il sorgente javascript necessario si trova nella directory media/js, ed è il seguente:

/* Copyright (C) 2010 Lorenzo Sfarra (lorenzosfarra@ubuntu.com)
 
 * 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 2
 * 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.
 */



// The command line prompt
var cliPrompt = "lorenzo@josie:~$ ";

// the server address where the real console exists
var cliHost = "http://localhost:8000/";

function isTrustedCommand(command) {
    /** 
     * Function to check that the given command is trusted.
     * @param command the command to check
     * @return boolean
     */
    // TODO: check that this is a trusted command!
    return true;
}

function executeCommand(text, cliPrompt, command) {
    /**
     * Function to execute the given command through an AJAX call
     * and retrieve the result to update the textarea value.
     * @param text the current textarea value
     * @param cliPrompt the prompt
     * @param command the command to execute
     */
    // build the URL for the command
    remoteCommand = cliHost + "cmd/" + command;
    output = "";
    // Perform the AJAX call
    $.ajax({
        url: remoteCommand,
        type: 'GET',
        dataType: 'text',
        error: function(data, textStatus, errorThrown) {
            // readyState == 4? Error.
            if (data.readyState == 4) {
                output = "Connection error.\n"
            }
        },
        success: function(data) {
            output = data + "\n";
            $("#commandline").val([text, output, cliPrompt].join("\n"));
            // Textarea with focus at bottom
            $("#commandline").animate({ scrollTop: 99999}, 10);
        }
    });

}

function onEnterKey() {
    /* Function called when a user press the Enter key on its keyboard. */
    text = $("#commandline").val();
    // Get the command
    promptIndex = text.lastIndexOf(cliPrompt);
    // build the command
    command = text.substring(promptIndex + cliPrompt.length);
    if (command == "clear") {
        // simply clear the textarea value
        $("#commandline").val(cliPrompt);
    } else if (isTrustedCommand(command)) {
        executeCommand(text, cliPrompt, command);
    } else {
        output = "Invalid command.";
        $("#commandline").val([text,output,cliPrompt].join("\n"));
    }
}

La funzione principale è ovviamente executeCommand() che effettua la chiamata AJAX necessaria per eseguire realmente il comando sul server di riferimento.

ATTENZIONE: una funzione importantissima è isTrustedCommand(command) che ritorna "true" se il comando ha il "permesso" per essere eseguito. Questo ovviamente è necessario per proteggere il server. Al momento la funzione non effettua alcun controllo e ritorna immediatamente "true".

Il foglio di stile terminal.css si trova nella directory media/css.
Passa alla parte II ».

Per lo stile è stato preso come modello di riferimento il terminale presente nell'articolo "Forwarding E-Mails with Postfix".

Segnalazione: introduzione a Python 3

Python 3 è intenzionalmente incompatibile con la serie 2.x (e precedenti, ovviamente).
Volevo segnalare due guide molto pratiche, chiare e concise che IBM ha messo a disposizione sul proprio sito, che riguardano appunto Python 3, e più precisamente:

1. Le novità;
2. Argomenti avanzati.

Tra le novità analizzate c'è la funzione print(), le stringhe, nuovi meccanismi di I/O.
Tra gli argomenti avanzati, le eccezioni e soprattutto una panoramica molto ampia sulle classi e sugli argomenti annessi (decoratori, classi astratte, etc...).

Python: 5 volte più veloce

Si tratta di Unladen Swallow, un progetto che dovrebbe portare a un miglioramento della velocità di esecuzione del linguaggio di programmazione di 5 volte. Il progetto rimpiazzerà la virtual machine di CPython con una compilazione JIT (just-in-time) usando LLVM. È importante notare che sarà compatibile con le applicazioni attuali e, essendo implementato come branch del CPython convenzionale, eventuali miglioramenti potranno essere utilizzati facendo un merge. La prima milestone release annunciata al PyCon riscontra già un incremento del 15-25% delle performance rispetto all'implementazione CPython standard. È un progetto open source sponsorizzato da Google, in cui lavorano ingegneri della casa di Mountain View.
È possibile consultare la pagina del piano di sviluppo del progetto su Google Code.

Debugging tool per Gtk+ dagli sviluppatori di VMware

Parasite, uno strumento di debug che si applica al processo della propria applicazione GTK+, con il quale si può analizzare l'applicazione, vedere informazioni dettagliate sulla UI, la struttura gerarchica, le proprietà dei widget e altri dettagli. È anche possibile modificare le proprietà dell'applicazione mentre è in esecuzione per testare queste modifiche per poi eventualmente renderle effettive nel codice. Un'altra caratteristica è una shell python integrata.
È importante sottolineare che non si deve modificare l'applicazione o ricompilarla per lavorare con questo strumento, dato che una volta installato è utilizzabile con qualunque applicazione GTK+ includendo il nome del modulo nella variabile d'ambiente GTK_MODULES (GTK_MODULES=gtkparasite).
È molto utile dato che lo sviluppo e il debug delle UI è spesso complesso. Come riportano nel sito del progetto, per chi conosce Firebug, è un'applicazione analoga anche se applicata alle applicazioni GTK+.
È anche disponibile uno screencast introduttivo che spiega brevemente lo scopo e le funzioni di questo strumento, e un articolo di Ars Technica che ne spiega brevemente le caratteristiche. Rilasciato con licenza MIT.

Python 3.0 rilasciato

È stato rilasciato Python 3.0 (conosciuto anche come Python 3000 o Py3k), che segna un passaggio molto importante, essendo la prima versione intenzionalmente incompatibile con la serie 2.x (e precedenti, ovviamente). Il linguaggio sostanzialmente rimane lo stesso, cambiando molti dettagli (anche implementativi) come i dizionari e le stringhe, e molte caratteristiche deprecate sono state completamente rimosse. La libreria standard inoltre è stata riorganizzata. In un articolo precedente sono già segnalate alcune novità. Le novità sono comunque tutte spiegate nell'articolo che analizza le nuove caratteristiche di Python3.0 messo a confronto con la versione 2.6 (rilasciata nella versione 2.6.1).

Python 2.6, percorso verso Python 3.0

Il primo Ottobre è stato rilasciato python 2.6 (release schedule).
Qual è l'obiettivo principale di questo rilascio? Quello di fornire un passaggio per quanto possibile agevolato a Python 3.0, il quale spezzerà la backward-compatibility con le versioni 2.X, introducendo miglioramenti significativi in diversi settori e aspetti del linguaggio. Il lato negativo, ovviamente, è valutare le ripercussioni sul codice già esistente: python 2.6 aiuterà proprio in questo aspetto.
Lo stesso Guido Van Rossum afferma che una volta che si possiede un codice funzionante con python2.6 il passaggio alla versione 3.0 è possibile in diversi modi, come ad esempio abilitare i Py3k warnings che informeranno sull'eventuale utilizzo di codice obsoleto per il quale esiste un'alternativa, o importare funzioni dal modulo __future__ (per fare un esempio di utilizzo comune, si può importare la nuova funzione print, che è cambiata in molti aspetti, per rimpiazzare la keyword print standard, o utilizzare le funzioni contenute nel modulo future_builtins).
La descrizione ufficiale di questa versione è consultabile a questo indirizzo.

Django 1.0 Rilasciato

Finalmente rilasciata la versione stabile Django 1.0, dopo molto tempo e lavoro.
Solo per citare qualche numero, dall'ultima versione stabile ci sono stati 4000 commit e 2000 bug fixati.
La notizia completa sul sito ufficiale è a questo indirizzo.


P.S.: non conosci ancora django? È il momento giusto per leggere una breve overview qui e di visitare il sito ufficiale del progetto.

Python, Vim e IDE

Utilizzando Vim quotidianamente e programmando in python, ho trovato molto interessante un articolo trovato in rete che contiene alcune tips molto interessanti, alcune già conosciute, altre meno.
Alcuni degli argomenti che sono trattati (e che potrebbero eventualmente mancarvi usando vim al posto di alcuni IDE) sono:

• Saltare liberamente dal codice che si sta scrivendo al codice di qualche libreria;
• Completamento del codice;
• Documentazione "al volo";
• Syntax Checking;
• Debugging;
• Altro...

L'articolo completo è a questo indirizzo.

Python Magazine

È stato pubblicato il primo numero di Python Magazine ed è liberamente e gratuitamente scaricabile. Articoli interessanti e molti esempi rendono questo primo numero davvero interessante. Dato che non costa nulla leggerlo, perchè non farlo? :)

Perchè scegliere python per amministrare sistemi UNIX

L'amministrazione di sistemi UNIX richiede diversi compiti, dalla gestione degli utenti, dei processi e dei dispositivi al backup.
Con vari shell script è possibile facilitare/velocizzare/automatizzare vari compiti.
Ma perchè non scegliere python anche per questi compiti? In un articolo su ibm.com, James Knowlton ci mostra come con questo linguaggio sia semplice e pratico creare script destinati all'amministrazione di sistemi UNIX, con alcuni esempi utili.
L'articolo completo, in inglese, è consultabile a questo indirizzo.

Python 3000: rilasciata la prima alpha

Direttamente da un annuncio di Guido van Rossum (creatore di python) apprendiamo la notizia del rilascio di Python 3.0a1.
L'annuncio con tutte le informazioni ed il link per il download è consultabile (in inglese) a questo indirizzo.

Python 3000

Più che un articolo vero e proprio è la segnalazione di un articolo. Per chi come me è un grande "fan" di python, questo articolo risulterà particolarmente interessante, in quanto è un report sullo stato di Python 3.0 (come verrà chiamato il prodotto ultimato, mentre "python 3000" si riferisce al progetto) scritto da Guido van Rossum, inventore del linguaggio stesso. Tratta di alcuni cambiamenti, alcune novità, il motivo dello "slittamento" della data di rilascio, altro ...