import os
import random
import re
import urllib
import urllib2

class flickrImages(object):
    
    RE_IMAGEURL = re.compile('src="(http://static.flickr.com/.+?_t.jpg)"', re.DOTALL | re.IGNORECASE)
    
    def __init__(self):
        
        self.imagesURLs = {}
    
    def getRandomImages(self):
        '''        
        Scarica dal sito FlickrImages delle immagini in maniera random...
        '''
        
        htmlPage = ''
        request = ''
                
        requestURL = 'http://flickr.com/photos?start=%d' % (random.randint(0, 5000))
        requestHeaders = {'User-Agent':'flickrImages/1.0'}
        
        try:
            request = urllib2.Request(requestURL, None, requestHeaders)
            htmlPage = urllib2.urlopen(request).read(500000)
        except:
            pass
        
        results = flickrImages.RE_IMAGEURL.findall(htmlPage)
        
        if len(results) > 0:
            for image in results:
                imageURL = urllib.unquote_plus(image)
                if not imageURL.startswith('http://'): imageURL = 'http://'+imageURL
                imageURL = imageURL.replace('_t.jpg', '_o.jpg') # Prende il formato piu' grande
                self.imagesURLs[imageURL] = 0
    
    def downloadImages(self):
        '''
        Scarica nella cartella googleIMGs le foto che vengono trovate in rete...
        '''
        
        numberIMGs = len(self.imagesURLs)
        posIMGs = 1
        
        for imageName in self.imagesURLs:
            print '[' + str(posIMGs) + '/' + str(numberIMGs) + '] - ' + imageName
            urllib.urlretrieve(imageName, 'flickrIMGs' + os.sep + os.path.split(imageName)[1])
            posIMGs += 1
    
if __name__ == '__main__':
    
    test = flickrImages()
    
    test.getRandomImages()
    test.downloadImages()
    
    print 'Finito...'

import gtk

def change_color_entry(entry, color):
    entry.modify_base(gk.STATE_NORMAL, gtk.gdk.color_parse(color))

import codecs

fp = codecs.open('E:\\demo.txt', 'w', 'utf_8')
fp.write('cioè')
fp.close()

class Demo: pass # Oggetto contenitore

def createAttributes():
    rc = Demo()
    
    setattr(rc, 'myobj', 'valore')

    return rc

import appuifw
import e32
import graphics
import thread
import time

class Main:
    
    def __init__(self):
                
        appuifw.app.title = u'Fibonacci'
        appuifw.app.body = self.canvas = appuifw.Canvas()
        appuifw.exit_key_handler = self.OnExit
        appuifw.app.menu = [(u'Calcola', self.OnCalcola)]
        
        self.nlock = thread.allocate_lock() # Allocazione di un lock per il thread
        self.vlock = thread.allocate_lock()
        
        self.ris1 = 0
        self.ris2 = ''
        self.loop = 1
        self.indice = 0
        self.img = graphics.Image.new(self.canvas.size)
        
        self.OnLoop()

    def OnCalcola(self):
        
        numero = appuifw.query(u'Inserire un Numero', 'number')
        
        thread.start_new_thread(self.fibonacci, (numero, ))
    
    def fibonacci(self, n):

        self.ris1 = time.strftime('%H:%M:%S')
        self.ris2 = ''
        
        a, b = 0, 1
        
        for i in range(n):
            
            a, b = b, a + b
            self.nlock.acquire()
            self.indice = ((i+1)*100)/n
            self.nlock.release()
        
        self.nlock.acquire()
        self.ris2 = time.strftime('%H:%M:%S')
        self.nlock.release()
        
    def OnExit(self):
        
        self.loop = 0
    
    def OnLoop(self):
        
        while self.loop:
            
            e32.ao_sleep(0.1)
            
            self.img.clear(0)
            
            self.img.line([37, 50, 137, 50], 0xffffff, width=20)
            self.img.line([37, 50, 37 + self.indice, 50], 0xfffc0d, width=20)
            self.img.text((80, 55), u'' + str(self.indice) + u'%', 0x000000)
            
            self.vlock.acquire()
            if self.ris2 <> '':
                
                self.img.text((45, 80), u'Start: ' + str(self.ris1), 0xffffff)
                self.img.text((45, 92), u'End:   ' + str(self.ris2), 0xffffff)
            
            
            self.canvas.blit(self.img)
            self.vlock.release()
        
