Thursday, August 14, 2014

Build BitShares-X Client on Ubuntu 14.04

BitShares X was the first project from Invictus Innovations that I participated in.
For some reason Invictus Innovations creates binaries for their client software only for Mac and Windows.
Below are the instructions on how I set it up on Ubuntu 14.04.

Install prerequisite packages (including some that are not mentioned in the docs):

sudo apt-get update
sudo apt-get install cmake git libreadline-dev uuid-dev g++ libdb++-dev libdb-dev zip libssl-dev openssl build-essential python-dev autotools-dev libicu-dev libbz2-dev libboost-dev libboost-all-dev nodejs-legacy libgl1-mesa-dev libegl1-mesa-dev npm


Download BitShares X code from GitHub:

cd ~/src
git clone https://github.com/dacsunlimited/bitsharesx.git
cd bitsharesx

Go to this web page so you can get the latest release number (for example: 0.4.20):

git tag  #Note the exact name of the tag for that version
git checkout v0.4.20
git submodule init
git submodule update


Download and install Qt 5.3.1 for Linux 64-bit:

cd ~/src
wget http://download.qt-project.org/official_releases/online_installers/qt-opensource-linux-x64-1.6.0-4-online.run
chmod +x qt-opensource-linux-x64-1.6.0-4-online.run
./qt-opensource-linux-x64-1.6.0-4-online.run


Download and install Node.js v0.10.29:

cd ~/src
wget http://nodejs.org/dist/v0.10.29/node-v0.10.29-linux-x64.tar.gz
tar xzf node-v0.10.29-linux-x64.tar.gz
cd node-v0.10.29-linux-x64
export PATH=/home/$USER/src/node-v0.10.29-linux-x64/bin:$PATH


Install lineman and its dependencies in web_wallet folder using npm:

cd ~/src/bitsharesx/programs/web_wallet

(The next two commands take a few minutes to complete.)

sudo npm install -g lineman
sudo npm install

Configure using CMake:

cd ~/src
mkdir bitsharesx-build
cd bitsharesx-build
export CMAKE_PREFIX_PATH=/home/$USER/src/Qt/5.3/gcc_64/
cmake -DINCLUDE_QT_WALLET=ON ../bitsharesx


Make the web wallet first, and then the rest of the system -- note that there will be a lot of warnings -- just ignore all the warnings:

cd ~/src/bitsharesx-build
make buildweb
make


Run the Qt client to confirm that it works:

cd ~/src/bitsharesx-build/programs/qt_wallet && ./BitSharesX


The first thing you should do is export your wallet. It will be saved in the form of a .json file and the contents will be encrypted already.


To upgrade to the latest release of BitSharesX


First, delete the old build:

cd ~/src
sudo rm -rf bitsharesx

Then repeat the steps above in the section titled: "Download BitShares X code from GitHub"
Skip the sections for installing Qt and node.js.
Then continue following instructions above starting with the section "nstall lineman and its dependencies in web_wallet folder using npm".

If you have problems with any of the above, then refer to the original instructions here.


If BitSharesX never synchronizes completely

If you can launch BitSharesX and log in normally but it never completely synchronizes because it displays "Severe network problems | Last block is synced xx days old" at the bottom of the screen, then do the following:

  1. Using Ubuntu's GUI file browser, go to your Home folder.
  2. Copy the "BitShares X" folder and Paste it -- the new folder will be named "BitShares X (copy)" -- this is your backup in case things don't work properly.
  3. Open the "BitShares X" folder and delete everything except the "wallets" folder.
  4. Re-boot your VM.
  5. Launch BitSharesX -- it will take a while to respond. While you're waiting it will say "Not connected" in the lower right. Eventually it will start synchronizing... and that will take even longer because it will download the entire blockchain again.

Build BitShares-PTS Client on Ubuntu 14.04

Holding BitShares-PTS in your own private wallet is the only way you can use the "protoshares" cryptocurrency to gain access to fundraisers in Invictus Innovations projects, but the BitShares-PTS wallet is a pain to set up on Ubuntu.
Below is the process I followed to set up my BitShares-PTS wallet.

In the Terminal window type:
sudo apt-get install qt4-qmake libqt4-dev build-essential libboost-dev libboost-system-dev libboost-filesystem-dev libboost-program-options-dev libboost-thread-dev libssl-dev libdb++-dev libminiupnpc-dev
cd ~/src
git clone https://github.com/BitShares/BitShares-PTS.git

