1. We split all words to syllables. Pinyin notation is made to avoid confusion, for example, you must use an apostrophe to separate the syllables if confusion is possible, for instance “Tian’anmen” is spelled definitely as “Tian an men”, not “Ti an an men”. With digits it’s even more simple, it’s “Tian1an1men2″, no confusion is possible unless there is a light tone inside but i can’t think of an example. Anyway you can use an apostrophe in this case as well.
2. The diacritic mark appears on one of the syllable’s vowels. How to decide which one is that?
   1. If there is “a” or “e”, it takes the mark
   2. If there is “ou”, then “o” takes the mark
   3. In all other cases, the last vowel takes it.
3. There is an ü letter which is represented by “v” when typing pinyin, because it’s the only letter which is not used by it.

Ok, now the code. It transforms everything which is inside [pinyin][/pinyin] block into the great looking pinyin.

function transform_pinyin_tones($content)
{
    if(!preg_match_all('`\[pinyin\](.*)\[/pinyin\]`Uis', $content, $r)) return $content;

    $tones = array(
    'a1' => '257',
    'a2' => '225',
    'a3' => '462',
    'a4' => '224',
    'e1' => '275',
    'e2' => '233',
    'e3' => '283',
    'e4' => '232',
    'i1' => '299',
    'i2' => '237',
    'i3' => '464',
    'i4' => '236',
    'o1' => '333',
    'o2' => '243',
    'o3' => '466',
    'o4' => '242',
    'u1' => '363',
    'u2' => '250',
    'u3' => '468',
    'u4' => '249',
    'v1' => '470',
    'v2' => '472',
    'v3' => '474',
    'v4' => '476'
    );

    $vowels = array('a', 'e', 'i', 'o', 'u', 'v');

    foreach($r[0] as $i => $match)
    {
        $digital = $r[1][$i];
        $diacritic = $digital;
        if(!preg_match_all('`([a-z]{1,6})([1-4])`is', $digital, $syllables)) continue;
        foreach($syllables[0] as $k => $syllable)
        {
            $s = $syllables[1][$k];
            $t = $syllables[2][$k];
            if(preg_match('`(a|e)`i', $s, $r2))
            {
                $s = preg_replace('`'.$r2[1].'`i', '&#'.$tones[strtolower($r2[1]).$t].';', $s);
            }
            elseif(preg_match('`ou`', $s, $r2))
            {
                $s = preg_replace('`ou`i', '&#'.$tones['o'.$t].';u', $s);
            }
            else
            {
                for($j=strlen($s)-1;$j;$j--)
                {
                    if(in_array($s[$j], $vowels))
                    {
                        $s = str_replace($s[$j], '&#'.$tones[$s[$j].$t].';', $s);
                        break;
                    }

                }
            }

            $diacritic = str_replace($syllable, $s, $diacritic);
        }

        $content = str_replace($match, $diacritic, $content);
    }
    return $content;
}

<ns1:accountID>1234567890</ns1:accountID>
<ns1:includeDeleted>false</ns1:includeDeleted>

it passes by, but if you pass them like:

<ns1:includeDeleted>false</ns1:includeDeleted>
<ns1:accountID>1234567890</ns1:accountID>

it doesn’t work. It doesn’t look reasonable (why do we name parameters in this case, for God’s sake!) but it makes using SOAPpy in its present form not possible, and here’s the reason. In SOAPpy, you pass parameters to function in natural Python way and they are processed using **kwargs and so on. But in this case you can’t be sure about the order they will go in final request. **kwargs is a dictionary. So, to be sure, you must pass the parameters as a tuple for example.

Finally, when I was at the end of realizing why this code doesn’t work, my testing code looked like something semi-complete so I’ve left it that way and now I’m using it in my project. It’s not perfect but I’m happy with it at the moment because it works and doesn’t require my attention. Here’s the code (including some snippets to parse XML SOAP response):

import re
from datetime import datetime
from urllib2 import urlopen, Request, HTTPError, URLError
import xml.sax.handler

"""
    Yahoo Enterprise Web Services implementation, V5

    No SOAP bindings, SOAPpy is old and poorly documented, other bindings
    don't work from scratch.

"""

