#!/usr/bin/env python
 
def get_palindromes(str):
	""" Return all palindromes in str of minimum size 3 """
	length = len(str) + 1
 
	found = []
	for i in xrange(0, length):
		for j in xrange(i+3, length):
				mid = i + ((j - i) / 2)
				if str[i:mid] == str[mid+1:j][::-1]: # In-efficient
					found.append(str[i:j])
	return found	
 
if __name__ == '__main__':
	print get_palindromes('efeababaf')

define('PRAVIN_THUMBNAIL_DIR', '/home/firedev/public_html/wp-content/cache/thumbnails/');
function pravin_resize($img_path, $width, $height) {
    $resolution = '"' . $width . 'x' . $height . '"';
    $output_path = PRAVIN_THUMBNAIL_DIR . md5($img_path) . "-$resolution.jpg";
    // If file does not exist OR the thumbnail was generated more than 
    // 5 mins (5 x 60 sec) then re-create the thumbnail
    if(!file_exists($output_path) || (time() - filemtime($output_path)) > (5 * 60)) {
        system("/usr/bin/convert -resize $resolution $img_path $output_path");
    }
    return $output_path;
}

#!/usr/bin/python
""" 
Script to generate URS from the starting paragraph of Wikipedia 
articles about persons.
 
by Pravin Paratey (pravinp -at- gmail.com)
 
Current Implementation:
----------------------
1. Extract first sentence
2. Clean wiki markup
3. Observing given data, and the data on wikipedia, shows that there 
   is a pattern that is followed while writing wikipedia entries for
   persons. Replacing (was/is)(an/a/the/) with (/the) does the trick
4. Output sentence formed
 
Ideally:
--------
Ideally, the piece of code should identify the following concepts:
1. Name of person
2. Time period
3. Son/Daughter/Father/Mother of (in case of famous personality)
4. Renowned for
 
How do we go about it?
1 and 2 - straight forward. Wikipedia gives cues through its markup
3 - straight forward. String matching using "son of", "daughter of", etc
4 - will need to match against a database.
 
For 3, we only keep the "son of", "daughter of", "X of Y" if Y is a prominent
person. An easy way of doing this is using incoming links on wikipedia OR
to search for X and Y individually on google and noting the number of results.
"""
 
import re, sys, codecs
 
def cleanUri(m):
    """ Cleans Uri wiki markup """
    word = m.group(1)
    if '|' in word: word = word.split('|')[1]
    return word.strip()
 
def dotRemove(m):
    """ Replaces . by # inside tags """
    return m.group(0).replace('.', '#')
 
def cleanMarkup(text):
    """ Removes
    1. wiki markup
    2. sanitize html entities 
    3. comments """
    #text = re.sub(r"\[\[[\w\s\-,]+\|(\w+)\]\]", r"\1", text)
    text = re.sub(r"\[\[(.*?)\]\]", cleanUri, text)
    text = re.sub(r"\{\{.*?\}\}", r"", text)
    text = re.sub(r"<ref>.*?<\/ref>", r"", text)
    text = re.sub(r"<!--.*?-->", r"", text)
    text = re.sub(r"\[.*?\]", r"", text)
    text = text.replace("'''", "").replace("''", "'")
    text = text.replace("[[", "").replace("]]", "")
    text = text.replace("&ndash;", "-").replace("&amp;", "&")
    return text
 
def getFirstSentence(text):
    """ Returns the text until first instance of '.'
    It also makes sure that the '.' isn't part of a wiki link
    or name"""
    tmp = re.sub(r"\[\[.*?\]\]", dotRemove, text)
    tmp = re.sub(r"\[.*?\]", dotRemove, tmp)
    tmp = re.sub(r"<ref>.*?<\/ref>", dotRemove, tmp)
    tmp = re.sub(r"<!--.*?-->", dotRemove, tmp)
    tmp = re.sub(r"'''.*?'''", dotRemove, tmp)
    tmp = re.sub(r"''.*?''", dotRemove, tmp)
    index = tmp.find('.')
 
    if index == -1: 
        return text
    else:
        return text[:index]
 
def makeArticle(m):
    """ Changes a, an to the when appropriate """
    retval = ', the'
    if len(m.group(2)) == 0:
        retval = ' '
    return retval
 
def extractURS(text):
    """ The function to call. Returns the URS """
    text = getFirstSentence(text)
    text = cleanMarkup(text)
    text = re.sub(r",?\s+(was|is)\s+(an|the|a|)", makeArticle, text)
    return text
 
