Query7 » Tutorials

Kohana 3.1 Wiki Tutorial Routes

logan — Mon, 16 May 2011 07:39:43 +0000

In the original Kohana wiki application the URLs in the views were hardcoded. If we wanted to change the domain name or restructure a route we would need to go through the application and change every single URL.

Thankfully the Kohana Route class comes with a method url() which allows us to generate URLs to routes we have specified in the application. In the first tutorial we defined the following routes in application/bootstrap.php:

Route::set('wiki-edit', 'wiki//edit')
	->defaults(array(
		'controller'=> 'wiki',
		'action'	=> 'edit_page',
	));

Route::set('wiki-save', 'wiki//save')
	->defaults(array(
		'controller'=> 'wiki',
		'action'	=> 'save_page',
	));

Route::set('wiki-page', 'wiki/')
	->defaults(array(
		'controller'=> 'wiki',
		'action'	=> 'view_page',
	));

Route::set('default', 'wiki')
	->defaults(array(
		'controller' => 'wiki',
		'action'     => 'view_page',
		'id'		 => 'index',
	));

Before we can generate routes we need to set some configuration options in application/bootstrap.php (line ~82). We need to specify the base_url and index_file attributes in the array passed to Kohana::init(). The application on my local install is located at 127.0.0.1/query7kwiki/index.php, so my Kohana::init() statement would read:

Kohana::init(array(
	'base_url'   => '/query7kwiki/',
	'index_file' => 'index.php'
));

In application/views/edit.php the form action attribute was hardcoded to the value /query7kwiki/index.php/wiki/. That can be replaced by:

 $page)); ?>

In application/views/single.php there is a link to the edit that specific page. We can replace the href of the anchor tag with:

 $page)); ?>

In the view application/views/create.php change the href of the create page link to:

 $page)); ?>

The wiki application is now portable and can safely be moved to a different server without functionality breaking.

Kohana 3.1 Wiki Tutorial

logan — Mon, 09 May 2011 06:09:52 +0000

In this tutorial you will learn how to create a simple wiki using the PHP framework Kohana version 3.1. Several years ago Siddharta Govindaraj created a screencast demonstrating how to create a wiki using Django, this is essentially the Kohana version of that. It covers using Kohana’s Routing, ORM and MVC systems. Full source code of the application is available on github.

The wiki application has 3 different pages:

/wiki/somepage/save – handles the saving of the page
/wiki/somepage/edit – displays a form that allows the user to edit the page
/wiki/somepage – displays the page

Configuration

We will be using the ORM module to query the database for our wiki pages so we must load it in the application/bootstrap.php file (Line ~99).

Kohana::modules(array(

	'database'   => MODPATH.'database',   // Database access
	'orm'        => MODPATH.'orm',        // Object Relationship Mapping

	));

We also need to specify our database configuration settings. This is done in application/config/database.php.

 array
  	(
  		'type'       => 'mysql',
  		'connection' => array(
  			'hostname'   => '127.0.0.1',
  			'username'   => 'root',
  			'password'   => 'root',
  			'persistent' => FALSE,
  			'database'   => 'query7kwiki',
  		),
  		'table_prefix' => '',
  		'charset'      => 'utf8',
  		'caching'      => FALSE,
  		'profiling'    => TRUE,
  	),
  );

  ?>

Model

Compared to most ORMs (Django, Doctrine, Propel), Kohana’s ORM is relatively light. You don’t need to specify the fields of your table as the Kohana ORM doesn’t attempt to generate the tables for you. It simply maps attribute names of the model object to field names in the database table. Be sure to check the Kohana Documentation for a detailed explanation of the ORM.

application/classes/model/page.php

class Model_Page extends ORM
{

	protected $_table_name = 'page';

	public function rules()
	{
		return array(

			'title' => array(
						array('not_empty')
							)

		);
	}

}

Execute the following SQL:

CREATE TABLE `page` (
`id` INT( 11 ) NOT NULL AUTO_INCREMENT PRIMARY KEY ,
`title` VARCHAR( 255 ) NOT NULL ,
`content` TEXT NOT NULL
) ENGINE = MYISAM ;

Routing

I define all routes at the bottom of application/bootstrap.php, however if you are working on a large application it may beneficial in the long run to define them in a separate file and then include them into the bootstrap file.

