Python | Programming Blog

February 4, 2015 admin 0

Python network sockets programming tutorial

Standard

The first computer network that implemented the Internet protocol was created in 1969. It was mainly used for projects in universities and research laboratories in the US. The network was named ARPANET. This network was the preprocessor of the modern Internet and the basis of modern computer networks.

In this tutorial you will learn about in network programming. You will learn about the client-server model that is in use for the World Wide Web, E-mail and many other applications.

The client server model is a model where there are n clients and one server. The clients make data requests to a server. The server replies to those messages received. A client can be any device such as your computer or tablet. Servers are generally dedicated computers which are to be connected 24/7. Right in this moment your client is a web browser (Chrome, Firefox or another) and a server gives you the pages.

A simple socket server in Python
This code will start a simple web server using sockets. It waits for a connection and if a connection is received it will output the bytes received.

#!/usr/bin/env python
 
import socket
 
TCP_IP = '127.0.0.1'
TCP_PORT = 62
BUFFER_SIZE = 20  # Normally 1024, but we want fast response
 
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
s.bind((TCP_IP, TCP_PORT))
s.listen(1)
 
conn, addr = s.accept()
print 'Connection address:', addr
while 1:
     data = conn.recv(BUFFER_SIZE)
     if not data: break
     print "received data:", data
     conn.send(data)  # echo
conn.close()

#!/usr/bin/env python

import socket

TCP_IP = '127.0.0.1'

TCP_PORT = 62

BUFFER_SIZE = 20 # Normally 1024, but we want fast response

s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)

s.bind((TCP_IP, TCP_PORT))

s.listen(1)

conn, addr = s.accept()

print 'Connection address:', addr

while 1:

data = conn.recv(BUFFER_SIZE)

if not data: break

print "received data:", data

conn.send(data) # echo

conn.close()

Execute with:

$ python server.py

1	$ python server.py

This opens the web server at port 62. In a second screen, open a client with Telnet. If you use the same machine for the client and server use:

$ telnet 127.0.0.1 62.

1	$ telnet 127.0.0.1 62.

If you use another machine as client, type the according IP address of that machine. You can find it with ifconfig.

Everything you write from the client will arrive at the server. The server sends the received messages back. An example output below (Click to enlarge):

Servers connected to a network.

Creating a network client:
The client script below sends a message to the server. The server must be running!

#!/usr/bin/env python

import socket


TCP_IP = '127.0.0.1'
TCP_PORT = 5005
BUFFER_SIZE = 1024
MESSAGE = "Hello, World!"

s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
s.connect((TCP_IP, TCP_PORT))
s.send(MESSAGE)
data = s.recv(BUFFER_SIZE)
s.close()

print "received data:", data

#!/usr/bin/env python

import socket

TCP_IP = '127.0.0.1'

TCP_PORT = 5005

BUFFER_SIZE = 1024

MESSAGE = "Hello, World!"

s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)

s.connect((TCP_IP, TCP_PORT))

s.send(MESSAGE)

data = s.recv(BUFFER_SIZE)

s.close()

print "received data:", data

This client simply mimics the behavior we did in Telnet.

Limitations of the server code
The server code above can only interact with one client. If you try to connect with a second terminal it simply won’t reply to the new client. To let the server interact with multiple clients you need to use multi-threading. We rebuild the server script to accept multiple client connections:

#!/usr/bin/env python
 
import socket
from threading import Thread
from SocketServer import ThreadingMixIn

class ClientThread(Thread):

    def __init__(self,ip,port):
        Thread.__init__(self)
        self.ip = ip
        self.port = port
        print "[+] New thread started for "+ip+":"+str(port)


    def run(self):
        while True:
            data = conn.recv(2048)
            if not data: break
            print "received data:", data
            conn.send(data)  # echo
         
TCP_IP = '0.0.0.0'
TCP_PORT = 62
BUFFER_SIZE = 20  # Normally 1024, but we want fast response


tcpsock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
tcpsock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
tcpsock.bind((TCP_IP, TCP_PORT))
threads = []

while True:
    tcpsock.listen(4)
    print "Waiting for incoming connections..."
    (conn, (ip,port)) = tcpsock.accept()
    newthread = ClientThread(ip,port)
    newthread.start()
    threads.append(newthread)

for t in threads:
    t.join()

#!/usr/bin/env python

import socket

from threading import Thread

from SocketServer import ThreadingMixIn

class ClientThread(Thread):

def __init__(self,ip,port):

Thread.__init__(self)

self.ip = ip

self.port = port

print "[+] New thread started for "+ip+":"+str(port)

def run(self):

while True:

data = conn.recv(2048)

if not data: break

print "received data:", data

conn.send(data) # echo

TCP_IP = '0.0.0.0'

TCP_PORT = 62

BUFFER_SIZE = 20 # Normally 1024, but we want fast response

tcpsock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)

tcpsock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)

tcpsock.bind((TCP_IP, TCP_PORT))

threads = []

while True:

tcpsock.listen(4)

print "Waiting for incoming connections..."

(conn, (ip,port)) = tcpsock.accept()

newthread = ClientThread(ip,port)

newthread.start()

threads.append(newthread)

for t in threads:

t.join()

Defining the application protocol
So far we have simply sent messages back and forth. Every message can have a specific meaning in an application. This is known as the protocol. The meaning of these messages must be the same on both the sender and receiver side. The Transport Layer below makes sure that messages are received (TCP). The Internet Layer is the IPv4 protocol. All we have to define is the Application Layer.

Below we modified the server to accept simple commands (We use the non-threading server for simplicity). We changed the port to 64. Server code with a protocol:

#!/usr/bin/env python
 
import socket
 
TCP_IP = '127.0.0.1'
TCP_PORT = 64
BUFFER_SIZE = 20  # Normally 1024, but we want fast response
 
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
s.bind((TCP_IP, TCP_PORT))
s.listen(1)
 
conn, addr = s.accept()
print 'Connection address:', addr
while 1:
     data = conn.recv(BUFFER_SIZE)
     if not data: break
     print "received data:", data
     #conn.send(data)  # echo
     if "/version" in data:
         conn.send("Demo version\n")

     if "/echo" in data:
         data = data.replace("/echo","")
         conn.send(data + "\n")

conn.close()

#!/usr/bin/env python

import socket

TCP_IP = '127.0.0.1'

TCP_PORT = 64

BUFFER_SIZE = 20 # Normally 1024, but we want fast response

s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)

s.bind((TCP_IP, TCP_PORT))

s.listen(1)

conn, addr = s.accept()

print 'Connection address:', addr

while 1:

data = conn.recv(BUFFER_SIZE)

if not data: break

print "received data:", data

#conn.send(data) # echo

if "/version" in data:

conn.send("Demo version\n")

if "/echo" in data:

data = data.replace("/echo","")

conn.send(data + "\n")

conn.close()

Run the server with:

sudo python server.py

1	sudo python server.py

A client can then connect with telnet (make sure you pick the right IP):

$ telnet 127.0.0.1 64
Trying 127.0.0.1...
Connected to 127.0.0.1.
Escape character is '^]'.
message
/version
Demo version
/echo Repeat this
 Repeat this

$ telnet 127.0.0.1 64

Trying 127.0.0.1...

Connected to 127.0.0.1.

Escape character is '^]'.

message

/version

Demo version

/echo Repeat this

Repeat this

If you liked this tutorial please share it with the buttons below.