To build the CLI:
cd BitShares-PTS/srcmake -f makefile.unix

To build the GUI, first download Qt-Creator.

Then run these commands:
cd <folder-where-qt-file-was-saved>
chmod +x qt-opensource-linux-x64-1.6.0-4-online.run
./qt-opensource-linux-x64-1.6.0-4-online.run

Accept all the defaults when going through the GUI prompts and let it launch Qt Creator when it's done installing.

In Qt Creator:
File > Open File or Project
Select the file: ~/src/BitShares-PTS/bitshares-pts.pro
Press: Configure Project
On the left side press the green triangle icon to run BitShares-PTS.
The current status of the build should appear at the bottom right.
After a period of building it should launch BitShares-PTS GUI client -- exit the client right away because you need to make some additional changes first.

The client will not work unless you provide some valid peers to connect to, so type this in the Terminal:
cd ~/.bitshares-pts
gedit bitshares-pts.conf

Copy and paste this text inside of the file and save it:
maxconnections=10
connect=cryptoseed.cloudapp.net:80
connect=76.72.171.91:80
connect=5.9.24.81:80
connect=23.92.25.118:80


After you exit BitShares-PTS (and Qt Creator), you can launch from the command line by typing:
~/src/build-bitshares-pts-Desktop_Qt_5_3_GCC_64bit-Debug/BitShares-PTS

If you get this message in the lower left of the BitShares-PTS client

"No block source available"

Then click: Help > Debug Window
Click Console tab.
And enter these commands into the edit box at the bottom of the window:
addnode cryptoseed.cloudapp.net:80 add
addnode 76.72.171.91:80 add
addnode 5.9.24.81:80 add
addnode 23.92.25.118:80 add

If you get this error message when you launch the BitShares-PTS client

"Error loading block database. Do you want to rebuild the block?"
then do this in the Terminal:
cd ~/src/build-bitshares-pts-Desktop_Qt_5_3_GCC_64bit-Debug
./BitShares-PTS --reindex

Saturday, August 2, 2014

Build "PyEth" -- the Ethereum command-line client, Python implementation

Please use the instructions at this page instead -- I was never able to get a return value from a contract using the setup described below.



I recently built the Python version of the Ethereum client (which does not come in GUI form, it only comes as a command-line tool).
With this version of the client you can run Serpent code.

Overview of the entire set-up process

  1. Set up VM
  2. Install pip
  3. Build pyeth
  4. Install pyethereum
  5. How to update pyethereum from GitHub

1. Set up VM

If you have already set up your VM (Virtual machine), then take a snapshot first in case something goes wrong.
If you have not already set up your VM, then follow the steps from this blog post.

2. Install pip

Download get-pip.py and note which folder you saved it in.

Then run these commands from the Terminal:
cd folder-where-you-downloaded-the-file
sudo python get-pip.py
If the above instructions did not work, then try the instructions here.

3. Build pyeth

(Note: I have not actually tested pyeth yet, but do these steps anyway in case subsequent steps depend on them.)


At the terminal type:

sudo apt-get install -y build-essential libreadline-gplv2-dev libncursesw5-dev libssl-dev libsqlite3-dev tk-dev libgdbm-dev libc6-dev libbz2-dev curl python-dev
sudo pip install virtualenv
cd ~/src
wget https://bootstrap.pypa.io/bootstrap-buildout.py
sudo python bootstrap-buildout.py
git clone https://github.com/ethereum/pyethereum.git
Download this file to ~/src:
https://bootstrap.pypa.io/ez_setup.py
At the terminal type:
sudo python ez_setup.py
wget https://bootstrap.pypa.io/ez_setup.py -O - | sudo python
cd pyethereum
sudo pip install -r requirements.txt
sudo python setup.py install

Delete the database, just in case it's an older version that doesn't match the software:
rm -fr ~/.pyethereum/statedb
Run PyEth for the first time -- remember, this is only a command-line program, there will not be a graphical interface. (Note that when it runs the very first time it might give you a warning message regarding .python-eggs):
pyeth
If it seems to be running without issues, then press Ctrl-C to exit.
If you did get a python-eggs error, then enter this command to fix it:
chmod g-wx,o-wx ~/.python-eggs


