Primeiro passo é adicionar as bibliotecas JQuery e JSTree na página.

Inserir uma função JavaScript e uma div no corpo da página, nesse caso chamei a div de tree.

Após criar uma função dentro do arquivo views.py, que irá converter o modelo Estado em um objeto json no formato exigido pela biblioteca jstree.

def jstreeJson(request):
    estados = Estado.objects.all()
    treeJson = []
    for e in estados:
        cidades = e.cidades.all()
        cids = []
        for c in cidades:
            cids.append( {'data' : str(c.nome) , "attr" :{  "id" :  str(c.nome) }})
        treeJson.append({'data' : str(e.nomeEstado), 'children' : cids,
                          })
    json = simplejson.dumps(treeJson)
    return HttpResponse(json,mimetype="application/json")

E por último adicionar a url dentro do arquivo urls.py

(r'^ajax/jstreeJson', 'jstreeExample.jstree.views.jstreeJson'),

OK. Está criada a árvore a qual fica da seguinte forma:

Para mais detalhes consulte o código fonte.

Referências:
http://www.jstree.com/documentation/json_data
Código Fonte: http://github.com/petryx/petryx.blogrs.com.br

Vamos ao script:

#!/usr/bin/python
# -*- coding: iso-8859-1 -*-
#Author: Marlon Luis Petry
#Licença GPL
import smtplib
from email.MIMEMultipart import MIMEMultipart
from email.MIMEBase import MIMEBase
from email.MIMEText import MIMEText
from email.Utils import COMMASPACE, formatdate
from email import Encoders
import os
import tarfile
import time
import datetime
import re

def sendMail(to, subject, text, files=[],server="localhost"):
    assert type(to)==list
    assert type(files)==list
    fro = "Server Backup "
    msg = MIMEMultipart()
    msg['From'] = fro
    msg['To'] = COMMASPACE.join(to)
    msg['Date'] = formatdate(localtime=True)
    today = datetime.date.today()
    msg['Subject'] = subject + str(today)
    msg.attach( MIMEText(text) )
    for file in files:
        part = MIMEBase('application', "octet-stream")
        part.set_payload( open(file,"rb").read() )
        Encoders.encode_base64(part)
        part.add_header('Content-Disposition', 'attachment; filename="%s"'
                      % os.path.basename(file))
        msg.attach(part)
    smtp = smtplib.SMTP(server)
    smtp.sendmail(fro, to, msg.as_string() )
    smtp.close()

def backupTar(nameBackup,conf="/etc/backup.conf"):
    tar = tarfile.open(nameBackup,'w:bz2')
    f = open(conf,'r')
    p = re.compile('\#')
    for line in f:
	    if not p.match(line): #descarta linhas que comecem por #
		file = line.replace('\n','') # Remove \n
		tar.add(file) #adiciona ou arquivo tar
    tar.close()	

name = 'backupSRV.tar.bz2' #nome do backup
backupTar(name)
sendMail(["xxxx@gmail.com"],"backup","backup",[name])

O arquivo de configuração deve estar no /etc/backup.conf, exemplo da estrutura do arquivo:

/etc/postfix/
/etc/apache2/
/root/scripts/

O arquivo não deve possuir linhas em branco

Depois de configurado é só inserir no crontab o script para gerar o backup e enviar por email nos horários desejados.

Utilizei o firefox para realizar o download, o qual possui a característica de adicionar ao nome do download a extensão .part. Através desse princípio desenvolvi o script, o qual verifica a existência do arquivo *.part, existindo o arquivo o script dorme por um minuto, quando o arquivo deixar de existir o computador será desligado.

import os.path
from time import sleep
import commands

while 1:

        if os.path.exists('/home/marlon/downloads/teste.rar.part'):
                print 'espera 1 minuto'
                sleep(60)
        else:
                os.system("poweroff")

Hoje pela manhã, o computador estava desligado!

A linguagem Python é muito versátil e elegante, excelente para desenvolvimento rápido. Este script pode ser modificado para tomar a decisão através do tamanho do arquivo, que com Python pode ser descoberto através do método os.path.getsize(‘file’).

Forte abraço.