February 1, 2015 admin 0

Python Database Programming: SQLite (tutorial)

Standard

In this tutorial you will learn how to use the SQLite database management system with Python. You will learn how to use SQLite, SQL queries, RDBMS and more of this cool stuff!

Data is everywhere and software applications use that. Data is either in memory, files or databases. One of these database management systems (DBMS) is called SQLite. SQLite was created in the year 2000 for a missile control system (boom! did we say it was cool?) and is one of the many management systems in the database zoo. MySQL, Postregsql, Oracle, Microsoft SQL Server and Maria DB are other database animals in this zoo. So what is this SQL?

SQL is a special-purpose programming language designed for managing data held in a databases. The language has been around since 1986 and is worth learning. The video below is an old funny video about SQL.

Why use SQLite? SQLite is the most widely deployed SQL database engine in the world. The source code for SQLite is in the public domain. It is a self-contained, serverless, zero-configuration, transactional SQL database engine. The SQLite project is sponsored by Bloomberg and Mozilla.

Installation:

$ sudo apt-get install sqlite

1	$ sudo apt-get install sqlite

Verify if it is correctly installed. Copy this program and save it as test1.py

#!/usr/bin/python
# -*- coding: utf-8 -*-

import sqlite3 as lite
import sys

con = None

try:
    con = lite.connect('test.db')
    cur = con.cursor()    
    cur.execute('SELECT SQLITE_VERSION()')
    data = cur.fetchone()
    print "SQLite version: %s" % data                
except lite.Error, e:   
    print "Error %s:" % e.args[0]
    sys.exit(1)
finally:    
    if con:
        con.close()

#!/usr/bin/python

# -*- coding: utf-8 -*-

import sqlite3 as lite

import sys

con = None

try:

con = lite.connect('test.db')

cur = con.cursor()

cur.execute('SELECT SQLITE_VERSION()')

data = cur.fetchone()

print "SQLite version: %s" % data

except lite.Error, e:

print "Error %s:" % e.args[0]

sys.exit(1)

finally:

if con:

con.close()

Execute with:

$ python test1.py

1	$ python test1.py

It should output:

SQLite version: 3.8.2

1	SQLite version: 3.8.2

What did the script above do?
The script connected to a new database called test.db with this line:

con = lite.connect('test.db')

1	con = lite.connect('test.db')

It then queries the database management system with the command

SELECT SQLITE_VERSION()

1	SELECT SQLITE_VERSION()

which in turn returned its version number. That line is known as an SQL query.

SQL joke. Source: Reddit

Storing data
The script below will store data into a new database called user.db

#!/usr/bin/python
# -*- coding: utf-8 -*-

import sqlite3 as lite
import sys

con = lite.connect('user.db')

with con:
    
    cur = con.cursor()    
    cur.execute("CREATE TABLE Users(Id INT, Name TEXT)")
    cur.execute("INSERT INTO Users VALUES(1,'Michelle')")
    cur.execute("INSERT INTO Users VALUES(2,'Sonya')")
    cur.execute("INSERT INTO Users VALUES(3,'Greg')")

#!/usr/bin/python

# -*- coding: utf-8 -*-

import sqlite3 as lite

import sys

con = lite.connect('user.db')

with con:

cur = con.cursor()

cur.execute("CREATE TABLE Users(Id INT, Name TEXT)")

cur.execute("INSERT INTO Users VALUES(1,'Michelle')")

cur.execute("INSERT INTO Users VALUES(2,'Sonya')")

cur.execute("INSERT INTO Users VALUES(3,'Greg')")

SQLite is a database management system that uses tables. These tables can have relations with other tables: it’s called relational database management system or RDBMS. The table defines the structure of the data and can hold the data. A database can hold many different tables. The table gets created using the command:

cur.execute("CREATE TABLE Users(Id INT, Name TEXT)")

1	cur.execute("CREATE TABLE Users(Id INT, Name TEXT)")

We add records into the table with these commands:

cur.execute("INSERT INTO Users VALUES(2,'Sonya')")
    cur.execute("INSERT INTO Users VALUES(3,'Greg')")

1 2	cur.execute("INSERT INTO Users VALUES(2,'Sonya')") cur.execute("INSERT INTO Users VALUES(3,'Greg')")

The first value is the ID. The second value is the name. Once we run the script the data gets inserted into the database table Users:

Exploring the data
We can explore the database using two methods: the command line and a graphical interface.

From console: To explore using the command line type these commands:

sqlite3 user.db
.tables
SELECT * FROM Users;

sqlite3 user.db

.tables

SELECT * FROM Users;

This will output the data in the table Users.

sqlite> SELECT * FROM Users;
1|Michelle
2|Sonya
3|Greg

sqlite> SELECT * FROM Users;

1|Michelle

2|Sonya

3|Greg

From GUI: If you want to use a GUI instead, there is a lot of choice. Personally I picked sqllite-man but there are many others. We install using:

sudo apt-get install sqliteman

1	sudo apt-get install sqliteman

We start the application sqliteman. A gui pops up.

Press File > Open > user.db. It appears like not much has changed, do not worry, this is just the user interface. On the left is a small tree view, press Tables > users. The full table including all records will be showing now.

This GUI can be used to modify the records (data) in the table and to add new tables.

The SQL language
SQL has many commands to interact with the database. You can try the commands below from the command line or from the GUI:

sqlite3 user.db 
SELECT * FROM Users;
SELECT count(*) FROM Users;
SELECT name FROM Users;
SELECT * FROM Users WHERE id = 2;
DELETE FROM Users WHERE id = 6;

sqlite3 user.db

SELECT * FROM Users;

SELECT count(*) FROM Users;

SELECT name FROM Users;

SELECT * FROM Users WHERE id = 2;

DELETE FROM Users WHERE id = 6;

We can use those queries in a Python program:

#!/usr/bin/python
# -*- coding: utf-8 -*-

import sqlite3 as lite
import sys


con = lite.connect('user.db')

with con:    
    
    cur = con.cursor()    
    cur.execute("SELECT * FROM Users")

    rows = cur.fetchall()

    for row in rows:
        print row

#!/usr/bin/python

# -*- coding: utf-8 -*-

import sqlite3 as lite

import sys

con = lite.connect('user.db')

with con:

cur = con.cursor()

cur.execute("SELECT * FROM Users")

rows = cur.fetchall()

for row in rows:

print row

This will output all data in the Users table from the database:

$ python get.py 
(1, u'Michelle')
(2, u'Sonya')
(3, u'Greg')

$ python get.py

(1, u'Michelle')

(2, u'Sonya')

(3, u'Greg')

SQL joke. Source: flickr

Creating a user information database
We can structure our data across multiple tables. This keeps our data structured, fast and organized. If we would have a single table to store everything, we would quickly have a big chaotic mess. What we will do is create multiple tables and use them in a combination. We create two tables:

Users:

Jobs:

To create these tables, you can do that by hand in the GUI or use the script below:

# -*- coding: utf-8 -*-
 
import sqlite3 as lite
import sys
 
con = lite.connect('system.db')
 
with con:
    
    cur = con.cursor()    
    cur.execute("CREATE TABLE Users(Id INT, Name TEXT)")
    cur.execute("INSERT INTO Users VALUES(1,'Michelle')")
    cur.execute("INSERT INTO Users VALUES(2,'Howard')")
    cur.execute("INSERT INTO Users VALUES(3,'Greg')")

    cur.execute("CREATE TABLE Jobs(Id INT, Uid INT, Profession TEXT)")
    cur.execute("INSERT INTO Jobs VALUES(1,1,'Scientist')")
    cur.execute("INSERT INTO Jobs VALUES(2,2,'Marketeer')")
    cur.execute("INSERT INTO Jobs VALUES(3,3,'Developer')")