Route::set() accepts 2 parameters. The first is the name of the route and the second is the URI pattern it should match. Because Route::set() returns an instance of Kohana_Route, we can chain the defaults method onto it. There we specify the controller and action that should be executed if the route is matched.

The section of the URI pattern is captured from the URI and automatically passed to the controller method as an argument.

Route::set('wiki-edit', 'wiki//edit')
	->defaults(array(
		'controller'=> 'wiki',
		'action'	=> 'edit_page',
	));

Route::set('wiki-save', 'wiki//save')
	->defaults(array(
		'controller'=> 'wiki',
		'action'	=> 'save_page',
	));

Route::set('wiki-page', 'wiki/')
	->defaults(array(
		'controller'=> 'wiki',
		'action'	=> 'view_page',
	));

Route::set('default', 'wiki')
	->defaults(array(
		'controller' => 'wiki',
		'action'     => 'view_page',
		'id'		 => 'index',
	));

Views

Read this tutorial on generating domain-independent, non hardcoded URLs

application/views/single.php


	
		<?php echo $page; ?>
	

	

		
		
			
		
		
		
			Edit

application/views/create.php


	
		<?php echo $page; ?> - Create
	

	

		
		This page does not exist. Create?

application/views/edit.php


	
		<?php echo $page; ?> - Edit
	

	

		 - Edit
		
			


				<?php echo $content; ?>

Controller

The wiki only has one controller, Controller_Wiki, located in application/classes/controller/wiki.php. All of the methods accept one parameter, the name of the page which is automatically passed by the URL Router.

The action_view_page() method will display the wiki page if it exists or a ‘create’ page if it does not exist. $single->loaded() will return true if the ORM returned a result, so if the page exists we load the ‘single’ view and attach the appropriate variables to the view, if it does not exist then we load the ‘create’ view.

public function action_view_page($page)
{

	$single = ORM::factory('page')
			->where('title', '=', $page)
			->find();

	if($single->loaded())
	{
		$v = View::factory('single');
		$v->page = $page;
		$v->content = $single->content;
				}
	else
	{
		$v = View::factory('create');
		$v->page = $page;
	}

	$this->response->body($v);

}

action_edit_page() returns the ‘edit’ page with the correct content field.

public function action_edit_page($page)
{
	$single = ORM::factory('page')
			->where('title', '=', $page)
			->find();

	if($single->loaded())
	{
		$content = $single->content;
	}
	else
	{
		$content = '';
	}

	$v = View::factory('edit');
	$v->page = $page;
	$v->content = $content;

	$this->response->body($v);
}

action_save_page() handles saving the page after the user submits the edit form. It first checks to see if the page exists. If it does exist then we update the content attribute of the model with whatever was posted in the form. If it doesn’t exist then we make a new page by instantiating a new model, assigning the title and content attributes and saving it.

public function action_save_page($page)
{
	$single = ORM::factory('page')
			->where('title', '=', $page)
			->find();

	$content = $this->request->post('content');

	if($single->loaded())
	{
		$single->content = $content;
		$single->save();
	}
	else
	{
		$new_single = new Model_Page();
		$new_single->title = $page;
		$new_single->content = $content;
		$new_single->save();
	}

	$this->request->redirect('http://127.0.0.1/query7kwiki/index.php/wiki/' . $page);

}

Full source code of the application is available on Github.

Tutorial Django Dojo DataGrid

logan — Mon, 18 Apr 2011 10:03:57 +0000

Dojo is an open source Javascript toolkit. It provides an easy way to access and modify the DOM as well as a rich user interface widget library. One of the most powerful widgets in the Dojo toolkit is DataGrid. It provides an easy way to represent what is essentially a cross between a spreadsheet and a table. In a recent Django project I needed to output the contents of a model into the DataGrid. Thanks to django-dojoserializer this is very easy.

Setup

We need the Python package django-dojoserializer. This can be installed by downloading the source and running

python setup.py install

or with setuptools using

easy_install django-dojoserializer

or with pip using

pip install django-dojoserializer

Then add django-dojoserializer to the INSTALLED_APPS tuple in settings.py.

Dojo will need to be linked correctly in the Django template. We need to require the dojox.grid.DataGrid and dojo.data.ItemFileReadStore classes.

Django Model

PROXY_TYPE_CHOICES = (

	('SOCKS4', 'SOCKS4'),
	('SOCKS5', 'SOCKS5'),
	('HTTP', 'HTTP'),

)