def xml2obj(src):
    """
    A simple function to converts XML data into native Python object.
    """

    non_id_char = re.compile('[^_0-9a-zA-Z]')
    def _name_mangle(name):
        return non_id_char.sub('_', name)

    class DataNode(object):
        def __init__(self):
            self._attrs = {}    # XML attributes and child elements
            self.data = None    # child text data
        def __len__(self):
            # treat single element as a list of 1
            return 1
        def __getitem__(self, key):
            if isinstance(key, basestring):
                return self._attrs.get(key,None)
            else:
                return [self][key]
        def __contains__(self, name):
            return self._attrs.has_key(name)
        def __nonzero__(self):
            return bool(self._attrs or self.data)
        def __getattr__(self, name):
            if name.startswith('__'):
                # need to do this for Python special methods???
                raise AttributeError(name)
            return self._attrs.get(name,None)
        def _add_xml_attr(self, name, value):
            if name == 'xsi_nil' and value == 'true':
                self.data = None
                return
            if name in self._attrs:
                # multiple attribute of the same name are represented by a list
                children = self._attrs[name]
                if not isinstance(children, list):
                    children = [children]
                    self._attrs[name] = children
                children.append(value)
            else:
                self._attrs[name] = value
        def __str__(self):
            return self.data or ''
        def __repr__(self):
            items = sorted(self._attrs.items())
            if self.data:
                items.append(('data', self.data))
            return u'{%s}' % ', '.join([u'%s:%s' % (k,repr(v)) for k,v in items])

    class TreeBuilder(xml.sax.handler.ContentHandler):
        def __init__(self):
            self.stack = []
            self.root = DataNode()
            self.current = self.root
            self.text_parts = []
        def startElement(self, name, attrs):
            self.stack.append((self.current, self.text_parts))
            self.current = DataNode()
            self.text_parts = []
            # xml attributes --> python attributes
            for k, v in attrs.items():
                self.current._add_xml_attr(_name_mangle(k), v)
        def endElement(self, name):
            text = ''.join(self.text_parts).strip()
            if text:
                self.current.data = text
            if self.current._attrs:
                obj = self.current
            else:
                # a text only node is simply represented by the string
                obj = text or ''
            self.current, self.text_parts = self.stack.pop()
            self.current._add_xml_attr(_name_mangle(name), obj)
        def characters(self, content):
            self.text_parts.append(content)

    builder = TreeBuilder()
    if isinstance(src,basestring):
        xml.sax.parseString(src, builder)
    else:
        xml.sax.parse(src, builder)
    return builder.root._attrs.values()[0]

