PDFme is an open source project that you do anything with pdf files.

So, up until this point I’ve been tinkering with TKinter, the python graphics module. Coming from someone who had only used the Zell graphics package up until that point, TKinter is spectacularly awesome! I know it’s not exactly the most extensive graphics package ever made, but it really does have some interesting features. I was particularly impressed with how easy it is to use. You usually expect something like this to be overly complex and near impossible to read. (Anyone that has ever tried to code a Java GUI by hand will understand this.) TKinter, even on the most basic level, is straight forward and simple.

I’ve been writing a python Paint program. Just to see what it could do. I don’t really expect to ever finish it but it was quite the learning experience. With just the documentation, I managed to navigate through most of the built-in classes and even played around with events and mouse clicks. The entire process was more or less: Think of what I want to do, look for a wigit class, create the wigit. Done.

Next Project: Figure out what Visual Studio does.

It would be nice to have a way to build quick-n-dirty GUIs so I can GUI-enable tools when that makes sense… but I’ve always just had a mental block about “going to that length”.

Yesterday though, I was flipping through Python in a Nutshell and I saw a GUI example there (p. 329) that was so simple I typed it in and tried it out :

import sys, Tkinter
Tkinter.Label(text="Welcome!").pack()
Tkinter.Button(text="Exit", command=sys.exit).pack()
Tkinter.mainloop()

That yields a simple little dialog:

…that can be resized:

I need to try some more of this!

http://python.org/doc/life-preserver/index.html

    def AE_appear(self):
        if on:

            if not self.AE_optionbar.winfo_ismapped():
                self.AE_optionbar.pack(side=’left’, padx = 10, pady = 1,fill=’both’)

            else:#turn off

              if self.AE_optionbar.winfo_ismapped():
                            self.AE_optionbar.pack_forget()

import Tkinter, tkFileDialog

try:

root = Tkinter.Tk()

root.withdraw()

files = tkFileDialog.askopenfilenames(parent = root,multiple =1)

finally:

root.destroy()

More work on gpdbcleaner. Today has been one of those sessions where I feel like I’m learning by leaps and bounds.

I changed the GUI to use the “grid” layout manager. This just seems cleaner than the “pack” manager. I also added message widgets which return the filenames being worked on (the PDB file to open and the save file name).

Along the way I learned about StringVar(). This allowed me to dynamically update the filenames as they were altered by the user, and I can finally pass the filenames between functions! I got rid of the clunky global file list I was using before.

I’ve also modified the “Open” button to perform two functions. The first is the same as before, to set the filename. The second reads in a listing of all record names in the PDB file. This is in preparation for an expansion in which I’ll let the user choose which record names to include in the “Clean” file.

Here is a screenshot of what the program looks like these days:

gpdbcleaner interface

And here is the source code:

#!/usr/bin/python

# http://biostumblematic.wordpress.com

import sys, re, tkFileDialog, string
from Tkinter import *

recordnames = []

class Gpdbcleaner:
    def __init__(self, root):
        '''Set up the TKinter window'''
        frame = Frame(root)
        frame.pack(fill=BOTH)

        self.openbutton = Button(frame, text='Select PDB file', command=self.openfile)
        self.openbutton.grid(row=0, sticky=W)

        self.openfilename = StringVar()
        self.openfilename.set('')

        self.openfile = Label(frame, width=50, relief=SUNKEN, anchor=W, textvariable=self.openfilename)
        self.openfile.grid(row=0, column=1, sticky=W)

        self.savefilename = StringVar()
        self.savefilename.set('')

        self.savebutton = Button(frame, text='Save As', command=self.asksaveasfilename)
        self.savebutton.grid(row=1, sticky=W)

        self.savefile = Label(frame, width=50, relief=SUNKEN, anchor=W, textvariable=self.savefilename)
        self.savefile.grid(row=1, column=1, sticky=W)

        self.runbutton = Button(frame, text='Run', fg='green', command=self.run)
        self.runbutton.grid(row=2, sticky=W)

        self.quitbutton = Button(frame, text='Quit', fg='red', command=frame.quit)
        self.quitbutton.grid(row=2, column=1, sticky=W)

    def openfile(self):
        self.askopenfilename()
        self.getrecordnames()

    def askopenfilename(self):
        '''Get the name of the PDB file to be cleaned up'''
        dirtyfile = tkFileDialog.askopenfilename()
        self.openfilename.set(dirtyfile)

    def asksaveasfilename(self):
        '''Get the save as file name'''
        cleanfile = tkFileDialog.asksaveasfilename()
        self.savefilename.set(cleanfile)

    def getrecordnames(self):
        '''Create a list of all the record names in the PDB file'''
        filetoopen = self.openfilename.get()
        inputfile = open(filetoopen, 'r')
        lines = inputfile.readlines()
        for line in lines:
            recordmatch = re.match('^\S*', line)
            record = recordmatch.group()
	    if record in recordnames:
	        pass
	    else:
	        recordnames.append(record)
        inputfile.close()

    def run(self):
        '''Perform the cleanup'''
        atomrecords=[]
        filetoopen = self.openfilename.get()
        inputfile = open(filetoopen, 'r')
        lines = inputfile.readlines()
        for line in lines:
            match = re.search('^ATOM', line)
            if match:
                atomrecords.append(line)
            else:
                pass
        atomrecords.append('END')
        inputfile.close()

        # Write out the records
        filetowrite = self.savefilename.get()
        outputfile = open(filetowrite, 'w')
        outputfile.writelines(atomrecords)
        outputfile.close()