# -*- coding: utf-8 -*-

import sqlite3 as lite

import sys

con = lite.connect('system.db')

with con:

cur = con.cursor()

cur.execute("CREATE TABLE Users(Id INT, Name TEXT)")

cur.execute("INSERT INTO Users VALUES(1,'Michelle')")

cur.execute("INSERT INTO Users VALUES(2,'Howard')")

cur.execute("INSERT INTO Users VALUES(3,'Greg')")

cur.execute("CREATE TABLE Jobs(Id INT, Uid INT, Profession TEXT)")

cur.execute("INSERT INTO Jobs VALUES(1,1,'Scientist')")

cur.execute("INSERT INTO Jobs VALUES(2,2,'Marketeer')")

cur.execute("INSERT INTO Jobs VALUES(3,3,'Developer')")

The jobs table has an extra parameter, Uid. We use that to connect the two tables in an SQL query:

SELECT users.name, jobs.profession FROM jobs INNER JOIN users ON users.ID = jobs.uid

1	SELECT users.name, jobs.profession FROM jobs INNER JOIN users ON users.ID = jobs.uid

You can incorporate that SQL query in a Python script:

#!/usr/bin/python
# -*- coding: utf-8 -*-

import sqlite3 as lite
import sys


con = lite.connect('system.db')

with con:    
    
    cur = con.cursor()    
    cur.execute("SELECT users.name, jobs.profession FROM jobs INNER JOIN users ON users.ID = jobs.uid")

    rows = cur.fetchall()

    for row in rows:
        print row

#!/usr/bin/python

# -*- coding: utf-8 -*-

import sqlite3 as lite

import sys

con = lite.connect('system.db')

with con:

cur = con.cursor()

cur.execute("SELECT users.name, jobs.profession FROM jobs INNER JOIN users ON users.ID = jobs.uid")

rows = cur.fetchall()

for row in rows:

print row

It should output:

$ python get2.py
(u'Michelle', u'Scientist')
(u'Howard', u'Marketeer')
(u'Greg', u'Developer')

$ python get2.py

(u'Michelle', u'Scientist')

(u'Howard', u'Marketeer')

(u'Greg', u'Developer')

If you liked this tutorial please share it using one of the buttons below

January 30, 2015 admin 0

Creating a webbrowser with Python and PyQT (tutorial)

Standard

In this tutorial we will build a webbrowser with Python. We will use PyQT. Install the required packages:

sudo pip install python-qt4
sudo apt-get install qt4-designer
sudo apt-get install pyqt4-dev-tools
sudo apt-get install python-kde4

sudo pip install python-qt4

sudo apt-get install qt4-designer

sudo apt-get install pyqt4-dev-tools

sudo apt-get install python-kde4

If you have not done our first tutorial, you could try it. If python-kde4 cannot be found update your repository to find it. If you are on Ubuntu or Debian Linux use this link.

Creating the UI with PyQT
Start qt4-designer from your applications menu. The QT Designer application will appear:

QT_Designer

Select Main Window and press Create. We now have our designer window open. Drag a KWebView component on the window. If you have a QtWebView in the component list. use that instead. We also add an Line Edit on top. Press File > Save As > browser.ui. Run the command:

pyuic4 browser.ui > browser.py

1	pyuic4 browser.ui > browser.py

This will generate a Python file. Remove the line “from kwebview import KWebView” from the bottom of the browser.py file. Change KWebView to QtWebView. We want to use QtWebView instead. If you are lazy to change that, take the browser.py file from below.

Creating the logic.
Create a file called run.py with this contents:

import sys
from browser import BrowserDialog
from PyQt4 import QtCore, QtGui
from PyQt4.QtCore import QUrl
from PyQt4.QtWebKit import QWebView

class MyBrowser(QtGui.QDialog):
    def __init__(self, parent=None):
        QtGui.QWidget.__init__(self, parent)
        QWebView.__init__(self)
        self.ui = BrowserDialog()
        self.ui.setupUi(self)
        self.ui.lineEdit.returnPressed.connect(self.loadURL)
 
    def loadURL(self):
        url = self.ui.lineEdit.text()
        self.ui.qwebview.load(QUrl(url))
        self.show()  
        #self.ui.lineEdit.setText("")

if __name__ == "__main__":
    app = QtGui.QApplication(sys.argv)
    myapp = MyBrowser()
    myapp.ui.qwebview.load(QUrl('https://talkera.org/python'))
    myapp.show()
    sys.exit(app.exec_())

import sys

from browser import BrowserDialog

from PyQt4 import QtCore, QtGui

from PyQt4.QtCore import QUrl

from PyQt4.QtWebKit import QWebView

class MyBrowser(QtGui.QDialog):

def __init__(self, parent=None):

QtGui.QWidget.__init__(self, parent)

QWebView.__init__(self)

self.ui = BrowserDialog()

self.ui.setupUi(self)

self.ui.lineEdit.returnPressed.connect(self.loadURL)

def loadURL(self):

url = self.ui.lineEdit.text()

self.ui.qwebview.load(QUrl(url))

self.show()

#self.ui.lineEdit.setText("")

if __name__ == "__main__":

app = QtGui.QApplication(sys.argv)

myapp = MyBrowser()

myapp.ui.qwebview.load(QUrl('https://talkera.org/python'))

myapp.show()

sys.exit(app.exec_())

This code will use the UI as defined in browser.py and add logic to it. The lines

self.ui.lineEdit.returnPressed.connect(self.loadURL)
 
    def loadURL(self):
        url = self.ui.lineEdit.text()
        self.ui.qwebview.load(QUrl(url))
        self.show()  
        #self.ui.lineEdit.setText("")

self.ui.lineEdit.returnPressed.connect(self.loadURL)

def loadURL(self):

url = self.ui.lineEdit.text()

self.ui.qwebview.load(QUrl(url))

self.show()

#self.ui.lineEdit.setText("")

The first line defines the callback or event. If a person presses enter (returnPressed), it will call the function loadURL. It makes sure that once you press enter, the page is loaded with that function. If you did everything correctly, you should be able to run the browser with the command:

python run.py

1	python run.py

Please make sure you type the full url, e.g. : https://talkera.org including the http:// part. Your browser should now start:

If your code does not run, please use the codes below (or look at the differences and change whats wrong):

browser.py

# -*- coding: utf-8 -*-

# Form implementation generated from reading ui file 'browser.ui'
#
# Created: Fri Jan 30 20:49:32 2015
#      by: PyQt4 UI code generator 4.10.4
#
# WARNING! All changes made in this file will be lost!

import sys
from PyQt4 import QtCore, QtGui
from PyQt4.QtGui import QApplication
from PyQt4.QtCore import QUrl
from PyQt4.QtWebKit import QWebView

try:
    _fromUtf8 = QtCore.QString.fromUtf8
except AttributeError:
    def _fromUtf8(s):
        return s

try:
    _encoding = QtGui.QApplication.UnicodeUTF8
    def _translate(context, text, disambig):
        return QtGui.QApplication.translate(context, text, disambig, _encoding)