class YahooEWS(object):

    VERSION = 'V5'
    LOCATION_ENDPOINT = 'https://marketing.ews.yahooapis.com/services'
    SERVICE_URL = None

    SERVICES = {
        'LocationService': ['getMasterAccountLocation'],
        'CampaignService': ['addCampaign', 'addCampaigns', 'deleteCampaign', 'deleteCampaigns', 'deleteGeographicLocationFromCampaign', 'getCampaign', 'getCampaignAdGroupCount', 'getCampaignKeywordCount', 'getCampaigns', 'getCampaignsByAccountID', 'getCampaignsByAccountIDByCampaignStatus', 'getGeographicLocationForCampaign', 'getMinBidForCampaignOptimizationGuidelines', 'getOptimizationGuidelinesForCampaign', 'getStatusForCampaign', 'getTargetingForCampaign', 'setCampaignOptimizationON', 'setGeographicLocationForCampaign', 'setOptimizationGuidelinesForCampaign', 'setTargetingForCampaign', 'updateCampaign', 'updateCampaigns', 'updateStatusForCampaign', 'updateStatusForCampaigns'],
        'AccountService': ['addAccount', 'addMoney', 'deleteBlockedDomainListForAccount', 'deleteContinentBlockListFromAccount', 'getAccount', 'getAccountBalance', 'getAccounts', 'getAccountStatus', 'getActiveCreditCard', 'getBlockedDomainListForAccount', 'getChargeAmount', 'getContinentBlockListForAccount', 'setActiveCreditCard', 'setBlockedDomainListForAccount', 'setChargeAmount', 'setContinentBlockListForAccount', 'updateAccount', 'updateStatusForAccount'],
        'AdGroupService': ['addAdGroup', 'addAdGroups', 'deleteAdGroup', 'deleteAdGroups', 'getAdGroup', 'getAdGroupAdCount', 'getAdGroupContentMatchMaxBid', 'getAdGroupExcludedWordsCount', 'getAdGroupKeywordCount', 'getAdGroups', 'getAdGroupsByCampaignID', 'getAdGroupsByCampaignIDByStatus', 'getAdGroupSponsoredSearchMaxBid', 'getContentMatchMinBidForAdGroupOptimizationGuidelines', 'getOptimizationGuidelinesForAdGroup', 'getSponsoredSearchMinBidForAdGroup', 'getSponsoredSearchMinBidForAdGroupOptimizationGuidelines', 'getSponsoredSearchMinBidForAdGroups', 'getStatusForAdGroup', 'moveAdGroup', 'setAdGroupContentMatchMaxBid', 'setAdGroupSponsoredSearchMaxBid', 'setOptimizationGuidelinesForAdGroup', 'updateAdGroup', 'updateAdGroups', 'updateStatusForAdGroup', 'updateStatusForAdGroups'],
        'AdService': ['addAd', 'addAds', 'deleteAd', 'deleteAds', 'getAd', 'getAds', 'getAdsByAdGroupByParticipatesInMarketplace', 'getAdsByAdGroupID', 'getAdsByAdGroupIDByEditorialStatus', 'getAdsByAdGroupIDByStatus', 'getEditorialReasonsForAd', 'getEditorialReasonText', 'getReasonsForAdNotParticipatingInMarketplace', 'getStatusForAd', 'getUpdateForAd', 'setAdUrl', 'updateAd', 'updateAds', 'updateStatusForAd', 'updateStatusForAds'],
        'KeywordService': ['addKeyword', 'addKeywords', 'copyKeyword', 'deleteKeyword', 'deleteKeywords', 'getEditorialReasonsForKeyword', 'getEditorialReasonText', 'getKeyword', 'getKeywords', 'getKeywordsByAccountID', 'getKeywordsByAdGroupByParticipatesInMarketplace', 'getKeywordsByAdGroupBySponsoredSearchBidStatus', 'getKeywordsByAdGroupID', 'getKeywordsByAdGroupIDByEditorialStatus', 'getKeywordsByAdGroupIDByStatus', 'getKeywordSponsoredSearchMaxBid', 'getOptimizationGuidelinesForKeyword', 'getReasonsForKeywordNotParticipatingInMarketplace', 'getSponsoredSearchMinBidForKeywordOptimizationGuidelines', 'getSponsoredSearchMinBidForKeywordString', 'getSponsoredSearchMinBidForKeywordStrings', 'getSponsoredSearchMinBidUpdatesByAdGroupId', 'getStatusForKeyword', 'getUpdateForKeyword', 'moveKeyword', 'setKeywordUrl', 'setOptimizationGuidelinesForKeyword', 'updateKeyword', 'updateKeywords', 'updateSponsoredSearchMaxBidForKeyword', 'updateSponsoredSearchMaxBidForKeywords', 'updateStatusForKeyword', 'updateStatusForKeywords'],
    }

    def __init__(self, options):
        self.options = options

    def _service_url(self):
        if not self.SERVICE_URL is None:
            return self.SERVICE_URL

        self.SERVICE_URL = self.call('getMasterAccountLocation')
        return self.SERVICE_URL

    def _soap_header(self):
        res = ''
        for k in self.options.keys():
            res += '%s' % (k, self.options[k], k)
        res += ''
        return res

    def call(self, function, args=[], service=None):
        if service is None:
            service = self._service_lookup(function)

        post_data = '\r\n\
' % self.VERSION
        post_data += self._soap_header()
        post_data += ''
        else:
            post_data += '>'
            for arg in args:
                # False -> false
                value = arg[1]
                if value is False:
                    value = 'false'
                post_data += '%s' % (arg[0], value, arg[0])
            post_data += '' % function

        post_data += ''
        if service == 'LocationService':
            request_url = '%s/%s/LocationService' % (self.LOCATION_ENDPOINT, self.VERSION)
        else:
            request_url = '%s/%s/%s' % (self._service_url(), self.VERSION, service)

        req = Request(request_url, post_data)
        req.add_header('Content-type', 'text/xml; charset=utf-8')
        req.add_header('User-Agent', 'YWS SOAP')
        req.add_header('SOAPAction', '""')
        try:
            r = urlopen(req).read()
        except HTTPError, e:
            raise Exception, xml2obj(e.read())['soap_Body']['soap_Fault']['faultstring']
        except URLError, e:
            raise Exception, 'Error: ' % e.reason

        res = xml2obj(r)['soap_Body']['%sResponse' % function]['out']
        if not res.data is None:
            return res.data

        return res

    def _service_lookup(self, function):
        for service in self.SERVICES.keys():
            if function in self.SERVICES[service]:
                return service
        raise Exception, 'Unknown function, please use service argument to call()'