if __name__ == '__main__':
    
    main = Main()

import re,sgmllib,sys,urllib

class Parser(sgmllib.SGMLParser):

    def start_a(self, attr):

        regx = re.compile('[Hh][Tt][Tt][Pp].*\....$')
        href = [v for a, v in attr if a == 'href']
        try:
            if regx.match(href[0]): print href[0]
        except:
            pass

if __name__ == '__main__':

    try:

        fd = urllib.urlopen(sys.argv[1])

        parser = Parser()
        parser.feed(fd.read())
        parser.close()

        fd.close()

    except Exception, error:

        print 'Errore: ' + str(error)

import wx, thread, time

def EVT_RESULT(win,func):
	win.Connect(-1,-1,111,func)

class RESULT(wx.PyEvent):

	def __init__(self, data):

		wx.PyEvent.__init__(self)
		
                self.SetEventType(111)
		self.data = data

class Main_Frame(wx.Frame):

	def __init__(self, parent=None, id=-1, title='Example PostEvent...'):

		self.ID_S = wx.NewId()
		self.ID_ST = wx.NewId()

		wx.Frame.__init__(self, parent, id, title)

		self.CenterOnScreen()
		self.Show()

		self._panel = wx.Panel(parent=self, id=-1)

		self._bu = wx.Button(parent=self._panel, id=self.ID_S, label='OK', size=(100, 100))
		self.Bind(wx.EVT_BUTTON, self.OnStart, id=self.ID_S)
		
		self._bo = wx.Button(parent=self._panel, id=self.ID_ST, label='KO',pos=(0, 200), size=(100, 100))

		self.Bind(wx.EVT_BUTTON, self.OnStop, id=self.ID_ST)

		EVT_RESULT(self, self.OnR)
		
		self.CreateStatusBar()

	def OnR(self, event):
		self.SetStatusText(str(event.data))

	def OnStart(self, evt):

		thread.start_new_thread(self.avvia, (self,))

	def OnStop(self, evt):

		print 'Cliccato....'

	def avvia(self, n):

		for i in range(10):
			time.sleep(1)
			wx.PostEvent(n, RESULT(i))

	
	
class Main_App(wx.App):

	def OnInit(self):

		self._main_frame = Main_Frame()
		
		self.SetTopWindow(self._main_frame)
		
		return True

if __name__ == '__main__':

	main_app = Main_App()
	main_app.MainLoop()

import os,re,sys

# python script.py file.html 

links = re.compile('[<].?[Aa].*[Hh][Rr][Ee][Ff].*=.*[\"\']?.*[\"\']?.?[>]')
lunghezza_file = os.stat(sys.argv[1])[6]
f = open(sys.argv[1], 'r')

while(lunghezza_file > 0):
 riga = f.readline()
 lunghezza_file -= len(riga)

 if links.search(riga):
  comparazione = links.search(riga)
  output = comparazione.group(0)
  links2 = re.compile('http:-*[Zz][Ii][Pp]')
  
  if links2.search(output):
   output2 = links2.search(output)
   print output2.group(0)

print 'FATTO'

import formencode

class EmailForm(formencode.Schema): 
    allow_extra_fields = True
    filter_extra_fields = True
    email = formencode.validators.Email(not_empty=True)

import sys, getpass, urllib

separator = "-----------------------------"
print(separator + 
       "\n   Georgia Tech Lawn Login\n" + 
       separator)

if len(sys.argv) >= 2:
    username = sys.argv[0]
    password = sys.argv[1]
    if len(sys.argv) >= 3:
        iss = sys.argv[2]
    else:
        iss = ""
else:
    username = raw_input("Username: ")
    password = getpass.getpass()
    iss = raw_input("Enable Inbound Security? ")

if iss.strip() in ("", "true", "True", "1", "y", "Y", "yes", "Yes"):
    iss = "true"
else:
    iss = "false"

try:
    print "\nAttempting to login..."
    data = urllib.urlopen('https://auth.lawn.gatech.edu/index.php',
                           'username=' + username +
                           '&password=' + password +
                           '&iss=' + iss +
                           '&output=text')
    print separator
    print data.read()
except IOError, e:
    print "IOError:", e