Hoje tive essa necessidade pois baixei as fotos da máquina fotográfica com o programa Digikam, pois minha máquina baixa as fotos através do protocolo PTP. A biblioteca libghoto2 se encarrega de implementar o protocolo e o Digikam é um front end.

Bom mas o post é pra mostrar um script em Python para renomear a extensão de vários arquivos ao mesmo tempo. Quando baixei a fotos para o note a extensão ficou em Maiúsculo *.JPG foi necessário renomear para .jpg pois tem programas que não reconhecem a extensão .JPG como foto.

Esse script é uma adpatação do post Encontre Arquivos Recursivamente

#!/usr/bin/env python
#  -*- coding: iso-8859-1 -*-
#  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; version 2 of the License.
#  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.
#
# author: Marlon Petry
# Date: 2008/09/01
# Function: Rename Files in Python
#

import os
import re

class findFiles:

    def __init__(self):
            self.result = []
    def findRecursive(self,path):
        if os.path.isdir(path) and not os.path.islink(path):
           files = os.listdir(path)
           self.result.append('d ' + path)
           for file in files:
              a = os.path.join(path,file)
              self.findRecursive(a)
        else:
           self.result.append('- ' + path)

    def rename(self,path,orig,new):
        reg = re.compile(orig)
        if os.path.isdir(path) and not os.path.islink(path):
           files = os.listdir(path)
           for file in files:
               newExt = re.compile(orig).match
               if newExt(file):
                  c = os.path.splitext(file)
                  b = c[0] + new
                  a = os.path.join(path,file)
                  b = os.path.join(path,b)
                  os.rename(a,b)

find = findFiles()
find.rename('/home/marlon/fotos/demoto.blogrs.com.br/','.*JPG','.jpg')

Espera que seja útil para mais alguém pois pra mim foi uma mão na roda. Renomear 400 arquivos na mão é muito enfadonho.

Abraços.

O primeiro exemplo é o algoritmo para cálculo do fatorial desenvolvi um classe que calcula o fatorial recursivamente def fatorialRecursive(self, x): e não recursivo def fatorialSimulateRecursive(self, x): o qual calcula o fatorial usando uma pilha, com esse método conseguimos calcular o fatorial de !1000 já com o método recursivo recebemos a seguinte exceção RuntimeError: maximum recursion depth exceeded. Eis uma vantagem de usar uma pilha ao invés de usar recursão.

#!/usr/bin/env python
#  -*- coding: iso-8859-1 -*-
#  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; version 2 of the License.
#  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.
#
# author: Marlon Petry
# Date: 2008/07/06
# Function: Remove Recursion with one Stack in python
#
class Stack:

     def __init__(self):
         self.stack = []

     def push(self,object):
         self.stack.append(object)

     def pop(self):
         if len(self.stack) == 0:
            raise "Error", "stack is empty"
         obj = self.stack[-1]
         del self.stack[-1]
         return obj

     def isempty(self):
         if len(self.stack) == 0:
            return False
         else:
            return True

class CalculusFatorial:
    stack = Stack()
    def fatorialRecursive(self, x):
        if x == 0:
            return 1
        else:
            return (x * self.fatorialRecursive(x - 1))

    def fatorialSimulateRecursive(self, x):
        factorial = 1;
        while x > 0:
            self.stack.push(x)
            x -= 1

        while self.stack.isempty():
            factorial *= self.stack.pop()

        return factorial

calc = CalculusFatorial()
print calc.fatorialRecursive(950)
print "Não recursivo"
print calc.fatorialSimulateRecursive(950)
calc.show()

O segundo algoritmo é a Torre de Hanoi, muito mais complexo para remover a recursividade fiquei uns dois dias tentando resolver até que encontrei um artigo que descreve como remover a recursão http://obelix.ee.duth.gr/~apostolo/TowersOfHanoi/index.html#non-recursive. Então segui os passos descritos no artigo e consegui chegar a solução.

#!/usr/bin/env python
#  -*- coding: iso-8859-1 -*-
#  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; version 2 of the License.
#  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.
#
# author: Marlon Petry
# Date: 2008/07/06
# Function: Tower Hanoi Remove Recursion with one Stack in python
#
import pdb
import sys