Usage example:

import sys
from misc.yahoo_ews import YahooEWS
options = {
    'username': 'user',
    'password': 'password',
    'masterAccountID': 'mymasteraccountid',
    'license': 'mylicensehere',
    'accountID': 'myaccountidhere'
}
yahoo = YahooEWS(options)

try:
    campaigns = yahoo.call(
        'getCampaignsByAccountID',
        [
         ('accountID', options['accountID']),
         ('includeDeleted', False)
        ])
    for c in campaigns.Campaign:
        print 'Campaign id: %s, name: %s' % (c.ID, c.name)
except:
    print sys.exc_info()

Chain length=3 (each word depends on 2 past words):

Mich, see how I dash about! For a while he had fixed them. He supervised pin the tail on the street below, outside this warm two-storey house, like so many serpentines thrown before her. Now, the parents. With laughing reluctance they slid down a slide which Mich had said eight years ago. He almost bent to take hold of Marion now, in her skull mask. He felt an inexplicable rush of pity for her, because she had watched her own party, like so many grey mice the children, like so many serpentines thrown before her. Now, the house was empty and silent in the autumn leaves before his granmother’s house many years ago and heard the bathroom door unlatch and she had produced a child in her own party, like so many grey mice the children, like so many leaves. By the sound of the child as an idea, completely asexual, an immaculate conception of contemptuous mind and cell. As a firm rebuke to him she had hurt him. It was quiet. Louise cried out, ‘Marion, Marion!’ ‘Turn on the lights,’ said one of

Length=2 (each word depends on previous one only):

‘Hush, you’ll spoil everything,’ some girl said. The room I’m in the house, four times around the rest, amid fits of the items. ‘Marion?’ asked Louise. ‘Are you afraid?’ Marion appeared in her disguise. ‘How do in winter he suspected that somehow he came after, smiling, ‘I can’t find her.’ Then …… some idiot turned on was her skull sockets small blue eyes and says, “This is dead,’ intoned the suddenly frozen task of table-section, into the last day he was a dark forcing murderer. It would be over! There was a child cried, ‘I’ll check the wild explosive in the furnace. The room he as he thought. With laughing down and picked her not a boy. ‘Come back, Helen!’ Shot from her, all the husband. ‘She’s not wear this game with white bone masks and says, “These are you invited people in, but she was talking. ‘Marion?’ asked Louise as much as he suspected that and the top it, on the bottom of October, with the last coming slowly had forced child. But when he came down. By the open. But when

As you can see, the longer the chain gets, the longer pieces of original text appear in the result.

The same approach can be applied not only to words, but to characters as well:

ceineatrs, inghs -s nowad Bushin acllaplkin long. id, worshe plkeng. cereil won hie thenorildiloorie ganing. ang I’ qut cthid Mar Moutorkerskise to theyotidinerkesk heseas smoullin blelo be t h heat eayis edin f tof ve uid h h. ist thes iso tuthe ofut ll, bume be cid this cesus congherid owintr apourowit t t Itid Ane cter alt Itowd glab thersthowaris ouedit, cs. acankngosefen the rors arsupis hatadeshead ce w, tlly pr hrit n’I siouldanots ithedeailoura d tce!’Nobe’Evesa hinoow-the Agalthescke”. pesed tabowippsched te!” add. ad t, agare. se Lower, ppeacr or m t s toucathe war. me rontar tongsen thelind ‘Qurofamp beliofe hoys he t h t. By. Loysey nehthton ake ad, othe he If s Anok ‘ bontath vedn dll ande m onoond on wioused ghelen sctut adaiowlllwe chanind hrnsil Thown. s obirknd ine teisiloug hind spthalarrchiron praye s. chas che asanaumm juruse wa opig. ar. ght che alinene faldie, Ee nyoind he. dle ‘Mall w, s. apirout t wis I’ chikie m t mig ha

And here’s the code. PHP first.