class Proxy(models.Model):
	ip = models.CharField(max_length=50)
	type = models.CharField(max_length=6, choices=PROXY_TYPE_CHOICES)
	alive = models.BooleanField(default=False)
	added = models.DateTimeField(auto_now=False, auto_now_add=True)
	last_checked = models.DateTimeField(auto_now=True, auto_now_add=False)

	def __unicode__(self):
		return self.ip

Django View

The view needs to display data from our model as JSON which is correctly formatted for the Dojo DataTable. Simply encoding the Django queryset as a JSON object would not work. Thankfully django-dojoserializer provides the dojoserializer.serialize() method which correctly formats our the queryset in a format the DataTable can read. The route /render/proxies maps to the following view:

from django.http import HttpResponse
from proxies.models import Proxy
from dojoserializer import serialize

def render_json(request):

	proxies = Proxy.objects.filter(alive=True)

	json_data = serialize(proxies)

	return HttpResponse(json_data, mimetype="application/json")

This gives the following output:

Defining the DataTable

We define the Dojo DataTable in two parts. The first is a Javascript representation of the structure of the DataTable, the second part is a

for where the DataTable will sit in markup. Note that each field attribute is the exact name of the corresponding field from the Django model. If the names do match the data will not display in the table.

var layoutProxies = [
            [{
                field: "ip",
                name: "IP",
                width: 'auto'
            },
            {
                field: "type",
                name: "Type",
                width: 'auto'
            },
            {
                field: "last_checked",
                name: "Last Checked",
                width: 10
            },
            {
                field: "alive",
                name: "Alive",
                width: 'auto'
            }

            ]];

Note the structure attribute of the div is set to the value of our structure. We will define proxyStore, the value of the store attribute below.

Connecting the DataTable to The Proxy Data

Finally we need to specify the proxyStore variable for the table to pull its data from. proxyStore is an instance of dojo.data.ItemFileReadStore(). We pass the URL of our JSON file and set urlPreventCache to true.

proxyStore = new dojo.data.ItemFileReadStore({url: '/render/proxies', urlPreventCache: true});

Which gives the final product:

Using Celery with Django

logan — Mon, 04 Apr 2011 07:38:53 +0000

Introduction

In a recent Django project I needed to issue some HTTP requests to a website, save the results and then display the information to the user. I could have issued those HTTP requests in a Django view, however the requests could take up to 10 seconds to return, and I didn’t want the page hanging that long for the user. I ended up using Celery, an asynchronous task queue written in Python, to execute the requests.

Installation

Celery
Celery is in pypi so installation is simple.

easy_install celery

pip install celery

Or download the source code, extract it and

python setup.py install

Django + Celery
In a high traffic production environment Celery should be paired with the RabbitMQ backend. However for my low traffic application I went with the django-kombu backend. django-kombu uses the Django database as a message store and requires very little configuration compared to other backends. We also need the djcelery package.

easy_install django-kombu

easy_install django-celery

Configuration

Before we can start using Celery we need configure our Django project. In settings.py make sure you add djkombu and djcelery to the INSTALLED_APPS tuple. Also make sure your database is configured and working.

Also add the following lines to settings.py.

import djcelery
djcelery.setup_loader()

BROKER_BACKEND = "djkombu.transport.DatabaseTransport"
#celery
BROKER_HOST = "localhost"
BROKER_PORT = 5672
BROKER_USER = "guest"
BROKER_PASSWORD = "guest"
BROKER_VHOST = "/"

Defining Tasks

All Celery tasks should be defined in PROJECT/APPNAME/tasks.py. You can define your tasks as methods with a Celery decorator, or as classes which inherit from a base Celery Task class. I prefer the class definitions. Each task must define a run method (which is called when the task is executed). Finally, each task must be registered with Celery so that they can be found. Below is a modified version of one of my Tasks.

import pycurl
from celery.task import Task
from celery.registry import tasks
from website.models import Website

class CheckWebsiteTask(Task):

	def run(self, ip, **kwargs):

		p, created = Website.objects.get_or_create(ip=ip)

		try:
			c = pycurl.Curl()
			c.setopt(pycurl.URL, ip)
			c.setopt(pycurl.TIMEOUT, 10)

			c.perform()

			p.alive = True

		except Exception, e:
			print e
			p.alive = False

		p.save()

tasks.register(CheckWebsiteTask)