4. Install pyethereum

Pyethereum allows you to call test contracts by calling them from python code.
Personally, I find this method of testing contracts to be very convenient.
Set up pyethereum:
cd ~/src/pyethereum
sudo python setup.py install
To interact with the Ethereum blockchain call:
pyethclient


5. Run a Serpent program on pyethereumNext, create a really simple contract that registers names -- much like namecoin -- and save it in the file "namecoin.se":
key = msg.data[0]value = msg.data[1]
# Key not yet claimedif not contract.storage[key]:   contract.storage[key] = value   return(1)else:   return([0], 1)  # Key already claimed
Then, create a python program that invokes the contract. Save it in the file "test_namecoin.py":
#! /usr/bin/env python
from pyethereum import tester as t
def run_serpent():
    s = t.state()  #Initialize genesis block
    c = s.contract('namecoin.se')  #Initialize contract
    name = "george"
    locn = 45
    result = s.send(t.k0, c, 0, [[name, locn]])
    print "Claim name \"{}\"\n at location {}\n result = {}".format(name, locn, result)
    name = "george"
    locn = 20
    result = s.send(t.k0, c, 0, [[name, locn]])
    print "Claim name \"{}\"\n at location {}\n result = {}".format(name, locn, result)
    name = "harry"
    locn = 65
    result = s.send(t.k0, c, 0, [[name, locn]])
    print "Claim name \"{}\"\n at location {}\n result = {}".format(name, locn, result)

if __name__ == "__main__":
    run_serpent()
Then test the contract by calling the python script from bash:
./test_namecoin.py

5. How to update pyethereum from GitHub

When the Ethereum folks announce a new proof-of-concept, update your local copy by running this in a terminal window:
cd ~/src/pyethereum && git pull -u origin master
Now, let's build it:
curl http://downloads.buildout.org/2/bootstrap.py | python
bin/buildout
Test that the setup works by launching PyEth:
~/src/pyethereum/bin/pyeth

Build "Aleth Zero" -- the Ethereum GUI client, C++ implementation

Please use the instructions at this page instead -- I was never able to get a return value from a contract using the setup described below.



I just installed the C++ version of Ethereum.
I've tried to provide the simplest explanation I could below.

Overview of the Entire Set-up process

  1. Set Up VM
  2. Build Stuff that Ethereum Needs
  3. Build Ethereum Client
  4. Launch AlethZero to Test It
  5. Get Some (Fake) Ether
  6. Optional: Back Up VM
  7. Load Contract
  8. Call Contract
  9. Learn How to Write Contracts
  10. Get Latest Client From GitHub

1. Set Up VM

If you have already set up your VM (Virtual Machine), then take a snapshot first in case something goes wrong.
If you have not already set up your VM, then follow the steps from this blog post.

2. Build Stuff that Ethereum Needs

Below I've summarized all the commands I entered in a Terminal window -- inside of the VM.
Some of the steps below will take a while, so while you're waiting for those steps to complete, check out this article.

Here are the steps to build Ethereum:
sudo apt-get update -y && sudo apt-get upgrade -y
sudo apt-get install -y build-essential g++-4.8 git cmake libgmp-dev libboost-all-dev automake unzip libtool libleveldb-dev yasm libminiupnpc-dev libreadline-dev scons libncurses5-dev qtbase5-dev qt5-default qtdeclarative5-dev libqt5webkit5-dev libcurl4-openssl-dev

I like to create a separate directory to store all my source code in before I begin:
mkdir -p ~/src

cd ~/src
git clone https://github.com/mmoss/cryptopp.git
cd cryptopp && sudo scons --shared --prefix=/usr

cd ~/src
git clone git://github.com/cinemast/libjson-rpc-cpp.git
cd libjson-rpc-cpp && git checkout v0.3.2
mkdir -p build && cd build && cmake .. && make
sudo make install
sudo ldconfig

3. Build Ethereum Client

In case there's a pre-existing incompatible blockchain, delete it:
rm -fr ~/.ethereum
Get the source code from GitHub:
cd ~/src
git clone https://github.com/ethereum/cpp-ethereum
Now, let's build it:
cd ~/src/cpp-ethereum && git checkout develop
mkdir -p build && cd build
cmake .. -DCMAKE_BUILD_TYPE=Release && make