<?
    /*
     * class for Markov's chains realization
     * (c) Andrey, somemilk.org@gmail.com, 2006
     *
     * Typical usage:
     * $m = new Markov(2); // 2 - markov chain length, depends on source
     *                     // file size, 2 for small files, 3-4 for large ones
     * $m->initFromFile("somefile.txt") or die("shit happens.");
     * $bullshit = $m->generate(2000); // generates bullshit 2000 chars long.
     * $m->initFromString(file_get_contents("somefile.txt")) or die("shit happens.");
     * $bullshit = $m->generate(100, MARKOV_OPT_WORDS); // generates bullshit 100 words long.
     */

    define("MARKOV_OPT_CHARACTERS", 1); // option: character limit for generate()
    define("MARKOV_OPT_WORDS",      2); // option: word limit for generate()
    define("MARKOV_DEFAULT_K",      3); // default Markov chain length
    define("MARKOV_TIME_LIMIT",     120); // time limit for initFromFile()

    define("MARKOV_MAX_RECURSION_LEVEL",     20);

    class Markov
    {
        var $k = MARKOV_DEFAULT_K;
        var $k_sets = array();
        var $split_method = MARKOV_OPT_WORDS;

        function Markov($k, $split_method = MARKOV_OPT_WORDS)
        {
            $this->k = $k;
            $this->split_method = $split_method;
        }

        /*
         * inits class' Markov k-sets with a text from a text file.
         *
         * returns true on success, false on failure
         */
        function initFromFile($filename)
        {
            set_time_limit(MARKOV_TIME_LIMIT);

            if(!is_readable($filename)) return false;

            $fc = file_get_contents($filename);
            $this->initFromString($fc);

            return true;
        }

        /*
         * inits class' Markov k-sets with a text from a string.
         *
         * returns true on success, false on failure
         */
        function initFromString($str)
        {
            if(strlen($str) k) return false;
            $this->k_sets = array();
            $set = array();

            if($this->split_method == MARKOV_OPT_WORDS)
            {
                $words = preg_split('/\s+/', trim($str));
                if(count($words) k) return false;
                foreach($words as $w)
                {
                    $this->_addToSets($set, $w);
                }
            }
            else
            {
                for($i=0; $i_addToSets($set, substr($str, $i, 1));
                }
            }

            return true;
        }

        function _addToSets(&$set, $w)
        {
	        $set[] = $w;
            if(count($set) == $this->k)
            {
                $key = "";
                for($i=0; $ik - 1; $i++)
                {
                    $key .= "[\$set[$i]]";
                }
                eval("\$this->k_sets{$key}[] = \$set[$i];");
                array_shift($set);
            }
        }

        /*
         * you must re-init the class after calling setK()
         */
        function setK($k) { $this->k = $k; $this->k_sets = array(); }

        /*
         * generates random word $length characters long
         * (available only if split_method is MARKOV_OPT_CHARACTERS
         */
        function getWord($length)
        {
            if($this->split_method != MARKOV_OPT_CHARACTERS) return false;
            $res = "";
            $set = array();
            while(strlen($res) k)
                {
                    $word = array_shift($set);
                    if(preg_match('/[\s\.,:\?!;"]/', $word))
                    {
                        $res = "";
                        continue;
                    }

                    $res .= $word;
                }

                if(strlen($res) == $length) break;

                if(count($set)) $element =& $this->k_sets[$set[0]];
                else $element = null;
                foreach($set as $i => $word)
                {
                    if(isset($element[$word])) $element =& $element[$word];
                }
                if(is_array($element))
                {
                    $word = $this->random_key($element);
                    if(is_array($element[$word])) $set[] = $word;
                    else $set[] = $this->random_value($element);
                }
                else $set[] = $this->random_key($this->k_sets);

            }
            return $res;
        }

        /*
         * generates Markov's string, max $how_much long,
         * in words (if $how==MARKOV_OPT_WORDS)
         * or in characters (if $how==MARKOV_OPT_CHARACTERS, default)
         */
        function generate($how_much, $how=MARKOV_OPT_CHARACTERS, $sentences=false, $recursion_level=0)
        {
            $res = "";
            $n_words = 0;
            $set = array();
            $sentence_started = false;
            while(($how == MARKOV_OPT_CHARACTERS && (strlen($res) < $how_much)) ||
                  ($how == MARKOV_OPT_WORDS && ($n_words k)
                {
                    $res .= ($word = array_shift($set));
                    if($this->split_method == MARKOV_OPT_WORDS)
                    {
                        $res .= " ";
                        $n_words++;
                    }
                    elseif(preg_match('/[\s\.,:\?!;"]/', $word))
                    {
                        $n_words++;
                    }
                    if($sentences && !$sentence_started && preg_match('/\.$/', $word))
                    {
                        $sentence_started = true;
                        $res = "";
                        $n_words = 0;
                    }
                }

                if(count($set)) $element =& $this->k_sets[$set[0]];
                else $element = null;
                foreach($set as $i => $word)
                {
                    if(isset($element[$word])) $element =& $element[$word];
                }
                if(is_array($element))
                {
                    $word = $this->random_key($element);
                    if(is_array($element[$word])) $set[] = $word;
                    else $set[] = $this->random_value($element);
                }
                else $set[] = $this->random_key($this->k_sets);

            }
            $res = rtrim($res);
            if($sentences)
            {
                $res = preg_replace('/\.[^\.]+$/', '.', $res);
                if(!preg_match('/\.$/', $res) && ($recursion_level generate($how_much, $how, $sentences, $recursion_level+1));
            }
            return $res;
        }

        /*
         * helper function, returns random array key
         */
        function random_key(&$array)
        {
            $rand = mt_rand(0, count($array) - 1);
            $i = 0;
            foreach($array as $key => $value) if($i++ == $rand) return $key;
        }
        /*
         * helper function, returns random array value
         */
        function random_value(&$array)
        {
            $rand = mt_rand(0, count($array) - 1);
            $i = 0;
            foreach($array as $key => $value) if($i++ == $rand) return $value;
        }
    }
?>

Python code, not mine, for generating words. I use it on one of my projects for generating random nicknames.

#!/usr/bin/env python

from collections import defaultdict
from random import choice

class TextGenerator(object):

    def __init__(self):
        self._data = defaultdict(list)

    def train(self, file):
        words = [None, None]
        for line in open(file):
            for word in line.split():
                words[0], words[1] = words[1], word
                if words[0]:
                    self._data[words[0]].append(words[1])

    def gentext(self, num_words):
        text = []
        text.append(choice(self._data.keys()).title())
        while len(text) < num_words:
            if self._data.has_key(text[-1]):
                text.append(choice(self._data[text[-1]]))
            else:
                text.append(choice(self._data.keys()))
        return ' '.join(text) + '.'

if __name__ == '__main__':
    textgen = TextGenerator()
    textgen.train('pandp.txt')
    print textgen.gentext(100)

You can google for some more code snippets, that’s what I found for perl:

#!/usr/bin/perl
# by jackal
use strict;
my $filename = shift || 'data.txt';
my $MAXGEN = 10000;
my $NONWORD = "\n";
my $w1 = $NONWORD;
my %statetab;
my $fh;
open($fh, '<', $filename);
while () {
    foreach (split) {
        push(@{$statetab{$w1}}, $_);
        $w1 = $_;
    }
}
close($fh);
push(@{$statetab{$w1}}, $NONWORD);
$w1 = $NONWORD;
open($fh, '>', 'markoff.txt');
for (my $i=0; $i[$r]) eq $NONWORD);
    print $fh "$t ";
    $w1 = $t;
}
close($fh);