class Stack:

   def __init__(self):
       self.stack = []

   def push(self,object):
       self.stack.append(object)

   def pop(self):
       if len(self.stack) == 0:
          raise "Error", "stack is empty"
       obj = self.stack[-1]
       del self.stack[-1]
       return obj

   def isempty(self):
       if len(self.stack) == 0:
          return False
       else:
          return True

class Hanoi:
    stack = Stack()
    def hanoi(self,disk,src,dst,temp,tipo):
        if(disk == 1):
            print "Disk %d Move da haste %d para haste %d tipo %d" % (disk,src,dst,tipo)
        else:
	    #pdb.set_trace()
            self.hanoi(disk - 1 , src, dst, temp,1)
            print "Disk %d Move da haste %d para haste %d tipo %d" % (disk,src,temp,tipo)
            #pdb.set_trace()
	    self.hanoi(disk - 1, dst, temp, src,2)

    def hanoiNotRecursive(self,disk,src,dst,temp,tipo):
        flag = -1;

        while disk > 0:
 	    self.stack.push((disk, src, dst, temp,1))
	    disk = disk -1
	    flag += 1
	while flag >= 0:

	    disk,src,dst,temp,tipo = self.stack.pop()
	    flag -=1;
	    if disk == 1:
	    	print "Disk %d Move da haste %d para haste %d tipo %d" % (disk,src,dst,tipo)
            else:
		print "Disk %d Move da haste %d para haste %d tipo %d" % (disk,src,temp,tipo)
	    disk -= 1
	    while disk > 0:
	      self.stack.push((disk, dst, temp, src,2))
              disk = disk - 1
	      flag += 1

testeHanoi = Hanoi()
testeHanoi.hanoi(18,1,2,3,0)
print "Hanoi not recursive"
testeHanoi.hanoiNotRecursive(3,1,2,3,1)

Não cheguei a calcular o tempo de execução para ver se existe diferença talvez faça isso em um próximo post.

Estou participando do concurso Intel Moblin com o projeto Great Picture se achar interessante o projeto seu voto será muito bem vindo mais detalhes sobre o projeto aqui.

Bom chega de conversa e vamo mostrar o código.

#!/usr/bin/env python
#  -*- coding: iso-8859-1 -*-
#  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; version 2 of the License.
#  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.
#
# author: Marlon Petry
# Date: 2008/07/06
# Function: find files recursively in python
#   

import os
import re

class findFiles:

    def __init__(self):
        self.result = []

    def findRecursive(self,path):
        if os.path.isdir(path) and not os.path.islink(path):
           files = os.listdir(path)
           self.result.append('d ' + path)
           for file in files:
             a = os.path.join(path,file)
             self.findRecursive(a)
        else:
           self.result.append('- ' + path)

    def show(self):
        for r in self.result:
            print r

find = findFiles()
find.findRecursive('/home')
find.show()

Se gostaram do post assine os Feed.

ORM (Object Relacional Mapper), Mapeamento objeto relacional serve para reduzir a impedância entre banco de dados relacional e programação orientada a objetos. O modelo relacional de banco de dados é muito confiável sendo largamente utilizado nos dias de hoje, sendo baseado em tabelas, linhas e colunas, já a programação orientada a objetos tem como elemento base um objeto que é definido por seus atributos e métodos.

Para desenvolver um software orientado a objetos, salvando o estado dos objetos em um banco de dados relacionais, pode ser feito manualmente através de SQL o que é complicado. Por isso usaremos o SQLAlchemy que fará esse mapeamento objeto relacional.

Este tutorial demonstra como utilizar o SQLalchemy versão 0.4.6, que é uma ferramenta SQL escrita em Python e um ORM(Object Relacional Mapper), fornecendo uma camada de abstração para unir os dois mundos, sendo possível desenvolver software sem usar SQL, para interagir com o banco de dados.

O SQLAchemy possui dialetos para se comunicar com os seguintes banco de dados: SQLite, Postgres, MySQL, Oracle, MS-SQL, Firebird, MaxDB, MS Access, Sybase and Informix; DB2.