Calling Tasks

Typically you will want to call your tasks somewhere in your view code. Just import your task and call it’s delay method, passing in the arguments that you specified in the run method of your task. The task will then be added to the queue within 5 or 10 seconds and the queue will then start to clear itself.

from django.http import HttpResponseRedirect

from website.tasks import CheckWebsiteTask
from website.models import Website

def check(request,id):

	website = Website.objects.get(id=id)

	CheckWebsiteTask.delay(website.ip)

	return HttpResponseRedirect('/')

Starting Celery

python manage.py celeryd -l info --settings=settings

Celery In The Real World

If you want to learn more about Celery then I recommend you read up on the various articles and tutorials on the Celery website. There is a list of Django apps that use Celery in one way or another, you may be able to use some of these in your own applications. Finally you can browse the source code of celery and django-celery on github to learn how they work under the hood.

NodeJS cURL Tutorial

logan — Mon, 28 Mar 2011 01:34:25 +0000

NodeJS is a powerful evented Javascript platform running on top of Google’s V8 javascript engine. Over the last year the popularity of NodeJS has increased greatly, as shown by the number of discussions on programming forums such as Hacker News, Reddit and Stackoverflow. Despite this NodeJS is still young and it falls short to Python and Ruby when it comes to the number and range of libraries and modules available.

The Problem

I wanted to convert one of my web scraping applications I made in PHP to NodeJS. The application interacts with SOCKS4 and SOCKS5 proxies using PHP’s cURL bindings. Unfortunately there are no cURL bindings (or SOCKS protocol wrappers) written for NodeJS. NodeJS does come with an HTTP client module that can issue web requests, however it doesn’t support SOCKS proxies.

The Solution

Although there are no specific NodeJS bindings for cURL, we can still issue cURL requests via the command line interface. NodeJS comes with the child_process module which easily allows us to start processes and read their output. Doing so is fairly straight forward. We just need to import the exec method from the child_process module and call it. The first parameter is the command we want to execute and the second is a callback function that accepts error, stdout, stderr.

The Code

var util = require('util');
var exec = require('child_process').exec;

var command = 'curl -sL -w "%{http_code} %{time_total}\\n" "http://query7.com" -o /dev/null'

child = exec(command, function(error, stdout, stderr){

	console.log('stdout: ' + stdout);
	console.log('stderr: ' + stderr);

	if(error !== null)
	{
		console.log('exec error: ' + error);
	}

});

This returns the HTTP code and time it took for the request to be issued:

stdout: 200 0.710

Conclusion

Although NodeJS is still young and bindings haven’t been made for alot of C libraries, the code above shows how you can still interact with the functionality they provide. That being said, the number of NodeJS modules is growing weekly. Be sure to keep an eye on the module wiki and npm registry for a list of modules.

Titanium Mobile Android Development: Soundboard App

logan — Mon, 07 Mar 2011 07:43:25 +0000

In this series of tutorials we use Appcelerator’s Titanium Mobile platform to create Android applications. This tutorial walks you through developing and packaging a soundboard application. Full source and packaged application is available on github.

The Application

A soundboard application lists and plays quotes from movies, games or people. Our soundboard will play quotes from the Zealot, Immortal and Stalker units from Starcraft2.

Clicking a unit name takes the user to a page where all of the unit’s quotes are shown.

Clicking a quote on the unit page plays the .mp3 file of the quote.

Directory Structure

The User Interface

The user interface is made up of several instances of the Titanium view elements Window and TableView. The home screen lists the names of different units that can play sounds. When the unit name is clicked we create a new instance of Window which is then populated with the appropriate view (If the user clicked on Immortal then the new window would load v/immortal.js).

UI code of app.js

var data = [

	{title: 'Immortal', view: 'v/immortal.js'},
	{title: 'Stalker', view: 'v/stalker.js'},
	{title: 'Zealot', view: 'v/zealot.js'},

];

var window = Titanium.UI.createWindow({

	title: 'Query7 SC2 Soundboard',
	backgroundColor:'#000',
	exitOnClose: true,

});

var tableView = Titanium.UI.createTableView({
	data: data,
	headerTitle: 'Query7 SC2 SoundBoard',
	});

window.add(tableView);
win.open();

Click Events