except AttributeError:
    def _translate(context, text, disambig):
        return QtGui.QApplication.translate(context, text, disambig)

class BrowserDialog(object):
    def setupUi(self, Dialog):
        Dialog.setObjectName(_fromUtf8("Dialog"))
        Dialog.resize(1024, 768)
        self.qwebview = QWebView(Dialog)
        self.qwebview.setGeometry(QtCore.QRect(0, 50, 1020, 711))
        self.qwebview.setObjectName(_fromUtf8("kwebview"))
        self.lineEdit = QtGui.QLineEdit(Dialog)
        self.lineEdit.setGeometry(QtCore.QRect(10, 20, 1000, 25))
        self.lineEdit.setObjectName(_fromUtf8("lineEdit"))

        self.retranslateUi(Dialog)
        QtCore.QMetaObject.connectSlotsByName(Dialog)

    def retranslateUi(self, Dialog):
        Dialog.setWindowTitle(_translate("Browser", "Browser", None))

# -*- coding: utf-8 -*-

# Form implementation generated from reading ui file 'browser.ui'

# Created: Fri Jan 30 20:49:32 2015

# by: PyQt4 UI code generator 4.10.4

# WARNING! All changes made in this file will be lost!

import sys

from PyQt4 import QtCore, QtGui

from PyQt4.QtGui import QApplication

from PyQt4.QtCore import QUrl

from PyQt4.QtWebKit import QWebView

try:

_fromUtf8 = QtCore.QString.fromUtf8

except AttributeError:

def _fromUtf8(s):

return s

try:

_encoding = QtGui.QApplication.UnicodeUTF8

def _translate(context, text, disambig):

return QtGui.QApplication.translate(context, text, disambig, _encoding)

except AttributeError:

def _translate(context, text, disambig):

return QtGui.QApplication.translate(context, text, disambig)

class BrowserDialog(object):

def setupUi(self, Dialog):

Dialog.setObjectName(_fromUtf8("Dialog"))

Dialog.resize(1024, 768)

self.qwebview = QWebView(Dialog)

self.qwebview.setGeometry(QtCore.QRect(0, 50, 1020, 711))

self.qwebview.setObjectName(_fromUtf8("kwebview"))

self.lineEdit = QtGui.QLineEdit(Dialog)

self.lineEdit.setGeometry(QtCore.QRect(10, 20, 1000, 25))

self.lineEdit.setObjectName(_fromUtf8("lineEdit"))

self.retranslateUi(Dialog)

QtCore.QMetaObject.connectSlotsByName(Dialog)

def retranslateUi(self, Dialog):

Dialog.setWindowTitle(_translate("Browser", "Browser", None))

run.py

import sys
from browser import BrowserDialog
from PyQt4 import QtCore, QtGui
from PyQt4.QtCore import QUrl
from PyQt4.QtWebKit import QWebView

class MyBrowser(QtGui.QDialog):
    def __init__(self, parent=None):
        QtGui.QWidget.__init__(self, parent)
        QWebView.__init__(self)
        self.ui = BrowserDialog()
        self.ui.setupUi(self)
        self.ui.lineEdit.returnPressed.connect(self.loadURL)
 
    def loadURL(self):
        url = self.ui.lineEdit.text()
        self.ui.qwebview.load(QUrl(url))
        self.show()  
        #self.ui.lineEdit.setText("")

if __name__ == "__main__":
    app = QtGui.QApplication(sys.argv)
    myapp = MyBrowser()
    myapp.ui.qwebview.load(QUrl('https://talkera.org/python'))
    myapp.show()
    sys.exit(app.exec_())

import sys

from browser import BrowserDialog

from PyQt4 import QtCore, QtGui

from PyQt4.QtCore import QUrl

from PyQt4.QtWebKit import QWebView

class MyBrowser(QtGui.QDialog):

def __init__(self, parent=None):

QtGui.QWidget.__init__(self, parent)

QWebView.__init__(self)

self.ui = BrowserDialog()

self.ui.setupUi(self)

self.ui.lineEdit.returnPressed.connect(self.loadURL)

def loadURL(self):

url = self.ui.lineEdit.text()

self.ui.qwebview.load(QUrl(url))

self.show()

#self.ui.lineEdit.setText("")

if __name__ == "__main__":

app = QtGui.QApplication(sys.argv)

myapp = MyBrowser()

myapp.ui.qwebview.load(QUrl('https://talkera.org/python'))

myapp.show()

sys.exit(app.exec_())

January 28, 2015 admin 0

Speech engines with Python (tutorial)

Standard

A computer system used to create artificial speech is called a speech synthesizer, and can be implemented in software or hardware products. A text-to-speech (TTS) system converts normal language text into speech. How can we use speech synthesis in Python?

Pyttsx
Pyttsx is a cross-platform speech (Mac OSX, Windows, and Linux) library. You can set voice metadata such as age, gender, id, language and name. Thee speech engine comes with a large amount of voices. Sadly, the default voice sounds very robotic.

sudo pip install pyttsx

1	sudo pip install pyttsx

Create the code speech1.py

import pyttsx
engine = pyttsx.init()
engine.say('The quick brown fox jumped over the lazy dog.')
engine.runAndWait()

import pyttsx

engine = pyttsx.init()

engine.say('The quick brown fox jumped over the lazy dog.')

engine.runAndWait()

And execute it with python.

Espeak
eSpeak is a compact open source software speech synthesizer for English and other languages, for Linux and Windows. We can install using:

sudo apt-get install espeak

1	sudo apt-get install espeak

Create the code speech2.py:

import os
os.system("espeak 'The quick brown fox'")

1 2	import os os.system("espeak 'The quick brown fox'")

It is very easy to use, but like pyttsx it sounds very robotic.

GoogleTTS
I found a script on Github that uses the Google speech engine. The script comes with many options and does not speak, instead it saves to an mp3. We added a command to play the mp3 automatically:

os.system("mpg321 out.mp3 -quiet")

1	os.system("mpg321 out.mp3 -quiet")

Run with:

python gtts.py -s 'Python programming example'

1	python gtts.py -s 'Python programming example'

The voice is extremely natural. The only disadvantage is that you need to be connected with the Internet when running this script.

Conclusion
GoogleTTS is the most natural speech synthesis engine that we found. While other TTS engines are simple to use they simply do not match the sound quality. Sadly the number of available voices is limited.

January 27, 2015 admin 1

QML and PyQT: Creating a GUI (tutorial)

Standard

If you have not done our first PyQT tutorial yet, you should do it, it’s fun! In this tutorial we will use an user interface markup language, a language that describes the graphical user interfaces and controls . An excerpt of user interface markup language code could look like:

Rectangle {
     id: simplebutton
     color: "grey"
     width: 150; height: 75

Rectangle {

id: simplebutton

color: "grey"

width: 150; height: 75

Essentially the language tells what the interface should look like. The language we will be using is called QML. Do not worry about it for now.

Start a programmed called QTCreator. The tutorial will be quite graphical to help you through the whole process. Simply type qtcreator in the terminal or start it from the menu list. This screen should pop up:

Press the big New Project button. Select QT Quick Application from the menu below. Finally press Choose on the bottom right.

A new popup will appear:

Type a name and a valid path to save your project. Then press Next. Select QT Quick 2.0 from the menu list. Press Next. Press Finish. Immediately a user interface defined in the QML language will appear.

Like all great programmers we are going to solve things the most lazy way possible. Instead of typing all the QML code by hand we are going to press the Design button that is on the left of the screen. A drag and drop screen should appear now.

We drag an image onto the area and select the source on the right. Save the project. Open a terminal and locate the qml file you just created. Alternatively you could simply copy the code in the edit box and save it to a .qml file. Enter the command:

qmlviewer main.qml

1	qmlviewer main.qml

This will display the windows as defined in the qml file without any functionality. It is simply a viewer for the interface. We then create some code to load this QML definition:

import sys

from PyQt4.QtCore import QDateTime, QObject, QUrl, pyqtSignal
from PyQt4.QtGui import QApplication
from PyQt4.QtDeclarative import QDeclarativeView

app = QApplication(sys.argv)

# Create the QML user interface.
view = QDeclarativeView()
view.setSource(QUrl('main.qml'))
view.setResizeMode(QDeclarativeView.SizeRootObjectToView)
view.setGeometry(100, 100, 400, 240)
view.show()

app.exec_()

import sys

from PyQt4.QtCore import QDateTime, QObject, QUrl, pyqtSignal

from PyQt4.QtGui import QApplication

from PyQt4.QtDeclarative import QDeclarativeView

app = QApplication(sys.argv)

# Create the QML user interface.

view = QDeclarativeView()

view.setSource(QUrl('main.qml'))

view.setResizeMode(QDeclarativeView.SizeRootObjectToView)

view.setGeometry(100, 100, 400, 240)

view.show()

app.exec_()

Finally we modify the first line main.qml to:

import Qt 4.7

1	import Qt 4.7

Simply because our QtQuick was missing. Running

python run.py

1	python run.py

Will now display our user interface as defined by QML:

All of the code is simply PyQT, so you could add code like in the previous tutorial. These are the two methods to create a graphical interface with PyQT. This method may be more loosely coupled to the code compared to the method of creating a GUI with QT in the previous tutorial. Despite that both are valid methods.

January 26, 2015 admin 3

Building an application GUI with PyQT, beginners tutorial

Standard

In this tutorial we will teach you how to create a graphical application with PyQT. You will need to install some packages:

sudo pip install pyqt
sudo apt-get install qt4-designer
sudo apt-get install pyqt4-dev-tools
sudo apt-get install python-kde4

sudo pip install pyqt

sudo apt-get install qt4-designer

sudo apt-get install pyqt4-dev-tools

sudo apt-get install python-kde4

If python-kde4 cannot be found update your repository to find it. If you are on Ubuntu use this link.

Now we can use the QT Designer application. It saves us from writing tons of layout code that you may be used to when writing HTML. Start qt4-designer from your applications menu. The QT Designer application will appear:

QT_Designer

Press Dialog without Buttons and press Create. You can now drag any component from the widget box to the form. Simple drag and drop. We added a button, label and a pixmap. (I took a random image from the web for the pixmap)

Our window looks like the image above. Press Form > Viewcode. We will get a popup box with the form code in… C++! That is great, but we want the Python code. Press File > Save as > form.ui.

The file test.ui contains your form described in XML format. (You can view it in a text editor) Open a console and type:

pyuic4 form.ui > form.py

1	pyuic4 form.ui > form.py

Running the file does nothing. Create a new file called gui.py

Paste the code below:

import sys
from PyQt4 import QtCore, QtGui
from form import Ui_Dialog


class MyDialog(QtGui.QDialog):
    def __init__(self, parent=None):
        QtGui.QWidget.__init__(self, parent)
        self.ui = Ui_Dialog()
        self.ui.setupUi(self)

if __name__ == "__main__":
    app = QtGui.QApplication(sys.argv)
    myapp = MyDialog()
    myapp.show()
    sys.exit(app.exec_())

import sys

from PyQt4 import QtCore, QtGui

from form import Ui_Dialog

class MyDialog(QtGui.QDialog):

def __init__(self, parent=None):

QtGui.QWidget.__init__(self, parent)

self.ui = Ui_Dialog()

self.ui.setupUi(self)

if __name__ == "__main__":

app = QtGui.QApplication(sys.argv)

myapp = MyDialog()

myapp.show()

sys.exit(app.exec_())

Run with:

python gui.py

1	python gui.py

This will open our graphical interface. Pressing on the OK button will simply close the application.

We want to add some action when the OK button is pressed. We add these three lines to the code:

self.ui.pushButton.clicked.connect(self.OK)

    def OK(self):
        print 'OK pressed.'

self.ui.pushButton.clicked.connect(self.OK)

def OK(self):

print 'OK pressed.'

Please make sure your button is named pushButton by inspecting the form.py file. Pressing the button will print ‘OK pressed’ to the terminal.

Total application below:

gui.py

import sys
from PyQt4 import QtCore, QtGui
from form import Ui_Dialog


class MyDialog(QtGui.QDialog):
    def __init__(self, parent=None):
        QtGui.QWidget.__init__(self, parent)
        self.ui = Ui_Dialog()
        self.ui.setupUi(self)
        self.ui.pushButton.clicked.connect(self.OK)

    def OK(self):
        print 'OK pressed.'


if __name__ == "__main__":
    app = QtGui.QApplication(sys.argv)
    myapp = MyDialog()
    myapp.show()
    sys.exit(app.exec_())

import sys

from PyQt4 import QtCore, QtGui

from form import Ui_Dialog

class MyDialog(QtGui.QDialog):

def __init__(self, parent=None):

QtGui.QWidget.__init__(self, parent)

self.ui = Ui_Dialog()

self.ui.setupUi(self)

self.ui.pushButton.clicked.connect(self.OK)

def OK(self):

print 'OK pressed.'

if __name__ == "__main__":

app = QtGui.QApplication(sys.argv)

myapp = MyDialog()

myapp.show()

sys.exit(app.exec_())

form.py (generated):

# -*- coding: utf-8 -*-

# Form implementation generated from reading ui file 'form.ui'
#
# Created: Mon Jan 26 01:18:19 2015
#      by: PyQt4 UI code generator 4.10.4
#
# WARNING! All changes made in this file will be lost!

from PyQt4 import QtCore, QtGui

try:
    _fromUtf8 = QtCore.QString.fromUtf8
except AttributeError:
    def _fromUtf8(s):
        return s

try:
    _encoding = QtGui.QApplication.UnicodeUTF8
    def _translate(context, text, disambig):
        return QtGui.QApplication.translate(context, text, disambig, _encoding)
except AttributeError:
    def _translate(context, text, disambig):
        return QtGui.QApplication.translate(context, text, disambig)

class Ui_Dialog(object):
    def setupUi(self, Dialog):
        Dialog.setObjectName(_fromUtf8("Dialog"))
        Dialog.resize(325, 208)
        self.label = QtGui.QLabel(Dialog)
        self.label.setGeometry(QtCore.QRect(30, 100, 341, 61))
        self.label.setObjectName(_fromUtf8("label"))
        self.pushButton = QtGui.QPushButton(Dialog)
        self.pushButton.setGeometry(QtCore.QRect(10, 150, 301, 41))
        self.pushButton.setObjectName(_fromUtf8("pushButton"))
        self.kpixmapregionselectorwidget = KPixmapRegionSelectorWidget(Dialog)
        self.kpixmapregionselectorwidget.setGeometry(QtCore.QRect(-30, -20, 371, 161))
        self.kpixmapregionselectorwidget.setPixmap(QtGui.QPixmap(_fromUtf8("Desktop/IMG_0377.jpg")))
        self.kpixmapregionselectorwidget.setObjectName(_fromUtf8("kpixmapregionselectorwidget"))

        self.retranslateUi(Dialog)
        QtCore.QMetaObject.connectSlotsByName(Dialog)

    def retranslateUi(self, Dialog):
        Dialog.setWindowTitle(_translate("Dialog", "Dialog", None))
        self.label.setText(_translate("Dialog", "This form is created with Python and QT.", None))
        self.pushButton.setText(_translate("Dialog", "OK", None))

from PyKDE4.kdeui import KPixmapRegionSelectorWidget

# -*- coding: utf-8 -*-

# Form implementation generated from reading ui file 'form.ui'

# Created: Mon Jan 26 01:18:19 2015

# by: PyQt4 UI code generator 4.10.4

# WARNING! All changes made in this file will be lost!

from PyQt4 import QtCore, QtGui

try:

_fromUtf8 = QtCore.QString.fromUtf8

except AttributeError:

def _fromUtf8(s):

return s

try:

_encoding = QtGui.QApplication.UnicodeUTF8

def _translate(context, text, disambig):

return QtGui.QApplication.translate(context, text, disambig, _encoding)

except AttributeError:

def _translate(context, text, disambig):

return QtGui.QApplication.translate(context, text, disambig)

class Ui_Dialog(object):

def setupUi(self, Dialog):

Dialog.setObjectName(_fromUtf8("Dialog"))

Dialog.resize(325, 208)

self.label = QtGui.QLabel(Dialog)

self.label.setGeometry(QtCore.QRect(30, 100, 341, 61))

self.label.setObjectName(_fromUtf8("label"))

self.pushButton = QtGui.QPushButton(Dialog)

self.pushButton.setGeometry(QtCore.QRect(10, 150, 301, 41))

self.pushButton.setObjectName(_fromUtf8("pushButton"))

self.kpixmapregionselectorwidget = KPixmapRegionSelectorWidget(Dialog)

self.kpixmapregionselectorwidget.setGeometry(QtCore.QRect(-30, -20, 371, 161))

self.kpixmapregionselectorwidget.setPixmap(QtGui.QPixmap(_fromUtf8("Desktop/IMG_0377.jpg")))

self.kpixmapregionselectorwidget.setObjectName(_fromUtf8("kpixmapregionselectorwidget"))

self.retranslateUi(Dialog)

QtCore.QMetaObject.connectSlotsByName(Dialog)

def retranslateUi(self, Dialog):

Dialog.setWindowTitle(_translate("Dialog", "Dialog", None))

self.label.setText(_translate("Dialog", "This form is created with Python and QT.", None))

self.pushButton.setText(_translate("Dialog", "OK", None))

from PyKDE4.kdeui import KPixmapRegionSelectorWidget

January 23, 2015 admin 0

Creating a gui in Python with WxWidgets [tutorial for beginners]

Standard

Python programming is a lot of fun and sometimes we want to create a graphical application (GUI). WxWidgets can be used to create a graphical interface that looks like a native application on any operating system. First download and install WxPython, the Python bindings for wxWidgets.

sudo apt-get install python-wxgtk2.8 python-wxtools wx2.8-doc wx2.8-examples wx2.8-headers wx2.8-i18n

1	sudo apt-get install python-wxgtk2.8 python-wxtools wx2.8-doc wx2.8-examples wx2.8-headers wx2.8-i18n

Then install a GUI creator called wxglade:

sudo apt-get install wxglade

1	sudo apt-get install wxglade

Using a GUI builder such as wxGlade will save you a lot of time, regardless of the GUI library you use. You can easily make complex graphical interfaces because you can simply drag and drop.

Creating our first GUI with Python and wxWidgets:

Start wxglade. You will see its user interface:

Press on tiny window on the top left, below the file icon.

Press OK. An empty window will now appear. Press on the tiny [OK] button in the wxGlade panel and press on the frame. The button will now appear. Press on Application in the tree window.

Set the output file in the wxproperties window.

If you look at the window note you can select multiple programming languages and two versions of wxWidgets. Select Python and wxWidgets 2.8. Finally press Generate code. (Do NOT name the file wx.py because the import needs wx, save it as window.py or something else).

Putting it all together:
Run:

python window.py

1	python window.py

And a window with a button will appear. Pressing the button will not do anything. To start a function when pressing the button, we need to define a so called Callback. This can be as simple as:

def OnButton(self, Event, button_label):
        print "In OnButton:", button_label

1 2	def OnButton(self, Event, button_label): print "In OnButton:", button_label

Finally we bind the button to the callback function using:

self.button_1.Bind(wx.EVT_BUTTON, self.OnButton )

1	self.button_1.Bind(wx.EVT_BUTTON, self.OnButton )

Pressing the button will now write a message to the command line. Instead of the boring command line message, we want to show a message box. This can be done using this command:

wx.MessageBox( "This is a message.", "Button pressed.");

1	wx.MessageBox( "This is a message.", "Button pressed.");

The full code below:

#!/usr/bin/env python
# -*- coding: UTF-8 -*-
#
# generated by wxGlade 0.6.8 on Fri Jan 23 22:59:56 2015
#

import wx

# begin wxGlade: dependencies
import gettext
# end wxGlade

# begin wxGlade: extracode
# end wxGlade


class MyFrame(wx.Frame):
    def __init__(self, *args, **kwds):
        # begin wxGlade: MyFrame.__init__
        kwds["style"] = wx.DEFAULT_FRAME_STYLE
        wx.Frame.__init__(self, *args, **kwds)
        self.button_1 = wx.Button(self, wx.ID_ANY, _("Hello World!"))
        self.button_1.Bind(wx.EVT_BUTTON, self.OnButton )

        self.__set_properties()
        self.__do_layout()
        # end wxGlade

    def __set_properties(self):
        # begin wxGlade: MyFrame.__set_properties
        self.SetTitle(_("wxWidgets button example. talkera.org/python "))
        # end wxGlade

    def __do_layout(self):
        # begin wxGlade: MyFrame.__do_layout
        sizer_1 = wx.BoxSizer(wx.VERTICAL)
        sizer_1.Add(self.button_1, 0, 0, 0)
        self.SetSizer(sizer_1)
        sizer_1.Fit(self)
        self.Layout()
        # end wxGlade

    def OnButton(event, button_label):
        wx.MessageBox( "This is a message.", "Button pressed.");
  

# end of class MyFrame
if __name__ == "__main__":
    gettext.install("app") # replace with the appropriate catalog name

    app = wx.PySimpleApp(0)
    wx.InitAllImageHandlers()
    frame_1 = MyFrame(None, wx.ID_ANY, "")
    app.SetTopWindow(frame_1)
    frame_1.Show()
    app.MainLoop()

#!/usr/bin/env python

# -*- coding: UTF-8 -*-

# generated by wxGlade 0.6.8 on Fri Jan 23 22:59:56 2015

import wx

# begin wxGlade: dependencies

import gettext

# end wxGlade

# begin wxGlade: extracode

# end wxGlade

class MyFrame(wx.Frame):

def __init__(self, *args, **kwds):

# begin wxGlade: MyFrame.__init__

kwds["style"] = wx.DEFAULT_FRAME_STYLE

wx.Frame.__init__(self, *args, **kwds)

self.button_1 = wx.Button(self, wx.ID_ANY, _("Hello World!"))

self.button_1.Bind(wx.EVT_BUTTON, self.OnButton )

self.__set_properties()

self.__do_layout()

# end wxGlade

def __set_properties(self):

# begin wxGlade: MyFrame.__set_properties

self.SetTitle(_("wxWidgets button example. talkera.org/python "))

# end wxGlade

def __do_layout(self):

# begin wxGlade: MyFrame.__do_layout

sizer_1 = wx.BoxSizer(wx.VERTICAL)

sizer_1.Add(self.button_1, 0, 0, 0)

self.SetSizer(sizer_1)

sizer_1.Fit(self)

self.Layout()

# end wxGlade

def OnButton(event, button_label):

wx.MessageBox( "This is a message.", "Button pressed.");

# end of class MyFrame

if __name__ == "__main__":

gettext.install("app") # replace with the appropriate catalog name

app = wx.PySimpleApp(0)

wx.InitAllImageHandlers()

frame_1 = MyFrame(None, wx.ID_ANY, "")

app.SetTopWindow(frame_1)

frame_1.Show()

app.MainLoop()

January 20, 2015 admin 0

An Introduction to Building Quantum Computing Applications with Python

Standard

So we want to make a quantum application with Python, but since we do not own any quantum computer we need to have a simulator first. Simulation will not have the same performance as an actual quantum computer but we will be able to run applications. We have a choice from three simulators: PyQu , QuTip and Qitensor. We decided to pick QuTip as it has a very large code base and as it has the most recent changes. PyQu hasn’t been updated since 2010 and Qitensor since a year or so.

Installing
We use a Unix machine in this tutorial, but you should be fine with any other operating system. Install using:

sudo add-apt-repository ppa:jrjohansson/qutip-releases
sudo apt-get update
sudo apt-get install python-qutip

sudo add-apt-repository ppa:jrjohansson/qutip-releases

sudo apt-get update

sudo apt-get install python-qutip

We then start Python from the command line and type the commands listed below ( >>> ).

$ python
Python 2.7.6 (default, Mar 22 2014, 22:59:38) 
[GCC 4.8.2] on linux2
Type "help", "copyright", "credits" or "license" for more information.
>>> from qutip import *
>>> about()

QuTiP: Quantum Toolbox in Python
Copyright (c) 2011 and later.
Paul D. Nation & Robert J. Johansson

QuTiP Version:      3.1.0
Numpy Version:      1.8.2
Scipy Version:      0.13.3
Cython Version:     0.20.1post0
Matplotlib Version: 1.3.1
Fortran mcsolver:   True
scikits.umfpack:    False
Python Version:     2.7.6
Platform Info:      Linux (i686)
Installation path:  /usr/lib/python2.7/dist-packages/qutip

$ python

Python 2.7.6 (default, Mar 22 2014, 22:59:38)

[GCC 4.8.2] on linux2

Type "help", "copyright", "credits" or "license" for more information.

>>> from qutip import *

>>> about()

QuTiP: Quantum Toolbox in Python

Paul D. Nation & Robert J. Johansson

QuTiP Version: 3.1.0

Numpy Version: 1.8.2

Scipy Version: 0.13.3

Cython Version: 0.20.1post0

Matplotlib Version: 1.3.1

Fortran mcsolver: True

scikits.umfpack: False

Python Version: 2.7.6

Platform Info: Linux (i686)

Installation path: /usr/lib/python2.7/dist-packages/qutip

This indicates that Qutip has been correctly installed.

The Quantum data structure
In quantum systems we need a data structure that is capable of encapsulating the properties of a quantum operator and ket/bra vectors, we use the Qobj data structure for that. In other words, to effectively simulate a quantum application we need to use the appropriate data structure. Consider the example below:

#!/usr/bin/env python
from qutip import *
from scipy import *

r = rand(4, 4)
print Qobj(r)

#!/usr/bin/env python

from qutip import *

from scipy import *

r = rand(4, 4)

print Qobj(r)

And execute with:

python quantum.py

1	python quantum.py

This will output the quantum object:

Quantum object: dims = [[4], [4]], shape = [4, 4], type = oper, isherm = False
Qobj data =
[[ 0.25529374  0.75548592  0.85680266  0.1438253 
 [ 0.75070138  0.68628867  0.97435624  0.77396516]
 [ 0.69819458  0.81714756  0.2604015   0.69051901]
 [ 0.0898242   0.05292657  0.49134431  0.4433644 ]]

Quantum object: dims = [[4], [4]], shape = [4, 4], type = oper, isherm = False

Qobj data =

[[ 0.25529374 0.75548592 0.85680266 0.1438253

[ 0.75070138 0.68628867 0.97435624 0.77396516]

[ 0.69819458 0.81714756 0.2604015 0.69051901]

[ 0.0898242 0.05292657 0.49134431 0.4433644 ]]

If you want to specify user input yourself you could use:

#!/usr/bin/env python
from qutip import *
from scipy import *

x = array([[1],[2],[3],[4],[5]])
q = Qobj(x)
print q

#!/usr/bin/env python

from qutip import *

from scipy import *

x = array([[1],[2],[3],[4],[5]])

q = Qobj(x)

print q

This quantum object will simply hold your user given data:

Quantum object: dims = [[5], [1]], shape = [5, 1], type = ket
Qobj data =
[[ 1.]
 [ 2.]
 [ 3.]
 [ 4.]
 [ 5.]]

Quantum object: dims = [[5], [1]], shape = [5, 1], type = ket

Qobj data =

[[ 1.]

[ 2.]

[ 3.]

[ 4.]

[ 5.]]

Quantum states and operators
A quantum system is not a simple two-level system, it has multiple states. QuTip includes some predefined states and quantum operators which are listed here.

Qubits and operators
We create a Qubit to hold data. Th Qubit is the quantum analogue of the classical bit. Unlike traditional bits, the qubit can be in a superposition of both states at the same time, a property which is fundamental to quantum computing. The code below will create a qubit:

#!/usr/bin/env python
from qutip import *
from scipy import *

spin = basis(2, 0)
print spin

#!/usr/bin/env python

from qutip import *

from scipy import *

spin = basis(2, 0)

print spin

You can now apply quantum system operators on the qubit:

#!/usr/bin/env python
from qutip import *
from scipy import *

spin = basis(2, 0)
print sigmam() * spin
print sigmap() * spin

#!/usr/bin/env python

from qutip import *

from scipy import *

spin = basis(2, 0)

print sigmam() * spin

print sigmap() * spin

Combining qubits
To describe the states of two coupled qubits we need to take the tensor product of the state vectors for each of the system components. Let us try that:

#!/usr/bin/env python
from qutip import *
from scipy import *

q1 = basis(2, 0)
q2 = basis(2,0)

print q1
print q2
print tensor(q1,q2)

#!/usr/bin/env python

from qutip import *

from scipy import *

q1 = basis(2, 0)

q2 = basis(2,0)

print q1

print q2

print tensor(q1,q2)

The output we will get is:

Quantum object: dims = [[2], [1]], shape = [2, 1], type = ket
Qobj data =
[[ 1.]
 [ 0.]]
Quantum object: dims = [[2], [1]], shape = [2, 1], type = ket
Qobj data =
[[ 1.]
 [ 0.]]
Quantum object: dims = [[2, 2], [1, 1]], shape = [4, 1], type = ket
Qobj data =
[[ 1.]
 [ 0.]
 [ 0.]
 [ 0.]]

Quantum object: dims = [[2], [1]], shape = [2, 1], type = ket

Qobj data =

[[ 1.]

[ 0.]]

Quantum object: dims = [[2], [1]], shape = [2, 1], type = ket

Qobj data =

[[ 1.]

[ 0.]]

Quantum object: dims = [[2, 2], [1, 1]], shape = [4, 1], type = ket

Qobj data =

[[ 1.]

[ 0.]

[ 0.]]

Whats next?
We have built some very simply quantum applications using this simple introduction. Perhaps you want to create an actually useful application, if so you could study more about quantum computing and complete the tutorial at http://qutip.org/docs/2.2.0/index.html

January 13, 2015 admin 0

Building an IRC (ro)bot

Standard

There are tons of (ro)bots out there for IRC (Internet Relay Chat). So how do you start and build one in Python, just for fun?

You will need a program that connects with an IRC server and acts like a traditional IRC client. IRC servers never ask for any type of complicated human verification such as solving captchas, which is why we can simply connect with a script. The script itself will use network sockets, a library that is often used to provide network interactions in many programming languages including Python and C/C++.

To communicate with an IRC server, you need to use the IRC protocol. The IRC protocol has distinct messages such as PRIVMSG, USER, NICK and JOIN. If you are curious, you could read the entire protocol. But following this tutorial may be a lot simpler Authentication is achieved using only a few steps:

The IRC protocol is a layer on top of the IP protocol. To create a socket we use the command:

irc = socket.socket(socket.AF_INET, socket.SOCK_STREAM)

1	irc = socket.socket(socket.AF_INET, socket.SOCK_STREAM)

socket.AF_INET tells the library to use the network protocol IPv4. The second argument tells the library to use stream sockets, which are traditionally implemented on the TCP protocol. (IRC works over TCP/IP). We then must use the commands to authenticate with the server:

USER botname botname botname: phrase
NICK botname
JOIN #channel

USER botname botname botname: phrase

NICK botname

JOIN #channel

Sometimes the IDENT command is neccesary too. Summing up, we get this class (save it as irc.py):

import socket
import sys


class IRC:

    irc = socket.socket()
  
    def __init__(self):  
        self.irc = socket.socket(socket.AF_INET, socket.SOCK_STREAM)

    def send(self, chan, msg):
        self.irc.send("PRIVMSG " + chan + " " + msg + "\n")

    def connect(self, server, channel, botnick):
        #defines the socket
        print "connecting to:"+server
        self.irc.connect((server, 6667))                                                         #connects to the server
        self.irc.send("USER " + botnick + " " + botnick +" " + botnick + " :This is a fun bot!\n") #user authentication
        self.irc.send("NICK " + botnick + "\n")               
        self.irc.send("JOIN " + channel + "\n")        #join the chan

    def get_text(self):
        text=self.irc.recv(2040)  #receive the text

        if text.find('PING') != -1:                      
            self.irc.send('PONG ' + text.split() [1] + '\r\n') 

        return text

import socket

import sys

class IRC:

irc = socket.socket()

def __init__(self):

self.irc = socket.socket(socket.AF_INET, socket.SOCK_STREAM)

def send(self, chan, msg):

self.irc.send("PRIVMSG " + chan + " " + msg + "\n")

def connect(self, server, channel, botnick):

#defines the socket

print "connecting to:"+server

self.irc.connect((server, 6667)) #connects to the server

self.irc.send("USER " + botnick + " " + botnick +" " + botnick + " :This is a fun bot!\n") #user authentication

self.irc.send("NICK " + botnick + "\n")

self.irc.send("JOIN " + channel + "\n") #join the chan

def get_text(self):

text=self.irc.recv(2040) #receive the text

if text.find('PING') != -1:

self.irc.send('PONG ' + text.split() [1] + '\r\n')

return text

Now that we have the network connectivity class, we can use it as an instance. We will keep our (ro)bot simple for explanatory purposes. The bot will reply “Hello!” if it gets the message “hello” in the channel it resides.

from irc import *
import os
import random

channel = "#testit"
server = "irc.freenode.net"
nickname = "reddity"

irc = IRC()
irc.connect(server, channel, nickname)


while 1:
    text = irc.get_text()
    print text
 
    if "PRIVMSG" in text and channel in text and "hello" in text:
        irc.send(channel, "Hello!")

from irc import *

import os

import random

channel = "#testit"

server = "irc.freenode.net"

nickname = "reddity"

irc = IRC()

irc.connect(server, channel, nickname)

while 1:

text = irc.get_text()

print text

if "PRIVMSG" in text and channel in text and "hello" in text:

irc.send(channel, "Hello!")

Save it as bot.py and run with python bot.py. Connect with a traditional irc client (mirc,hexchat,irsii) to the the channel and observe the experiment has worked! You can now extend it with any cool features you can imagine.

January 11, 2015 admin 0

Creating a gmail wordcloud

Standard

I have created a python program that generates a wordcloud based on your gmail account. The output may look something like this depending on the contents of your emails:

First you will need a small script that interacts with the gmail service. We have created a small script that interact with gmail. It relies on gmaillib installed and you will need to set: allow “less-secure” applications to access gmail server: https://www.google.com/settings/security/lesssecureapps

Gmail example:

#!/usr/bin/env python
import gmaillib
from collections import Counter


def getMails(cnt,account, start,amount):
  emails = account.inbox(start, amount)

  for email in emails:
    cnt[email.sender_addr] += 1

amountOfMails = 100
cnt = Counter()
username = raw_input("Gmail account: ")
password = raw_input("Password: ")

account = gmaillib.account(username, password)

getMails(cnt,account,0,amountOfMails)
print cnt

#!/usr/bin/env python

import gmaillib

from collections import Counter

def getMails(cnt,account, start,amount):

emails = account.inbox(start, amount)

for email in emails:

cnt[email.sender_addr] += 1

amountOfMails = 100

cnt = Counter()

username = raw_input("Gmail account: ")

password = raw_input("Password: ")

account = gmaillib.account(username, password)

getMails(cnt,account,0,amountOfMails)

print cnt

If this script runs successfully you have almost all requirements installed. You will also need the library called wordcloud. We rebuild the system such that we get one long string containing the message bodies, which we feed as input to the wordcloud instance. The variable amount contains the number of mails to fetch. We have set it to 100 but you could set it to all messages using get_inbox_count() or you could simply fetch all emails of the last week.

Final program:

#!/usr/bin/env python
import gmaillib
from collections import Counter
from wordcloud import WordCloud
import matplotlib.pyplot as plt

amount = 100
cnt = Counter()
username = raw_input("Gmail account: ")
password = raw_input("Password: ")

account = gmaillib.account(username, password)

emails = account.inbox(0, amount)

data = ""
for email in emails:
  data = data + str(email.body)

wordcloud = WordCloud().generate(data)
plt.imshow(wordcloud)
plt.axis("off")
plt.show()

#!/usr/bin/env python

import gmaillib

from collections import Counter

from wordcloud import WordCloud

import matplotlib.pyplot as plt

amount = 100

cnt = Counter()

username = raw_input("Gmail account: ")

password = raw_input("Password: ")

account = gmaillib.account(username, password)

emails = account.inbox(0, amount)

data = ""

for email in emails:

data = data + str(email.body)

wordcloud = WordCloud().generate(data)

plt.imshow(wordcloud)

plt.axis("off")

plt.show()