Instalando:

Para instalar o SQLAlchemy iremos utilizar a ferramenta setuptools que pode ser baixada aqui, e instalada com o seguinte comando:

python ez_setup.py

Após instalado o setuptools agora iremos instalar o SQLAlchemy com o comando:

easy_install SQLAlchemy

Este comando irá conectar a internet, baixar a última versão e instalar na sua máquina.

Necessitamos também de um banco de dados. Para facilitar nossa vida iremos utilizar o sqlite3, um banco de dados simples de utilizar e instalar:

Instalando sqlite3 gentoo

emerge -av sqlite

Pode ser instalado também baixando o um binário pré compilado

wget http://www.sqlite.org/sqlite3-3.5.9.bin.gz
gunzip sqlite3-3.5.9.bin.gz
cp sqlite3-3.5.9.bin /usr/bin

Instalar o pysqlite3 para python conectar ao banco sqlite3

easy_install pysqlite

Definindo as Classes

Começaremos definindo as classes que serão mapeadas para o banco de dados. O nosso domínio será um sistema de venda online mas no momento iremos criar a classe Cliente, mapear ela no banco, logo após salvar ela no banco, e executar algumas pesquisas. Na segunda parte será criado um relacionamento um para muitos onde iremos criar a classe endereço, e na última parte iremos mapear a classe Forma de Pagamento que será a superclasse das classes Cartão de Credito, dinheiro e boleto.

Logo abaixo está o código completo utilizado, após o código explicaremos linha por linha:

from sqlalchemy import *
from sqlalchemy.orm import *

class Cliente(object):

	def __init__(self,nome,rg,cpf):
		self.nome = nome
		self.rg = rg
		self.cpf = cpf

	def __repr__(self):
		return "" % (self.nome,self.rg,self.cpf)	

db = create_engine('sqlite:///:memory:', echo=False)

metadata = MetaData()	

#Cria a tabela Cliente

ClienteTable = Table('cliente', metadata,
	Column('id', Integer, primary_key=True),
	Column('nome', String(40)),
	Column('rg', String(10)),
	Column('cpf', String(12))
)

metadata.create_all(db) 

#mapeando
mapper(Cliente,ClienteTable)

cliente1 = Cliente('Marlon','1012123302','12345678901')
cliente2 = Cliente('Paulo','3414423302','12345678901')
cliente3 = Cliente('Joao','8765123302','12345678901')
cliente4 = Cliente('Jose','3212123302','12345678901')
cliente5 = Cliente('Mauro','3456123302','12345678901')

#criando a sessao

Session = sessionmaker(bind=db, autoflush=True, transactional=True)

session = Session()

session.save(cliente1)
session.save(cliente2)
session.save(cliente3)
session.save(cliente4)
session.save(cliente5)

session.commit()

#consultando

query = session.query(Cliente)

print 'Lista todos e mostra o nome\n'
for cliente in session.query(Cliente):
	print cliente.nome

print '\nLIMIT e OFFSET\n'

for c in session.query(Cliente)[1:3]:
	print c

print '\nFiltrando por Nome\n'

for cliente in session.query(Cliente).filter_by(nome='Marlon'):
	print cliente

print '\n Usando like\n'

query = session.query(Cliente).filter(Cliente.nome.like('%Ma%'))
query.all()

Importando as bibliotecas

Na linhas 1 e 2 são importadas todas as classes da bibliotecas sqlalchemy e sqlalchemy.orm

Definindo a classe Cliente

A classe cliente é definida a partir da linha 4 até a linha 12, possuindo os seguintes atributos: nome, rg e cpf. O construtor da classe __init__(self, nome, rg, cpf) tem como parametros o nome, rg e cpf o metodo __repr__(self):, serve para mostrar uma string de representação da classe.

Conectando ao Banco

Nesse tutorial é utilizado o banco de dados sqlite in-memory, sendo útil testar o mapeamento. A conexão com o banco é realizada na linha 15. A variável echo serve para mostrar os comandos sql que serão executados no banco, caso não seja do seu interesse ver os comando SQL gerados ajuste a variável para False ex: echo=False.

Definindo e criando as tabelas