When the name of a unit is clicked, we want to open a new Titanium Window View and populate it with a TableView that shows the quotes from the appropriate unit. In the code below we listen for click events on the main TableView. If a row is clicked, then we open a new Window and pass the url parameter. This will set the contents of the new Window to whatever is in the source of the passed argument. In this case we specified in the array data an attribute called view which holds the path to the javascript file for each individual unit.

Event code of app.js

tableView.addEventListener('click', function(e)
{

	var win = Titanium.UI.createWindow({
		url: e.rowData.view,
		title: e.rowData.title,
		navBarHidden: true,
		exitOnClose: false,
	});

	win.open();

});

Individual Unit Pages

Each unit will have it’s own view script located in the v (for view) directory. Each script contains a definition of the TableView that shows the quotes the units can say.
UI code of v/immortal.js

var win = Titanium.UI.currentWindow;

var data = [

	{title: 'For the ancients', file: 'sound_immortal_atk_1.mp3'},
	{title: 'The cycle is unchanging', file: 'sound_immortal_death_1.mp3'},
	{title: 'The enemy closes', file: 'sound_immortal_help_1.mp3'},
	{title: 'I return to serve', file: 'sound_immortal_ready_1.mp3'},
	{title: 'The battle is ours', file: 'sound_immortal_victory_2.mp3'},
	{title: 'Our cannons shall sing', file: 'sound_immortal_yesg1.mp3'},

];

var tableView = Titanium.UI.createTableView({

	data: data,
	headerTitle: 'Immortal',

});

win.add(tableView);

Playing Music

Whenever an item on an Individual Unit Page is clicked we want to play the appropriate sound file. We store the location of the mp3 file in the data array.

tableView.addEventListener('click', function (e){

	var sound = Titanium.Media.createSound();

	sound.url = '../mp3/' + e.rowData.file;

	sound.play();

});

Packaging

Now all we need to do is package our application into a .apk file so that it can be distributed among Android devices. We need to generate a key to sign our Android app. Run the command below in the MSDOS prompt. You will be asked some additional information such as your name or country. None of it is really important unless you intend to put this app on the Android Market. Remember the KEYALIASNAME and password you set as Titanium requires you enter them.

keytool -genkey -v -keystore KEYSTORENAME -alias KEYALIASNAME -keyalg RSA -validity 11000

After clicking package Titanium will compile your app into .apk format. From there you can put it on your phone’s SD card and install it. If you intend to publish an app you create onto the Android Market then be sure to give this and this a good read.

If you have any comments, questions or requests for tutorials, please ask below.

Titanium Mobile Android Development: First Application

logan — Mon, 28 Feb 2011 08:35:39 +0000

In this series of tutorials we use Appcelerator’s Titanium Mobile platform to create Android applications. This tutorial walks you through developing and packaging your first Titanium application. Full source and packaged application is available on github.

The Application

The application itself is fairly basic but incorporates many techniques that you may need to use in your own apps. It fetches the latest 10 items off the Query7.com RSS feed and displays them in a TableView. If you click on one of the items Android will open the link in a web browser (Internet, Opera Mini, Firefox etc, whatever your default Android browser is).

The User Interface

The user interface has two Titanium view elements – a Window and a TableView. After creating both views we need to call the add method on the instance of Window to ensure the TableView shows on the page. Doing so is fairly straight forward:

Titanium.UI.setBackgroundColor('#000');

var win = Titanium.UI.createWindow({
    title:'Query7 RSS Feed',
    backgroundColor:'#000'
});

var data = [];

var tableview = Titanium.UI.createTableView({
	data:data,
	headerTitle: 'Query7 RSS',
	backgroundColor:'#000'
});

win.add(tableview);
win.open();

HTTP Requests

The next step is to retrieve the RSS feed from the Query7 blog. Titanium has a very nice HTTPClient object that allows us to perform requests similar to the way we would using Ajax/JS in the web browser. We specify an onload method that handles the response of the request and an open method in which we specify the type of request (GET/POST/PUT/DELETE) and the URL we are requesting. Finally we initiate the request by calling the send method.

var xhr = Titanium.Network.createHTTPClient();

xhr.onload = function()
{

	try
	{
		// manipulate response data here

	}
	catch(E)
	{
		alert(E);
	}

};

xhr.open('GET', 'http://feeds.feedburner.com/query7blog.rss');
xhr.send();

Parsing XML using Titanium