Further reading:

Wikipedia:
http://en.wikipedia.org/wiki/Markov_chain

Python code author’s site:
http://bitecode.co.uk/

or a polygon chart:

In this post I will describe how to draw a pretty smooth curve chart using python and cairo. You can adapt this routine to be used with django, pycha or any other image creation library, code snippets in comments are appreciated.

The main problem is, even if your image creation library has curve drawing functions (Bézier splines), those functions need some control points which DO NOT reside on the curve. So how do those points affect the curve? Let’s look at the example (it may seem complex, but it’s not, I just tried to make it more readable and easier to understand):

import cairo
from math import pi

def draw_point(x, y):
    cr.move_to(x + 2, y)
    cr.arc(x, y, 2, 0, 2 * pi)
    cr.set_source_rgba(0, 0, 0, 1)
    cr.stroke()

surface = cairo.ImageSurface(cairo.FORMAT_ARGB32, 100, 100)
cr = cairo.Context(surface)
cr.set_line_width(2)

x0, y0 = 5, 5 # starting point
x3, y3 = 95, 95 # end point

x1, y1 = 95, 5 # control point 1
x2, y2 = 5, 95 # control point 2

"""let's draw all the points to see everything clearly"""
draw_point(x0, y0)
draw_point(x1, y1)
draw_point(x2, y2)
draw_point(x3, y3)