root = Tk()
root.title('PDB cleaner')

gpdbcleaner = Gpdbcleaner(root)

root.mainloop()

I still don’t completely understand the way functions interact with one another, but here is working code for the PDB cleaner with a very basic TKinter GUI.

#!/usr/bin/python

# http://biostumblematic.wordpress.com

import sys, re, tkFileDialog
from Tkinter import *

filelist=[]

class Gpdbcleaner:
    def __init__(self, root):
        '''Set up the TKinter window'''
        frame = Frame(root)
        frame.pack()

        self.openbutton = Button(frame, text='Select PDB file', command=self.askopenfilename)
        self.openbutton.pack(side=LEFT)

        self.savebutton = Button(frame, text='Save As', command=self.asksaveasfilename)
        self.savebutton.pack(side=LEFT)

        self.runbutton = Button(frame, text='Run', fg='green', command=self.run)
        self.runbutton.pack(side=LEFT)

        self.quitbutton = Button(frame, text='Quit', fg='red', command=frame.quit)
        self.quitbutton.pack(side=LEFT)

    def askopenfilename(self):
        '''Get the name of the PDB file to be cleaned up'''
        dirtyfile = tkFileDialog.askopenfilename()
        return filelist.append(dirtyfile)

    def asksaveasfilename(self):
        '''Get the save as file name'''
        cleanfile = tkFileDialog.asksaveasfilename()
        return filelist.append(cleanfile)

    def run(self):
        '''Perform the cleanup'''
        atomrecords=[]
        inputfile = open(filelist[0], 'r')
        lines = inputfile.readlines()
        for line in lines:
            match = re.search('^ATOM', line)
            if match:
                atomrecords.append(line)
            else:
                pass
        atomrecords.append('END')
        inputfile.close()

        # Write out the records
        outputfile = open(filelist[1], 'w')
        outputfile.writelines(atomrecords)
        outputfile.close()

root = Tk()

gpdbcleaner = Gpdbcleaner(root)

root.mainloop()

Next step: making the program more powerful and flexible.

Me and Kaushani were reading the tutorials on Tkinter (its a GUI module in python for those who don’t know) and we thought of writing a simple Cross’n'Not game using that.We are just so called ‘Bathroom Coders’(plz don’t take the literal meaning) and so our code might seem a little inappreciable to the regular coders.Therefore, we firmly welcome recommendations,comments and suggestions wherever needed.

Here’s the code for Cross ‘n’ Not V0.1 or you can even download from the link given at he bottom of the post.

P.S. Few exceptions will be raised when you terminate the application.Kindly bear with it as we are currently working on it and will come up with a better version very soon .Suggestions are always welcomed.

DOWNLOAD

I do like python a lot, but I feel some things are still missing. Correct me if I’m wrong.

* How do I know what can I import? I can use help(os) but how do I know that ‘os’ exists (from within the interpreter). I want a command like dir that can searche through the default import directories. “mdir” (like module dir) or “pdir” (package dir).
* Tkinter sucks, why isn’t wx or anything else included?
* The php documentation really makes me jealous because the user contributed comments are VERY useful. Why doesn’t python docs have some web 2.0 in it? Like digg’s comment system.
* So many crappy IDE’s, I can’t find one that’s good for everything. At first I liked Wing but nowadays it’s way too slow and heavy so I switched to SPE which is great except it can crash for no reason.
* The GIL needs to be taken more seriously with a dedicated page explaining why it’s in place, how to escape it’s suckiness, and a roadmap to minimize the damage. Alot of people care about performance more than idiot-proof concurrency.