Even though we are coding in Javascript, we are not in a web browser environment, so the usual document and window objects do not exist. This means frameworks which make XML manipulation easy, such as jQuery and Mootools, will not work. Luckily Titanium offers us the DOMDocument object, which acts and has a similar API to the web browser document object.

In the code below we can get the output of the HTTP request and automatically turn it into a DOMDocument object by accessing it as this.responseXML.documentElement. If you just wanted to get the output as plain text, you would access it by this.responseText. Now that the DOMDocument instance is set up, we do a simple XPath query to get the title and iterate over the items to get the data about the individual posts.

// manipulate response data here

var doc = this.responseXML.documentElement;
var items = doc.getElementsByTagName('item');
var doctitle = doc.evaluate("//channel/title/text()").item(0).nodeValue;

var urls = new Array();

for(var c=0; c>items.length;c++)
{

	urls[c] = items.item(c).getElementsByTagName('link').item(0).text;

	postName = items.item(c).getElementsByTagName('title').item(0).text;
	postUrl = items.item(c).getElementsByTagName('link').item(0).text;

}

Populating the TableView

Now that we have the data from the RSS feed we can populate the TableView. To do this we create several Titanium.UI.TableViewRow objects and then append them to our TableView.

row = Titanium.UI.createTableViewRow({
			title: postName,
			backgroundColor:'#000',
			color: '#FF0'
		});

tableview.appendRow(row);

Click events, Intents

Now that we have data in the TableView we want to add functionality so that when an item in the TableView is clicked, the Android web browser will open to that specific post. Our code needs to listen for a click event on a TableViewRow and then launch a Titanium.Android.Intent.

row.addEventListener('click', function (e){

	var intent = Titanium.Android.createIntent({

			action: Titanium.Android.ACTION_VIEW,
			data: urls[e.index],

		});

	intent.addCategory(Titanium.Android.CATEGORY_BROWSABLE);
	Ti.Android.currentActivity.startActivity(intent);

});

Packaging

keytool -genkey -v -keystore KEYSTORENAME -alias KEYALIASNAME -keyalg RSA -validity 11000

And thats it, your first Android application is now complete. Next week we will look at creating a Soundboard application using Titanium Mobile. As always if you have any comments, questions or requests for tutorials, please ask below.

Using Proxies with cURL in PHP

logan — Sun, 13 Feb 2011 21:30:21 +0000

If you are new to using PHP and cURL please refer to the PHP cURL tutorial. It covers why you should using cURL (as opposed to file_get_contents) and goes over how to make cURL requests with a custom class.

This tutorial will cover how to use different types of proxies – SOCKS4, SOCKS5 and HTTP with cURL.

Basic cURL Request

We’ll start by creating a simple cURL script that requests the web page checkip.dyndns.org and displays the result on the screen. The website just displays our current IP address, this is useful when working with proxies. Below is our very basic cURL request.

$url = 'http://checkip.dyndns.org/';

$c = curl_init($url);

curl_setopt($c, CURLOPT_RETURNTRANSFER, true);

$result = curl_exec($c);

echo '';
var_dump($result);
echo '';

curl_close($c);

As we can expect, the output will be your IP address.

202.183.56.21

Using Proxies with cURL

To use proxies with cURL we need to set 2 additional cURL options: CURLOPT_PROXYTYPE and CURLOPT_PROXY. CURLOPT_PROXYTYPE should be set to either CURLPROXY_SOCKS5 or CURLPROXY_SOCKS4, depending on the type of proxy you are using. CURLOPT_PROXY should be set to the IP address and port of the proxy you are using.

If you are using an HTTP proxy then you only need to set CURLOPT_PROXY to your proxy. CURLOPT_PROXYTYPE automatically defaults to CURLPROXY_HTTP.

As you can expect, the following script displays the IP address of the proxy.

$url = 'http://checkip.dyndns.org/';

$c = curl_init($url);

curl_setopt($c, CURLOPT_RETURNTRANSFER, true);
curl_setopt($c, CURLOPT_PROXYTYPE, CURLPROXY_SOCKS5);
curl_setopt($c, CURLOPT_PROXY, '68.119.83.81:27977');

$result = curl_exec($c);

echo '';
var_dump($result);
echo '';

curl_close($c);

Note: You’ll need to use your own proxy. The one supplied is made up.

Interacting with Skype from Python using Skype4Py

logan — Mon, 03 Jan 2011 09:10:23 +0000