"""the line from starting point to control point 1"""
cr.move_to(x0, y0)
cr.line_to(x1, y1)
cr.set_source_rgba(0, 0, 0, 0.1)
cr.stroke()

"""the line from starting point to control point 2"""
cr.move_to(x3, y3)
cr.line_to(x2, y2)
cr.set_source_rgba(0, 0, 0, 0.1)
cr.stroke()

"""the curve itself"""
cr.move_to(x0, y0)
cr.curve_to(x1, y1, x2, y2, x3, y3)
cr.set_line_width(5)
cr.set_source_rgba(0, 0, 1, 1)
cr.stroke()

surface.write_to_png('curve.png')

So we are going to draw a curve from upper left corner down to right lower, and control points are in upper right and down left respectively. That will look like this:

You can clearly see that the lines between control and starting and end points are tangents to the curve, and the farther the control point gets from the starting or end point, the more “curvy” it becomes:

And that leads us to an obvious solution. We need to connect each two points of the chart with curves, and the tangents in those points must be the same from both sides, otherwise the curve won’t be smooth. If we don’t look ahead and don’t look back on the curve, we must make those tangents horizontal. So the first control point will be a little on the left from the starting point and the second one little on the right from the ending point, but on the same vertical position. Here is the code with some debug functions letting us see the control points and tangents, we’ll comment them out later:

import cairo
from math import pi, sqrt

width = 500
height = 100
graph_data = [
(0, 10),(20, 50),(40, 80),(60, 5),(80, 10),(100, 20),
(120, 30),(140, 60),(160, 95),(180, 30),(200, 50),
(220, 70),(240, 80),(260, 10),(280, 60),(300, 30),
(320, 90),(340, 95),(360, 30),(380, 10),(400, 5),
(420, 20),(440, 80),(460, 70),(480, 20),(500, 40)
]

def prepare_curve_data(graph_data):
    prepared_data = []
    for i in range(0, len(graph_data)):
        x, y = graph_data[i][0], graph_data[i][1]
        if i == 0:
            cx1, cy1 = x, y
        else:
            step_x = x - graph_data[i - 1][0]
            cx1, cy1 = x - step_x/2, y

        if i == len(graph_data) - 1:
            cx2, cy2 = x, y
        else:
            step_x = graph_data[i + 1][0] - x
            cx2, cy2 = x + step_x/2, y

        prepared_data.append((x, y, cx1, cy1, cx2, cy2))

    return prepared_data

def draw_point(x, y, opacity):
    cr.move_to(x + 2, y)
    cr.arc(x, y, 2, 0, 2 * pi)
    cr.set_source_rgba(0, 0, 0, opacity)
    cr.stroke()

def debug_points(cr, prepared_data):
    for i in range(0, len(prepared_data)):
        x, y = prepared_data[i][0], prepared_data[i][1]
        cx1, cy1 = prepared_data[i][2], prepared_data[i][3]
        cx2, cy2 = prepared_data[i][4], prepared_data[i][5]

        draw_point(x, y, 1)
        if cx1 != x or cy1 != y:
            draw_point(cx1, cy1, 0.3)
            cr.move_to(x, y)
            cr.line_to(cx1, cy1)
            cr.set_source_rgba(0, 0, 0, 0.1)
            cr.stroke()

        if cx2 != x or cy2 != y:
            draw_point(cx2, cy2, 0.3)
            cr.move_to(x, y)
            cr.line_to(cx2, cy2)
            cr.set_source_rgba(0, 0, 0, 0.1)
            cr.stroke()

def poly_curve(cr, prepared_data):
    for i in range(0, len(prepared_data) - 1):
        x, y = prepared_data[i][0], prepared_data[i][1]
        cx1, cy1 = prepared_data[i][4], prepared_data[i][5]
        cx2, cy2 = prepared_data[i + 1][2], prepared_data[i + 1][3]
        x2, y2 = prepared_data[i + 1][0], prepared_data[i + 1][1]
        cr.move_to(x, y)
        cr.curve_to(cx1, cy1, cx2, cy2, x2, y2)

surface = cairo.ImageSurface(cairo.FORMAT_ARGB32, width, height)
cr = cairo.Context(surface)
cr.set_line_width(2)

prepared_data = prepare_curve_data(graph_data)
debug_points(cr, prepared_data)
poly_curve(cr, prepared_data)
cr.set_source_rgba(0, 0, 0, 1)
cr.stroke()