4. Launch AlethZero to Test It

The C++ GUI client is called "AlethZero" (not "AlephZero").
After building the client software, test that it works by entering this command:
cd ~/src/cpp-ethereum/build/alethzero && ./alethzero
Wait a minute for the GUI to launch.

Click the button 'Go!' to connect to peers on the global test network.
Verify that you're connected to at least one peer by looking at the bottom of the client's GUI.

(The following info should not be necessary anymore, but here it is just in case: If after a minute or two you do not see any peers, then you'll have to hunt around in the Ethereum forums for an address that you can manually enter by selecting Network > Connect to peer. Just remember that the IP address you enter must always end with ":30303")

5. Get Some (Fake) Ether

First method - faucet:
Go to this website to get some free fake Ether to run your test programs with.
First, copy your address by double-clicking on an address in AlethZero's "Owned Accounts" sub-window, then paste into the web page and click the "Gimme Wei" button.

You may need to click the 'Refresh' button for your balance to refresh properly. I've noticed that Alethzero has a problem with not refreshing the GUI, so click 'Refresh' regularly.

Exit AlethZero, exit the VM, and take another VirtualBox snapshot.
Name the snapshot "Ethereum client compiled".

Second method - mine it:
Next, mine your own Ether by choosing menu: Debug > Force Mining.
Then click the button 'Mine'.

If the steps above did not work for you, then here are the original instructions from the Ethereum web page.

6. Optional: Back Up VM

Log out of the VM, but leave the main VirtualBox Manager window still running.
Choose menu: File > Export Appliance
Save it to an external drive if you have one available.

Now that you have a backup, you can import the "Ethereum Dev" VM onto any machine with VirtualBox installed.
(Be sure to check-mark 'Reinitialize the MAC address of all network cards' -- just in case you want several VMs on the same network -- at least that's what I read online somewhere.)

7. Load Contract

Eventually, all of Ethereum's contract languages will run on all the clients, but at the present time AlethZero only runs contracts written in LLL or Serpent.

Copy the following LLL contract and paste it into the 'Data' field in AlethZero (this contract simply multiplies a number by two):

(return 0 
    (lll 
        (seq 
            (set '_temp4_1 (mul (calldataload 0) 2))
            (return (ref '_temp4_1) 32)
        )
        0
    )
)

Stop mining by clicking the 'Mine' button again (we're only stopping mining so we can easily identify our contract in the pending window).
Then click the button 'Execute'.
Look in the "Pending" sub-window and note the address of the contract (it will follow the word "Creates:").

Start mining by clicking the 'Mine' button again -- this will cause the "Pending" sub-window to clear out.
Now you can open the "Contracts" sub-window and double-click on the contract that begins with those same characters you noted earlier. Double-clicking copies the text of the address (yeah, I know that's not standard behavior).

8. Call Contract

TBD



9. Learn How to Write Contracts

All of this info is most certainly outdated already, but it's probably still worth looking at until we get newer info.



10. Get Latest Client From GitHub

When the Ethereum folks announce a new proof-of-concept, update your local copy by running this in a terminal window (this is the scorched earth approach and seems to work best):
cd ~/src && sudo rm -rf cpp-ethereum
Then run through the steps again in the section titled: "Build Ethereum Client".

Feel free to play around with AlethZero -- if you completely mess things up just restore the previous VM snapshot.

Thursday, July 31, 2014

Build "Ethereal" -- the Ethereum GUI client, Go implementation

Please use the instructions at this page instead -- I was never able to get a return value from a contract using the setup described below.



I recently built the Go (aka Golang) version of the Ethereum client.
It was much faster and easier than the C++ version.

Overview of the entire set-up process

  1. Get VM (Virtual Machine) set up
  2. Run the Go-Ethereum install script
  3. Connect to the permanent Go-Ethereum mining node
  4. Run a sample program
  5. How to update Go-Ethereum from GitHub

1. Get VM (Virtual Machine) set up

If you have already set up your VM, then take a snapshot first in case something goes wrong.
If you have not already set up your VM, then follow the steps from this blog post.

2. Run the Go-Ethereum install script

Just run these three commands from the Terminal window (for Ubuntu 14.04 only):
cd ~/src
wget https://gist.githubusercontent.com/maran/2d69089ed5ea3f83fde8/raw -O install
chmod +x install
./install
This takes a while to complete, so invest some of this waiting-around-time into reading this article discussing the current debate over Bitcoin within the Austrian school of economics.

If you were unable to make the script work, then follow the original, more detailed instructions here.


3. Connect to the permanent Go-Ethereum mining node

When I ran ethereal out of the box it was unable to connect to any peers. So, as a result I couldn't mine any Ether, which prevented me from actually executing my test code.
To get around this problem, connect your client to the permanent Go Ethereum mining node that was set up for developers and testers like us.

The first time you execute Ethereal, run these command in the Terminal:
cd $GOPATH/src/github.com/ethereum/go-ethereum/ethereal && ethereal -seed=false

When the GUI appears, type Ctrl-P, and paste the following into the popup window and click 'Add':
107.178.217.2:30303
Next, press the 'Start mining' button on the lower-left. You should (gradually over time) start to see the number of Ether increase on the status bar at the bottom of the window.

In the future, whenever you run Ethereal again you can launch it by running this in the Terminal:

cd $GOPATH/src/github.com/ethereum/go-ethereum/ethereal && ethereal


If you have trouble with this, then read the original description here.


4. Run a sample program

Let's copy this sample program (written in Mutan) and paste it into Ethereal:
# Initialization
contract.storage[tx.origin()] = 10**20
exit compile {
    var to = this.data[0]
    var from = tx.origin()
    var value = this.data[1]
 
    if contract.storage[from] >= value {
        contract.storage[from] = contract.storage[from] - value
        contract.storage[to] = contract.storage[to] + value
    }
}

Press 'Send'. It will give you the address of the contract you just sent to the network.

Now that you know Ethereal works properly, exit Ethereal, exit the VM, and take another VirtualBox snapshot.
Name the snapshot "Go-Ethereum compiled".

5. How to update Go-Ethereum from GitHub

Run these commands to update Go-Etherum (and Ethereal):
go get -u github.com/ethereum/go-ethereum/ethereum
go get -u -a github.com/ethereum/go-ethereum/ethereal
Then launch Ethereal normally:
cd $GOPATH/src/github.com/ethereum/go-ethereum/ethereal && ethereal

Sunday, July 6, 2014

Set up a Virtual Machine for Ethereum Contract Development

Yesterday, my friend and I got got talking about setting and achieving goals. Then he sent me this great article titled, "Do things, tell people."

My whole life I've kept to myself too much. So, I just made a promise to myself that whatever I'm working on, I'm going to share it with as many people as possible.
If I notice I'm not talking to people, then maybe I need to start doing things that are driven by a burning desire!
So, in the spirit of telling people what I'm doing, here is a blog post that explains how I set up my VM (virtual machine) which I later used to install the Ethereum client.

There are already well written instructions on the Internet that explain how to set up the Ethereum client. However, when I tried to follow the instructions I clearly made some kind of bone-headed mistake because my system stopped booting and I had to re-install the operating system. 
So, I'm recording what I did to make the process reproducible.
Also, from now on, if I have enough hard drive space, I will always set up my build environments inside of a virtual machine (VM) so I don't have to re-install the OS.

Overview of the entire set-up process for 

  1. Install VirtualBox
  2. Install Ubuntu 14.04 in VirtualBox
  3. Export the VirtualBox setup to back it up as a "Basic Ubuntu Install


1. Install VirtualBox

My host OS is Ubuntu 14.04 and my VirtualBox guest OS will also be Ubuntu 14.04.
Why did I choose Ubuntu 14.04 as my guest OS? Because most of the instructions I saw that provide the easiest methods for getting stuff to work were targeted to 14.04 -- I'm taking the path of least resistance.

I did not install VirtualBox from the Ubuntu Software Center because in the past I have been unable to make USB ports work using that method.
Follow the helpful instructions at the end of this section.
(Note that when the instructions mention the 'Other Software' tab, you need to select the Software Center menu 'Edit > Software Sources'.)

Here are the instructions.

2. Install Ubuntu 14.04 in VirtualBox

Follow this link so you can download an ISO image of Ubuntu 14.04.

One mistake I made in a previous attempt was to install on an older build of Ubuntu -- just install the newest version, life is too short!

Next, launch VirtualBox and create a new VM.
Name the VM "Ethereum Dev".
Set memory size to a large value -- I chose 1024 MB out of a total of 32 GB.
Select 'Create a virtual hard drive now' -- and be sure to choose 'VMDK' for greater portability to other platforms.
Allow the virtual drive to be 'Dynamically allocated' so it uses less space and expands in size as you use it more.
I chose the maximum value of 2 TB for my hard drive because I have an enormous hard drive and the virtual drive doesn't actually grow in size until you use it.

This next paragraph turned out to be kind of important:
Set up the ISO image as a DVD drive (or insert the physical DVD into the drive) before launching the new VM. I tried doing it after launching and I had to delete the VM, scream into a pillow, and start over.

Launch the new VM and click 'Install Ubuntu' from the ISO image.
I check-marked 'Download updates while installing', then clicked 'Continue'.
Because any code I develop inside this VM will be posted for anyone to use on the Internet, I chose to not encrypt the installation, so I selected 'Erase disk and install Ubuntu'.
I also check-marked 'Use LVM with the new Ubuntu installation' just for the hell of it.
Click 'Install Now'.
I also selected 'Log in automatically' then proceeded into the installation.
While it's installing, read this article and think about how bitcoin might affect our future.
When it's done installing, click 'Restart Now'.

Another thing that turned out to be important:
I originally tried doing all of the remaining steps in this section in a different order but it failed miserably.
Stick to the steps below. I've done it three times in a row and so far it's worked every time, but cross your fingers just in case.

Inside of the VM, open a Terminal window (Ctrl-Alt-T) and run these commands:
sudo apt-get update && sudo apt-get upgrade
While it processes that command, take some time to process this article by L. Neil Smith.
Then enter this command in the Terminal:
sudo apt-get install virtualbox-guest-dkms virtualbox-guest-utils virtualbox-guest-x11
These programs will allow the desktop to re-size so it always fits the size of the VirtualBox window. But keep in mind that I see this functionality stop working on a regular basis. I'm able to get it working again by exiting the VM then re-booting the host OS.

Run these command:
sudo apt-get update && sudo apt-get dist-upgrade
While the VM is still running, select this VirtualBox menu (not the VM menu): Devices > Insert Guest Additions CD Image
Then click the 'Run' button. Then answer 'yes' to continue despite the system whining that something seems wrong.

At this point I had to re-boot the VM because the screen was too small so I couldn't access some of the buttons. Re-boot the VM by clicking the gear icon in the upper-right and choosing 'Shut Down'.
Click 'Start' to re-launch the VM again.

Inside of the VM, install git by clicking on the Ubuntu Software Center. (I'll assume you know how to do that already.)

Exit the VM window, but leave the VirtualBox Manager window open.
Click the 'Snapshots' button, then take a snapshot (Ctrl-Shift-S).
Name the snapshot "Ubuntu basic install".

3. Export the VirtualBox setup to back it up as a 'Basic Ubuntu Install'

Log out of the VM, but leave the main VirtualBox Manager window still running.
Choose menu: File > Export Appliance
Save it to an external drive if you have one available.
In the event you completely gox things, you can always recover this basic setup by choosing 'File > Import Appliance'.

What next?

Next you'll want to install one or more of the Ethereum clients. I will create a blog post for each one later.
I plan on installing the Go, C++ and Python clients just because I'd like to learn new stuff.
Below is some info that may help you choose which one to install.

I read somewhere that the Go version would eventually be dubbed the reference client (meaning that it would be used to generate the binary executables for the general public to use).
Also, at the present time only the C++ and Go clients are technically compatible with each other -- so I suppose that may mean the Python client is not as up-to-date?

But if you want to write programs for Ethereum in a specific language, then you need to understand that at some point in the future all three languages (LLL, Serpent and Mutan) will work on all the clients. But for now:
  • The Go-like language, which is called "Mutan", only runs on the the Go client.
  • The Python-like language, which is called "Serpent", only runs on the Python client.
  • The Lisp-like language, called "LLL", only runs on the C++ client.
If you're like me, I'd like to use the GUI (graphical user interface) instead of the CLI (command line interface) at first. When I understand things a little better I'll want to learn the CLI as well.
One area of confusion for me was the naming of the GUI clients:
  • The C++ GUI client is called "alethzero".
  • The Go GUI client is called "ethereal".
  • The Python client does not come as a GUI form, only as a CLI, and it's called "pyeth".