Skype4Py is a Python module that allows developers to programatically interact with the Skype client running on their computer. In this tutorial we will look at and use the Skype4Py module to create simple but useful scripts.

Installation

Skype4Py is a normal Python module and is listed in the Python package index (Pypi). To install it with setuptools enter the following in a command prompt.

easy_install Skype4Py

To install it with pip enter the following in a command prompt.

pip install Skype4Py

Getting Started

Skype4Py interacts with the Skype client running on your desktop, it doesn’t talk directly to the Skype servers. For any of the scripts we cover in this tutorial to work the Skype application must be running and you need to be logged in. You can either start Skype yourself or use the following snippet to start it using Skype4Py.

s = Skype4Py.Skype()

if not s.Client.IsRunning:
	s.Client.Start()

Before we can interact with the Skype client from Skype2Py, we need to connect Skype4Py to the instance of Skype running on your desktop. This is done using the Attach method.

import Skype4Py

s = Skype4Py.Skype()
s.Attach()

After executing this you need to check the Skype client on your desktop. A notification similar to the one below will appear. This ensures that no virus or 3rd party program can use your Skype account without your knowledge. Click ‘Allow access’.

User Information

Skype4Py provides a User class which represents a user’s Skype account. We can access information such as the user’s full name, their Skype status and when they were last logged into Skype. To get the person who is currently logged into the Skype client’s information we need to use the CurrentUser class.

import Skype4Py
s = Skype4Py.Skype()
s.Attach()

print 'Full Name: %s' % s.CurrentUser.FullName
print 'Skype Status: %s' % s.CurrentUser.OnlineStatus
print 'Country: %s' % s.CurrentUser.Country

To access information about the current Skype user’s friends, we need to use the Friends class. The snippet below iterates over all of the current Skype user’s friends and prints some information about them.

import Skype4Py
s = Skype4Py.Skype()
s.Attach()

for f in s.Friends:
	print 'Full Name: %s' % f.FullName
	print 'Skype Status: %s' % f.OnlineStatus
	print 'Country: %s' % f.Country

Sending SMS Messages

Skype4Py can also be used to send SMS messages. Only Skype users who have credit in their Skype account can send SMS. Be sure to check local SMS rates on the Skype website before using and never put this code in a loop without double checking it first. Make sure you include your country’s international prefix at the beginning of the number variable. After using this code my phone received the SMS 20 seconds later (NZ carrier).

import Skype4Py
s = Skype4Py.Skype()
s.Attach()

message = 'Hello SMS from Query7'
number = '+641234567890' 

m = s.CreateSms(Skype4Py.smsMessageTypeOutgoing, number)
m.Body = message

m.Send()

What Else Can Skype4Py Do?

Writing a module for Kohana3

logan — Mon, 20 Dec 2010 20:43:54 +0000

In this tutorial we will cover how to build a module from scratch in Kohana 3. If you aren’t familiar with the Kohana framework then I recommend you read the beginners introduction to Kohana.

The Plan

We will be building a module that replaces Kohana’s own view layer (Kohana_View). It will use the PHP template library Twig. We want our own view layer to be API compatible with Kohana’s view layer. This will ensure that other modules work out of the box and that the only code the developer will need to alter in their application are the templates (so that they are Twig compatible). No code in any controller will need to be modified.

Because Kohana follows HMVC (see beginners introduction to Kohana) we will be calling our class View. This means that all calls in the application to the class of View will be to the View class in our module, not Kohana’s own View class.

Directory Structure

Enabling The Module

The name of any Kohana module is the same name as the directory inside the modules directory. So in this case it is twig. To activate any module, we must add it to the array passed to Kohana::modules in application/bootstrap.php.

application/bootstrap.php – line 88

Kohana::modules(array(
	'twig' => MODPATH.'twig',
	// 'auth'       => MODPATH.'auth',       // Basic authentication
	// 'cache'      => MODPATH.'cache',      // Caching with multiple backends
	// 'codebench'  => MODPATH.'codebench',  // Benchmarking tool
	// 'database'   => MODPATH.'database',   // Database access
	// 'image'      => MODPATH.'image',      // Image manipulation
	// 'orm'        => MODPATH.'orm',        // Object Relationship Mapping
	// 'oauth'      => MODPATH.'oauth',      // OAuth authentication
	// 'pagination' => MODPATH.'pagination', // Paging of results
	// 'unittest'   => MODPATH.'unittest',   // Unit testing
	// 'userguide'  => MODPATH.'userguide',  // User guide and API documentation
	));