if __name__ == '__main__':
    #fp = open(sys.argv[1])
    fp = codecs.open("input.txt", "r", "utf-8")
    fp2 = codecs.open("output.txt", "w", "utf-8")
    fp2.write(codecs.BOM_UTF8.decode("utf-8")), # Add BOM for UTF-8
    for line in fp:
        line = line.rstrip()
        if len(line) == 0 or line.startswith("#"): # For debugging
            continue
        urs = extractURS(line)
        fp2.write(urs + '\r\n')
    fp.close()
    fp2.close()

#!/usr/bin/python
import random
from time import time
 
def generateWord():
	char_array = 'abcdefghijklmnopqrstuvwxyz'
	random.seed(time())
	word = ''
	for i in range(0, 8): # 8 letter word
		word += char_array[random.randint(0, 25)]
	return word
 
if __name__ == '__main__':
	print generateWord()

import java.util.regex.Matcher;
import java.util.regex.Pattern;
 
 
public class Tester {
    public static void main(String args[]) 
    {
        Pattern pattern = Pattern.compile("name=\"QTime\">(\\d+)</int>");
        Matcher matcher = pattern.matcher("<response><lst name=\"responseHeader\">" + 
            "<int name=\"status\">0</int><int name=\"QTime\">2</int></lst></response>");
 
        try {
            if(matcher.find()) {
                System.out.println(matcher.group(1));
            }
        }
        catch (Exception e) {
            System.out.println("Couldn't find QTime");
        }
    }
}

#!/usr/bin/env python
# -*- coding: utf-8 -*-
# Simple WebServer Illustration
# Pravin Paratey (April 15, 2009) [pravinp at gmail dot com]
 
from BaseHTTPServer import BaseHTTPRequestHandler, HTTPServer
 
class MyHandler(BaseHTTPRequestHandler):
    binaryExtensions = ['.gif', '.png', '.jpg']
    contentTypes = {
        '.css': 'text/css',
        '.gif': 'image/gif',
        '.jpg': 'image/jpg',
        '.png': 'image/png',
        'html': 'text/html',
    }
 
    def do_GET(self):
        """ Implementing the GET method """
        try:
            if self.path == '/': self.path = '/index.html'
            mode = 'r'
            if self.path[-4:] in self.binaryExtensions: mode = 'rb'
            fp = open(self.path[1:], mode)
            data = fp.read()
            fp.close()
            # Send response
            self.send_response(200)
            self.send_header('Content-Type', self.__getContentType())
            self.send_header('Transfer-Encoding', 'chunked')
            self.end_headers()
            self.wfile.write(data)
        except IOError:
            self.send_error(404, "File not found: %s" % self.path)
 
    def __getContentType(self):
        """ Function to figure out content types """
        content_type = 'text/plain'
        extension = self.path[-4:]
        if extension in self.contentTypes:
            content_type = self.contentTypes[extension]            
        return content_type
 
if __name__ == '__main__':
    server = HTTPServer(('', 8000), MyHandler)
    server.serve_forever()

import java.io.File;
 
import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
 
import org.w3c.dom.Node;
import org.w3c.dom.NodeList;
 
 
public class Tester {
    public static void main(String args[]) 
    {
        DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
        factory.setNamespaceAware(false);
 
        try {
            DocumentBuilder builder = factory.newDocumentBuilder();
            org.w3c.dom.Document doc = builder.parse(new File(args[0]));
            NodeList nodes1 = doc.getChildNodes();
            for(int i=0; i<nodes1.getLength(); i++) {
                TreeWalk(nodes1.item(i), 0);
            }
        }
        catch(Exception e) {
            e.printStackTrace();
        }
    }
 
    private static void TreeWalk(Node n, int level) 
    {
        if(n.getNodeType() != Node.TEXT_NODE) {
            for(int i=0; i<level; i++)
                System.out.print("  ");
            System.out.print(n.getNodeName() + ":");
        }
        else {
            System.out.println(n.getNodeValue().trim());
        }
        NodeList list = n.getChildNodes();
        for(int i=0; i<list.getLength(); i++) {
            TreeWalk(list.item(i), level+1);
        }
    }
}

int main() {
	return 0;
}

function wp_syntax_highlight($match)
{
    global $wp_syntax_matches;
 
    $i = intval($match[1]);
    $match = $wp_syntax_matches[$i];
 
    $language = strtolower(trim($match[1]));
    $line = trim($match[2]);
    $escaped = trim($match[3]);
    $header = trim($match[4]);
    $code = wp_syntax_code_trim($match[5]);
    if ($escaped == "true") $code = htmlspecialchars_decode($code);
 
    $geshi = new GeSHi($code, $language);
    $geshi->enable_keyword_links(false);
    do_action_ref_array('wp_syntax_init_geshi', array(&$geshi));
 
    $output = "\n<div class=\"wp_syntax\">";
 
    if($header) {
        $output .= "<div class=\"wp_syn_hdr\">" . $header . "</div>";
    }