Devemos informar para o SqlAlchemy os tabelas que iremos utilizar a sintaxe é parecida com o comando CREATE TABLE do SQL, as definições da nossa primeira tabela é demonstrada a partir da linha 22 até a 27.

O objeto MetaData que faz a ligação entre o objeto em Python com o banco de dados, se perceber na linha 22, devemos passar o objeto metadata para criar a tabela cliente. E no próximo passo devemos informar ao objeto metadata que queremos criar a tabela dentro do banco, para isso o método create_all(db) deve ser chamado linha 29 passando o objeto de referencia para o banco de dados. Então antes de executar o comando SQL será verificado se a tabela já existe no banco ou não.

2008-06-03 14:51:21,192 INFO sqlalchemy.engine.base.Engine.0x..2c PRAGMA table_info("cliente")
2008-06-03 14:51:21,193 INFO sqlalchemy.engine.base.Engine.0x..2c {}
2008-06-03 14:51:21,195 INFO sqlalchemy.engine.base.Engine.0x..2c
CREATE TABLE cliente (
        id INTEGER NOT NULL,
        nome VARCHAR(40),
        rg VARCHAR(10),
        cpf VARCHAR(12),
        PRIMARY KEY (id)
)

2008-06-03 14:51:21,196 INFO sqlalchemy.engine.base.Engine.0x..2c {}
2008-06-03 14:51:21,197 INFO sqlalchemy.engine.base.Engine.0x..2c COMMIT

Agora a tabela no banco está criada com as colunas necessárias para a classe cliente, então devemos fazer o mapeamento objeto relacional.

Mapeando

Para realizar o mapeamento objeto relacional utilizamos a biblioteca sqlalchemy.orm esta possui o método mapper() o qual cria um mapeamento entre a tabela ClientTable e a classe Cliente mostrado na linha 31.

Agora vamos criar 5 clientes conforme mostrado da linha 33 a 37, note que devemos informar o nome, rg e cpf.
Executando em um terminal python

>>> cliente1
>>> str(cliente1.id)
'None'

De onde surgiu o atributo id pois na classe Cliente não temos esse atributo. Esse atributo foi inserido na nossa classe quando realizamos o mapeamento na linha 31 veja

>>>dir(Cliente)
['__class__', '__delattr__', '__dict__', '__doc__', '__getattribute__', '__hash__', '__init__', '__module__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__str__', '__weakref__', '_class_state', 'c', 'cpf', 'id', 'nome', 'rg']
>>>

Os atributos da classe Cliente foram modificados para realizar o mapeamento. O atributo id serve para mostrar o indice na tabela por enquanto esta nulo, mas no momento que chamarmos o método commit() na linha 50 ele será automaticamente atualizado.

Criando a sessão

Como já definimos a classe e a tabela podemos interagir com o banco, para existir a interação devemos criar o objeto Session, na linha 40 chamamos o construtor sessionmaker onde passamos como parâmetro o conexão com o banco bind = db, autoFlush=True e transactional=True informado que iremos utilizar transações.
E na linha 42 criamos o objeto session, agora já podemos salvar nossos clientes no banco, executar o session.commit() e ver o que acontece com o atributo id.

>>>cliente1.id
1

Então nosso cliente está salva no banco. Para ficar mais interessante vamos realizar uma pesquisas (queries).

Consultando

As consultas utilizam o método session.query(objeto) no nosso exemplo o objeto será a classe Cliente.

Na linha 59 até a 61 tem o exemplo de um laço “for” que mostra o nome de todos os clientes.

A linha 67 e 68 mostra um exemplo de como usar Limit e Offset

Já na linha 72 e 73 mostra como listar todos os cliente que tenha o nome Marlon.

E por fim a linha 77 e 78 mostra o uso de expressões regulares, listando todos os clientes que contenham as letras %Ma%.

Qualquer duvida deixe um comentário será um prazer esclarecer.

Download do código

This is my first post in English, sorry any is grammatical errors !!!

My intention is write a little tutorial in Python showing how to make an oriented objects chat server using sockets and threads.

A skeleton of the chat server is basically given by the following loop:

1. Wait for client connection
2. After the client to be connected start a thread to each new client
3. Get the user name and nickname
4. Entry in a loop to read the socket if exists new messages send all clients except client who generated the message

Let’s begin by waiting client connection

The following snippet of code creates a socket of type stream at line 1, and associate it with the server socket at port 5800 line 4, finally listen for new connections at line 7.

    serversocket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    serversocket.setsockopt( socket.SOL_SOCKET, socket.SO_REUSEADDR, 1 )
    try:
        serversocket.bind(('',5800))
    except ValueError,e:
        print e
    serversocket.listen(5)

Until now we have one server socket listening at port 5800, but it is not allow client connections. When connection request arrives, the server decides if it will be accept. In order to accept a connection the method accept() should be invoked. This method doesn’t take parameter and return a tuple (clientsocket, address), where clientsocket is a new socket server used to communicate with the client and address is the client address. The following snippet of code illustrates one loop waiting by new clients.

while True:
        (clientSocket, address) = serversocket.accept()

At this moment we have one server socket waiting for new connections. Now we have to write a client class which will be inherit methods and attributes by the thread class. In order to know all clients connected at the server we will be storing the client socket at a List.

Well, now we will write a class Client that inherits a class Thread and will have the following methods:
sendAll() to send messages for all clients except a client that send messages;
newClientConnect() this method gets the user name, nick and stores at a sockets List ;
printHelp() show how to use chat;
run() This is the main thread method where the client.start() method will be invoked it will by each client, and perform tasks how: read socket, verify if the message have commands, after that, send messages for all clients.

#!/usr/bin/env python
# -*- coding: iso-8859-1 -*-
# 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; version 2 of the License.
# 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.
#
#author: Marlon Petry
#Date: 2008/04/30
#Function: Chat server in python
#
import sys
from threading import Thread
import socket

allClients = []

class Client(Thread):
	def __init__(self,clientSocket):
		Thread.__init__(self)
		self.sockfd = clientSocket #socket client
		self.name = ""
		self.nickName = ""

        def printHelp(self):
                str = "======================================\n"
		str = str + "Chat Help\n\q quit\n"
                str = str + "======================================\n"
		return str

        def newClientConnect(self):
		self.sockfd.send("Welcome my first chat\n")
		self.sockfd.send("Login: ")
		name = self.sockfd.recv(2048)
		self.name = name.strip()
		self.sockfd.send("NickName: ")
		nickName = self.sockfd.recv(2048)
		self.nickName = nickName.strip()
		allClients.append(self.sockfd)

	def sendAll(self,buff):
		for index, clientSock in enumerate(allClients):
			if self.sockfd != clientSock:
			   print (self.sockfd == clientSock)
			   try:
			       s = clientSock.send("[%s] => %s"%(self.nickName, buff))
			   except socket.error,e:
                               print "error socket %s\n" % e
                               clientSock.close()
                               del allClients[index]

	def run(self):
	        self.newClientConnect()
		while True:
			buff = self.sockfd.recv(2048)
			if buff.strip() == '\q':
			     self.sockfd.close()
			     break # Exit when break
			elif buff.strip() == '\?':
			     str = self.printHelp()
			     self.sockfd.send(str)
			else:
			     self.sendAll(buff)

if __name__ == "__main__":

    serversocket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    serversocket.setsockopt( socket.SOL_SOCKET, socket.SO_REUSEADDR, 1 )
    try:
        serversocket.bind(('',5800))
    except ValueError,e:
        print e
    serversocket.listen(5)
    while True:
        (clientSocket, address) = serversocket.accept()
        ct = Client(clientSocket)
        ct.start()
__all__ = ['allClients','Client']

How to use

Start server

python server.py

Connect client

telnet 127.0.0.1 5800
Trying 127.0.0.1...
Connected to 127.0.0.1.
Escape character is '^]'.
Welcome my first chat
Login: Hi
NickName: uhuuu

Connect more clients for test

Thats all Folks!!!!!!!!
References:
Python Network Programming, Sebastian V. Tiponut, Technical University Timisoara

Special Thanks to my friends Milton Rocca and Marco Antonio de Castro Barbosa.