Twig

We will be using Fabien Potencier’s Twig project as a replacement templating engine for Kohana. The Twig files themselves will be stored in modules/twig/Twig/. If you are familiar with git you could create a git submodule of Twig so you can update Twig independently from our twig Kohana module. However for the sake of this tutorial it is easier just to download the tarball and extract it.

Rather than including all Twig files explicitly (using include or require statements) we will use Twig’s own autoloader. We could call it either in application/bootstrap.php or modules/twig/init.php. Since the autoloader is specific to the twig module (and not to the application) it is better to put it in modules/twig/init.php. Every init.php file in every enabled module is called automatically every request by Kohana.

modules/twig/init.php

require 'Twig/Autoloader.php';

Twig_Autoloader::register();

Configuration

Each developer that uses our twig module will have a different template directory and will want to pass different options to the Twig library when it’s instantiated (such as whether Twig runs in debug mode). Rather than hard coding these options into our module (which would force every developer using it to alter module code) we can use Kohana’s configuration system.

Because the configuration for our module is application specific, create application/config/twig.php

application/config/twig.php

// http://www.twig-project.org/book/03-Twig-for-Developers

return array(

	//Edit these per app.
	'template_dir' => 'C:/wamp/www/kohanaresources/application/views/',
	'cache_dir' => 'C:/wamp/www/kohanaresources/application/cache/',

	//Set to false in production application
	'auto_reload' => true,
	'debug' => true,

	//Misc settings. Don't touch unless you know what your doing.
	'trim_blocks' => false,
	'charset' => 'utf8',
	'base_template_class' => 'Twig_Template',
	'strict_variables' => false,

);

To access these array parameters that the developer sets, its a simple matter of:

Kohana::config('twig.template_dir');

The View Class

modules/twig/classes/view.php is going to contain our class, View. It will handle the rendering of the template using Twig. As discussed above, we want our View class to have the same API as Kohana_View, so we will copy system/classes/kohana/view.php and make a small alteration to it. Most of the methods in Kohana_View provide different ways to set variables to the instance of Kohana_View. For example all three of these essentially do the same thing:

$v = new View('some/template');

$v->website = 'Query7';
$v->set('website', 'Query7');
$v->bind('website', 'Query7');

All loading and parsing of the template file is done in View::capture(). This is the only method from the original Kohana_View class that we will need to alter. Here is our new method in full:

modules/twig/classes/view.php – View::capture

protected static function capture($kohana_view_filename, array $kohana_view_data)
{
	if (isset(View::$_global_data))
	{
		$data = array_merge($kohana_view_data, View::$_global_data);
	}
	else
	{
		$data = $kohana_view_data;
	}

	$loader = new Twig_Loader_Filesystem(Kohana::config('twig.template_dir'));

	$twig = new Twig_Environment($loader, array(

		'cache' => Kohana::config('twig.cache_dir'),
		'debug' => Kohana::config('twig.debug'),

		'auto_reload' => Kohana::config('twig.auto_reload'),
		'trim_blocks' => Kohana::config('twig.trim_blocks'),
		'charset' => Kohana::config('twig.charset'),
		'base_template_class' => Kohana::config('twig.base_template_class'),
		'strict_variables' => Kohan::config('twig.strict_variables')
	));

	$template = $twig->loadTemplate($kohana_view_filename);

	return $template->render($data);
}

Our function first combines all data to be passed to the template in a single array, $data. It then instantiates Twig_Loader_Filesystem and passes the location of the template directory to it. Twig_Enviroment is then instantiated and the different configuration options are passed there. Finally the template is loaded and rendered.

Example of twig in use

some method in a controller

$v = new View('colors.html');

$v->colors = array('red','blue','yellow','purple');

$this->request->response = $v->render();

colors.html

{% for c in colors %}
    {{ c }},
{% endfor %}

output

red,blue,yellow,purple,

Finishing Up

After you have finished any Kohana module you should write the necessary documentation and tests. Kohana has it’s own module that integrates PHPUnit with the Kohana framework. The majority of Kohana modules are open source on Github, with repositories named kohana-*modulename*. Finally you will want to promote your module. Announcing it on the Kohana forum and on Twitter are good ways to get it some attention.

If you have any questions or feedback please leave them in the comments below.