And I think i have a few more rants to go on about this, I’ll post ‘em when I recall.

Great post on entry widget validation. It’s not well documented so this is a useful bookmark if you have to do any validation ever.

You can read it here.

As I code more and more GUIs for home and work I find that I use a lot of entry widgets for manipulating data and getting user input. And every time I build an entry widget I think, wouldn’t it be nice to have a right-click edit menu so I can paste or whatnot from the mouse. With each new app I’d do it all over again, making this simple right click menu widget, at first really as a way to reinforce what I’ve learned in Python so I could make sure fundamental techniques stuck in my mind.

Well its stuck, I’m sure of it, and I’ve gotten tired of reinventing the wheel so I slapped together this quick class. The code below does an import on Tix. I use Tix because I prefer its native notebook widget to PMWs, but that’s another story. However, if you don’t like Tix just replace all instances of that word with Tkinter and it’ll work fine because Tix inherits everything from Tkinter to begin with. I haven’t tested it in text widgets yet.

The class itself is pretty trivial but perhaps some people will find it useful and maybe even novices will find something interesting in it. If anything this is my way of contributing back to the interwebs all the nuggets of knowledge it has graciously given me. If you find any bugs or have any suggestions to improve this please let me know!

Thanks!
PR.

Edit: Removed needless return statements.

import Tix

class RightClickMenu(object):
    """
    Simple widget to add basic right click menus to entry widgets.

    usage:

    rclickmenu = RightClickMenu(some_entry_widget)
    some_entry_widget.bind("<3>", rclickmenu)

    If you prefer to import Tkinter over Tix, just replace all Tix
    references with Tkinter and this will still work fine.
    """
    def __init__(self, parent):
        self.parent = parent
        # bind Control-A to select_all() to the widget.  All other
        # accelerators seem to work fine without binding such as
        # Ctrl-V, Ctrl-X, Ctrl-C etc.  Ctrl-A was the only one I had
        # issue with.
        self.parent.bind("<Control-a>", lambda e: self.select_all(), add='+')
        self.parent.bind("<Control-A>", lambda e: self.select_all(), add='+')
    def __call__(self, event):
        # if the entry widget is disabled do nothing.
        if self.parent.cget('state') == Tix.DISABLED:
            return
        # grab focus of the entry widget.  this way you can see
        # the cursor and any marking selections
        self.parent.focus_force()
        self.build_menu(event)
    def build_menu(self, event):
        menu = Tix.Menu(self.parent, tearoff=0)
        # check to see if there is any marked text in the entry widget.
        # if not then Cut and Copy are disabled.
        if not self.parent.selection_present():
            menu.add_command(label="Cut", state=Tix.DISABLED)
            menu.add_command(label="Copy", state=Tix.DISABLED)
        else:
            # use Tkinter's virtual events for brevity.  These could
            # be hardcoded with our own functions to immitate the same
            # actions but there's no point except as a novice exercise
            # (which I recommend if you're a novice).
            menu.add_command(
                label="Cut",
                command=lambda: self.parent.event_generate("<<Cut>>"))
            menu.add_command(
                label="Copy",
                command=lambda: self.parent.event_generate("<<Copy>>"))
        # if there's string data in the clipboard then make the normal
        # Paste command.  otherwise disable it.
        if self.paste_string_state():
            menu.add_command(
                label="Paste",
                command=lambda: self.parent.event_generate("<<Paste>>"))
        else:
            menu.add_command(label="Paste", state=Tix.DISABLED)
        # again, if there's no marked text then the Delete option is disabled.
        if not self.parent.selection_present():
            menu.add_command(label="Delete", state=Tix.DISABLED)
        else:
            menu.add_command(
                label="Delete",
                command=lambda: self.parent.event_generate("<<Clear>>"))
        # make things pretty with a horizontal separator
        menu.add_separator()
        # I don't know of if there's a virtual event for select all though
        # I did look in vain for documentation on -any- of Tkinter's
        # virtual events.  Regardless, the method itself is trivial.
        menu.add_command(label="Select All", command=self.select_all)
        menu.post(event.x_root, event.y_root)
    def select_all(self):
        self.parent.selection_range(0, Tix.END)
        self.parent.icursor(Tix.END)
        # return 'break' because, for some reason, Control-a (little 'a')
        # doesn't work otherwise.  There's some natural binding that
        # Tkinter entry widgets want to do that send the cursor to Home
        # and deselects.
        return 'break'
    def paste_string_state(self):
        """Returns true if a string is in the clipboard"""
        try:
            # this assignment will raise an exception if the data
            # in the clipboard isn't a string (such as a picture).
            # in which case we want to know about it so that the Paste
            # option can be appropriately set normal or disabled.
            clipboard = self.parent.selection_get(selection='CLIPBOARD')
        except Tix.TclError:
            return False
        return True