surface.write_to_png('curve.png')

And this is the result:

It is quite satisfactory, but it has some flaws. In the areas where the curve must go up or down steadily, we see some kind of bumps. It would be right to lean the tangents on those sections, so the control points would reside on the line parallel to the line connecting previous and next points. To make this more clear, I’ll rewrite the prepare_curve_data() and show you the result:

def prepare_curve_data(graph_data):
    prepared_data = []
    for i in range(0, len(graph_data)):
        x, y = graph_data[i][0], graph_data[i][1]

        if (i != 0) and (i != len(graph_data) - 1):
            x_left, y_left = graph_data[i - 1][0], graph_data[i - 1][1]
            x_right, y_right = graph_data[i + 1][0], graph_data[i + 1][1]
            step_x_left = (x - x_left) / 2
            step_x_right = (x_right - x) / 2
            dx, dy = x_right - x_left, y_right - y_left
            h = sqrt(dx*dx + dy*dy)
            if h == 0:
                cx1, cy1, cx2, cy2 = x, y, x, y
            else:
                dx1, dy1 = (dx * step_x_left) / h, (dy * step_x_left) / h
                dx2, dy2 = (dx * step_x_right) / h, (dy * step_x_right) / h
                cx1, cx2 = x - dx1, x + dx2
                cy1, cy2 = y - dy1, y + dy2
        else:
            cx1, cy1, cx2, cy2 = x, y, x, y

        prepared_data.append((x, y, cx1, cy1, cx2, cy2))

    return prepared_data

And finally: the snippet ready to be put in your code:

import cairo
from math import pi, sqrt

width = 500
height = 100
graph_data = [
(0, 10),(20, 50),(40, 80),(60, 5),(80, 10),(100, 20),
(120, 30),(140, 60),(160, 95),(180, 30),(200, 50),
(220, 70),(240, 80),(260, 10),(280, 60),(300, 30),
(320, 90),(340, 95),(360, 30),(380, 10),(400, 5),
(420, 20),(440, 80),(460, 70),(480, 20),(500, 40)
]

def poly_curve(cr, graph_data):
    prepared_data = []
    for i in range(0, len(graph_data)):
        x, y = graph_data[i][0], graph_data[i][1]

        if (i != 0) and (i != len(graph_data) - 1):
            x_left, y_left = graph_data[i - 1][0], graph_data[i - 1][1]
            x_right, y_right = graph_data[i + 1][0], graph_data[i + 1][1]
            step_x_left = (x - x_left) / 2
            step_x_right = (x_right - x) / 2
            dx, dy = x_right - x_left, y_right - y_left
            h = sqrt(dx*dx + dy*dy)
            if h == 0:
                cx1, cy1, cx2, cy2 = x, y, x, y
            else:
                dx1, dy1 = (dx * step_x_left) / h, (dy * step_x_left) / h
                dx2, dy2 = (dx * step_x_right) / h, (dy * step_x_right) / h
                cx1, cx2 = x - dx1, x + dx2
                cy1, cy2 = y - dy1, y + dy2
        else:
            cx1, cy1, cx2, cy2 = x, y, x, y

        prepared_data.append((x, y, cx1, cy1, cx2, cy2))

    for i in range(0, len(prepared_data) - 1):
        x, y = prepared_data[i][0], prepared_data[i][1]
        cx1, cy1 = prepared_data[i][4], prepared_data[i][5]
        cx2, cy2 = prepared_data[i + 1][2], prepared_data[i + 1][3]
        x2, y2 = prepared_data[i + 1][0], prepared_data[i + 1][1]
        cr.move_to(x, y)
        cr.curve_to(cx1, cy1, cx2, cy2, x2, y2)

surface = cairo.ImageSurface(cairo.FORMAT_ARGB32, width, height)
cr = cairo.Context(surface)
cr.set_line_width(2)
poly_curve(cr, graph_data)
cr.set_source_rgba(0, 0, 0, 1)
cr.stroke()

surface.write_to_png('curve.png')

And the result:

And now compare this to the polygon chart:

Neat, eh?

References and things to read:

Cairo — vector graphics library: http://cairographics.org/
Cairo for Python (pycairo): http://www.cairographics.org/pycairo/
Nice pycairo tutorial: http://www.tortall.net/mu/wiki/CairoTutorial