if __name__ == '__main__':
    root = Tix.Tk()
    root.geometry("156x65")
    Tix.Label(root, text="Right mouse click in\nthe entry widget below:").pack()
    entry_w = Tix.Entry(root)
    entry_w.pack()
    rclick = RightClickMenu(entry_w)
    entry_w.bind("<3>", rclick)
    root.mainloop()

Nesse post não vou ensinar como fazer interface gráfica no python, mas simplesmente como abrir dialogs para não dependermos da linha de comando.

Dialogs são aquelas janelinhas de informação ou erro que abrem como pop-ups.

Usaremos a interface gráfica padrão do python para isso, o Tkinter

A primeira coisa a se fazer é importar essa biblioteca, usamos o comando import:

import Tkinter

Agora vamos importar mais duas bibliotecas para fazer o dialog. A biblioteca tkMessageBox para mensagens e a tkSimpleDialog para os inputs:

import tkMessageBox
import tkSimpleDialog

O código a seguir serve para iniciar a interface gráfica, não vou me apofundar muito pois não é o objetivo. Se quiser saber mais sobre Tkinter existe um tutorial aqui.

root = Tkinter.Tk()

Esse próximo comando é opcional, quando inicializamos a interface gráfica é criada uma janela por padrão. Se quisermos esconder essa janela que não vamos utilizar basta essa linha:

root.withdraw()

Agora podemos começar a lógica do nosso programa, que está no post anterior.

nome = tkSimpleDialog.askstring('Nome', 'Qual o seu nome?')

Aqui substituímos o raw_input pelo tkSimpleDialog, observe que usamos tkSimpleDialog.askstring, o askstring indica o tipo que queremos receber, ask significa perguntar em inglês, então: perguntar string. As opções são: askstring, askfloat, askinteger e outras opções mais avançadas para arquivos, cores, etc.

Novamente passamos parâmetros entre parênteses, o primeiro é o título da janela e o segundo a pergunta.

askstring no Gnome(Linux)

Agora que já recebemos o nome, temos que dar que dar um oi:

tkMessageBox.showinfo("Nome", "Oi " + nome)

Mantendo a mesma ordem dos parâmetros(título, mensagem) usamos a opção showinfo do tkMessageBox. Novamente temos outras opçoes além de showinfo: showwarning, showerror e outras.

Os nomes dos comandos fazem sentido se você tiver um conhecimento básico de inglês, isso pode facilitar bastante o aprendizado.

Assim concluímos o nosso programa, mas devemos seguir mais alguns passos para que ele rode sem apresentar erros, utilizando as duas primeiras linhas do arquivo que servem para configurações especiais:

Para evitar erros é bom declara a codificação do nosso programa, por razões de compatibilidade com vários idiomas e sistemas operacionais recomendo usar utf-8(unicode), para saber mais sobre isso olhe na wikipédia.A declaração é feita através da seguinte linha adicionada na primeira ou segunda linha do arquivo:

# -*- encoding: utf-8 -*-

Usuários Linux ainda tem que adicionar mais uma linha para poder executar clicando diretamente no ícone(sem precisar do terminal), essa linha indica que deve ser aberto com o interpretador do python:

#!/usr/bin/env python

Agora nosso programa está completo, eis o código:

#!/usr/bin/env python
# -*- encoding: utf-8 -*-

import Tkinter
import tkMessageBox
import tkSimpleDialog

root = Tkinter.Tk()
root.withdraw()

nome = tkSimpleDialog.askstring('Nome','Qual o seu nome?')
tkMessageBox.showinfo("Nome", "Oi " + nome)

Salvem em um arquivo, no linux a extensão não é importante. Mas no windows devemos salvar como .pyw, antes estávamos salvando como .py.

A exensão .pyw impede que o python abra o shell(linha de comando), assim sua aplicação é inteiramente gráfica.

No linux você deve dar permissão de execução e quando der dois cliques vai ter as opções para executar com terminal, sem terminal e ver o código-fonte:

No windows os dois cliques vão executar o programa abrindo ou não o terminal de acordo com a extensão.

]]> http://sid93.wordpress.com/2008/09/15/pop3-mail-saver-04-new-0x/ Mon, 15 Sep 2008 17:50:26 +0000 SiD http://sid93.wordpress.com/2008/09/15/pop3-mail-saver-04-new-0x/

Ho rilasciato le nuove versioni di questo programma, con parziali ritocchi e medofiche al codice.

New Features

~ Codice sistemato.
~Log modificato con l’aggiunta dell’user.
~Modificati alcuni alert e nuova label con il numero mail in arrivo.
~Nuovi cursori per gli entry.

Puoi scaricarlo da qui:

http://cyber-sec.helloweb.eu/files/pop3-mail-saver-v04.zip

Vedi di più QUI

Article by GoblinRFD

More of a link than an article.  I have always wanted to do a video tutorial, and always had other things to do.  I stumbled recently across an email highlighting two tutorials for using TKinter (a set of functions for creating GUI’s with Python)

Dont be put off by the lackluster voice, these are very good and full credit to the creator for making them.  They take the user from the base level of TKinter and explains (very well) the basic principles.

These two videos were created by a guy called Shawn, and it would be nice, if you find them useful to send him a quick message to say thanks!

I will hopefully be adding more of these tutorials as they are highlighted to me.

Click here for the videos!

I just started to write a very very VERY simple phonebook for my own use. This is just a quick note, and I will keep you posted with snippets here and there. this link helped me get through understanding how I would go about doing it. Anyway, I’ll get started now, will post snippets whenever possible!

Tratto dal topic del forum deathcodez.com

#### Importa la libreria necessaria per la GUI ####
from Tkinter import *
#### Importa la libreria necessaria per la GUI ####

#### Inizializza la GUI ####
f.mainloop()
#### Inizializza la GUI ####

Come vedete l’ho commentata per una maggiore comprensione…
byez

Un semplice video che mostra come creare una semplicissima gui con le Tkinter.

Buona visione

Tadinya mau nulis judul tergigit atau keracunan bisa ular, tapi berhubung ular yang dimaksud tidak menggigit atau berbisa jadinya diganti deh. Ular yang dimaksud membunuh mangsanya dengan cara melilit dan menelan bulat-bulat. Anda tahu?

kalau Anda menjawab python, Anda boleh bersyukur masih memiliki ingatan tentang biologi umum.

Sebetulnya tulisan kali ini tidak membicarakan tentang biologi tapi masih tentang pemrogaman. Sudah beberapa hari ini saya sedang asik ngoprek memrogram dengan menggunakan bahasa python. Awalnya memang hanya karena pada beberapa tulisan terakhir yang menyinggung menggunakan opencv menggunakan python yang memudahkan dalam melakukan eksplorasi fitur citra yang dilanjutkan dengan mencoba menggunakan modul lainnya (GUI).

Memrogram antarmuka grafis (GUI) menggunakan python bisa langsung menggunakan pustaka bawaan yaitu Tkinter yang memanfaatkan Tcl/Tk. Pustaka ini lumayan mudah digunakan, namun dokumentasi yang saya temukan sangat sedikit (kurang pada aspek tertentu yang saya perlukan). Akhirnya saya melirik ke pustaka lain yaitu wxPython yang merupakan wrapper dari GUI Toolkit bernama wxWidget/wxWindows. Pada awalnya wxPython tampak lebih kompleks namun ternyata cara pakainya lebih terstruktur (lebih bersih) dibandingkan Tkinter. Satu hal lagi mengenai kelebihan wxPython adalah cara pakainya mirip dengan VCL pada delphi yang selama ini saya gunakan.

Kembali ke bahasa python, bahasa ini memang seperti deskripsinya dalam konteks biologi yaitu tidak berbisa dan membunuh mangsanya secara perlahan. Dibandingkan dengan bahasa lain yang sebangsa (Ruby) yang tampak lebih bersinar/berkilau (populer) di kalangan pengguna linux (mungkin karena python bersifat copyrighted walaupun sama-sama gratis dan open-source). Python cenderung hanya disukai oleh segelintir orang namun cukup dominan dalam cakupan yang spesifik (seperti Google dengan AppEngine-nya dan Blender). Alasan saya ketika memilih python adalah karena sintaksnya yang clean sehingga enak dibaca Khususnya menghilangkan redundansi begin-end yang ada di Pascal/Delphi yang mulai terasa gatal seperti yang terjadi pada LISP.