import json
import urllib
import curses
import time
 
host = 'HOSTNAME' # your .com here, sans http://www.
key = 'APIKEY' # you gotta register an API key with Chartbeat first
url = 'http://api.chartbeat.com/summize?host=%s&apikey=%s' % (host, key)
 
screen = curses.initscr()
curses.noecho()
curses.curs_set(0)
screen.nodelay(1)
screen.keypad(1)
 
try:
	while True:
		x = screen.getch()
		if x == ord('q'): break
		page = urllib.urlopen(url).read()
		data = json.loads(page)
		screen.clear()
		screen.addstr(0,0,"Visitors: %d"%data['people'])
		screen.addstr(1,0,"Pageload: %.1f"%(data['domload']/1000.0))
		screen.refresh()
		time.sleep(600) # sleep for 10 minutes
except:
	pass
finally:
	curses.nocbreak()
	screen.keypad(0)
	curses.echo()
	curses.endwin()

$post_id = url_to_postid('http://example.com/path/to/page');

<?php
// Hook into WP so we can access the DB
include '../../../wp-blog-header.php';
// Load all the YARPP functions
include 'yarpp.php';
// Let YARPP create tables, if they don't exist already
yarpp_activate();
//
$time_start = time();
$sql = "SELECT ID FROM $wpdb->posts WHERE post_type='post' and post_status='publish' ORDER BY ID desc";
$ids = $wpdb->get_col($sql,0);
$c = count($ids);
for($i=0; $i<$c; $i++) {
    $id = $ids[$i];
    printf("%d/%d\tID: %d\tELAPSED: %d\tREMAINING: %d\n",$i,$c,$id,$time_elapsed,$time_remaining);
    flush();
    // this fn causes yarpp to compute relatedness for the post
    yarpp_related(array('post'),array(),false,$id,'website');
    $time_elapsed = (time() - $time_start);
    $time_remaining = (($c-$i)-1) * ($time_elapsed/$i);
}

...
3/10	ID: 45647	ELAPSED: 10	REMAINING: 35
4/10	ID: 45625	ELAPSED: 14	REMAINING: 28
5/10	ID: 45601	ELAPSED: 19	REMAINING: 23
6/10	ID: 45593	ELAPSED: 22	REMAINING: 17
7/10	ID: 45572	ELAPSED: 29	REMAINING: 14
8/10	ID: 45571	ELAPSED: 31	REMAINING: 8
9/10	ID: 45570	ELAPSED: 34	REMAINING: 4
...

{"Person A": {"Item 1": 1.5, "Item 2": 2.5}, 
 "Person B": {"Item 2": 3.5}}

similarity(ratings_a,ratings_b) = 0.5

(use 'clojure.set)
 
;;
;; Some utility functions
;;
 
;; sum of squares of differences
(defn sum-of-squares [a b]
  (apply + (map (fn [x y] (Math/pow (- x y) 2)) a b)))
 
;; book has typo in definition here, see errata
(defn inverse-sum-of-squares [a b]
  (/ 1 (+ 1 (Math/sqrt (sum-of-squares a b)))))
 
;; items this person has rated 
(defn seen-by [db person]
  (into #{} (keys (get db person))))
 
;; items person hasn't rated
(defn unseen-by [db name items]
  (difference items (set (map first (get db name)))))
 
;; items both people have rated
(defn co-rated-items [db name-1 name-2]
  (intersection (set (keys (get db name-1))) (set (keys (get db name-2)))))
 
;; ratings by name of co-rated items in alphabetical order
(defn co-ratings [db name corated]
  (vals (filter (fn [v] (contains? corated (first v))) (sort (get db name)))))
 
;;
;; Distance metrics
;;
 
;; Manhattan distance
(defn sim-distance [db name-1 name-2]
  (let [corated (co-rated-items db name-1 name-2)]
    (if (not corated) 0
	(inverse-sum-of-squares (co-ratings db name-1 corated)
				(co-ratings db name-2 corated)))))
 
;; Pearson distance
;; book has a typo causing incorrect float division
(defn sim-pearson [db name-1 name-2]
  (let [corated (co-rated-items db name-1 name-2)]
    (if (not corated) 0
	(let [n (count corated)
	      ratings-1 (co-ratings db name-1 corated)
	      ratings-2 (co-ratings db name-2 corated)
	      sum-1 (apply + ratings-1)
	      sum-2 (apply + ratings-2)
	      sum-1-sq (apply + (map (fn [x] (* x x)) ratings-1))
	      sum-2-sq (apply + (map (fn [x] (* x x)) ratings-2))
	      psum (apply + (map (fn [x y] (* x y)) ratings-1 ratings-2))
	      num (- psum (/ (* sum-1 sum-2) n))
	      den (Math/sqrt (* (- sum-1-sq (/ (* sum-1 sum-1) n))
				(- sum-2-sq (/ (* sum-2 sum-2) n))))]
	  (if (= den 0) 0
	      (/ num den))))))
 
;;
;; Recommendation algorithm
;;
 
(defn total-sums [db other items sim]
  (reduce (fn [m item] (assoc m item (* (get (get db other) item) sim))) {} items))
 
(defn sim-sums [items sim]
  (reduce (fn [m item] (assoc m item sim)) {} items))
 
;; combines sum(rating*similarity) and sum(similarity) of all raters
(defn loop-totals [db others me metric]
  (loop [others others t {} s {}]
    (if (= (count others) 0) [t s]
	(let [other (first others)
	      unseen-items (unseen-by db me (seen-by db other))
	      sim (metric db me other)]
	  (if (< sim 0)
	    (recur (rest others) t s)
	    (recur (rest others)
		   (merge-with + t (total-sums db other unseen-items sim))
		   (merge-with + s (sim-sums unseen-items sim))))))))
 
;; generates recommendations of the form {rating: item}
(defn recommend [db me metric]
  (let [others (disj (set (map first db)) me)
	[my-totals my-sims] (loop-totals db others me metric)]
    (reverse (sort (map (fn [item] [(/ (get my-totals item) (get my-sims item)) item]) (set (keys my-totals)))))))
 
;;
;; functions dealing with creation of DB
;;
 
;; returns DB with a new rating added
(defn add-rating [db name item rating]
  (assoc db name (conj (get db name {item rating}) {item rating})))
 
;; returns DB with a list of new ratings added
(defn add-ratings [db ratings]
  (reduce
   (fn [db [name item rating]]
     (add-rating db name item rating))
   db ratings))
 
;; creates the DB used for examples in the book
(defn init-db []
  (add-ratings {}
	       [["Lisa Rose" "Lady in the Water" 2.5]
		["Lisa Rose" "Snakes on a Plane" 3.5]
		["Lisa Rose" "Just My Luck" 3.0]
		["Lisa Rose" "Superman Returns" 3.5]
		["Lisa Rose" "You, Me and Dupree" 2.5]
		["Lisa Rose" "The Night Listener" 3.0]
		["Gene Seymour" "Lady in the Water" 3.0]
		["Gene Seymour" "Snakes on a Plane" 3.5]
		["Gene Seymour" "Just My Luck" 1.5]
		["Gene Seymour" "Superman Returns" 5.0]
		["Gene Seymour" "The Night Listener" 3.0]
		["Gene Seymour" "You, Me and Dupree" 3.5]
		["Michael Phillips" "Lady in the Water" 2.5]
		["Michael Phillips" "Snakes on a Plane" 3.0]
		["Michael Phillips" "Superman Returns" 3.5]
		["Michael Phillips" "The Night Listener" 4.0]
		["Claudia Puig" "Snakes on a Plane" 3.5]
		["Claudia Puig" "Just My Luck" 3.0]
		["Claudia Puig" "The Night Listener" 4.5]
		["Claudia Puig" "Superman Returns" 4.0]
		["Claudia Puig" "You, Me and Dupree" 2.5]
		["Mick LaSalle" "Lady in the Water" 3.0]
		["Mick LaSalle" "Snakes on a Plane" 4.0]
		["Mick LaSalle" "Just My Luck" 2.0]
		["Mick LaSalle" "Superman Returns" 3.0]
		["Mick LaSalle" "The Night Listener" 3.0]
		["Mick LaSalle" "You, Me and Dupree" 2.0]
		["Jack Matthews" "Lady in the Water" 3.0]
		["Jack Matthews" "Snakes on a Plane" 4.0]
		["Jack Matthews" "The Night Listener" 3.0]
		["Jack Matthews" "Superman Returns" 5.0]
		["Jack Matthews" "You, Me and Dupree" 3.5]
		["Toby" "Snakes on a Plane" 4.5]
		["Toby" "Superman Returns" 4.0]
		["Toby" "You, Me and Dupree" 1.0]]))

(def *db* (init-db))
(recommend *db* "Toby" sim-distance)

<?php
/*
Plugin Name: Ct Most Popular
Plugin URI: http://www.craiget.com
Description: Display most viewed posts using the Chartbeat API, exposes one function: ct_most_popular_plugin_widget(); 
Version: 0.1
Author: Craige
Author URI: http://craiget.com
License: For example and testing purposes. Not suggested for use on a real site.
*/
 
$ct_most_popular_plugin_version = "0.1";
 
$ct_most_popular_plugin_data = array();
 
// create a most_popular option
register_activation_hook(__FILE__, 'ct_most_popular_plugin_install');
function ct_most_popular_plugin_install()
{
	add_option("ct_most_popular_plugin_data", $ct_most_popular_data);
	add_option("ct_most_popular_plugin_version", $ct_most_popular_plugin_version);
	// schedule hourly update
	wp_schedule_event(time(), 'hourly', 'ct_most_popular_plugin_update_event');
}
 
// delete the most_popular option
register_deactivation_hook(__FILE__, 'ct_most_popular_plugin_uninstall');
function ct_most_popular_plugin_uninstall()
{
	delete_option("ct_most_popular_plugin_data");
	delete_option("ct_most_popular_plugin_version");
	// un-schedule hourly update
	wp_clear_scheduled_hook('ct_most_popular_plugin_update_event');
}
 
// appear under "Settings" on the admin page
add_action('admin_menu', 'ct_most_popular_plugin_menu');
function ct_most_popular_plugin_menu() {
	add_options_page('Ct Most Popular', 'Ct Most Popular', 'manage_options', '', 'ct_most_popular_plugin_options');
}
 
// init option values in db
add_action('admin_init', 'ct_most_popular_plugin_options_init' );
function ct_most_popular_plugin_options_init(){
	register_setting('ct_most_popular_plugin_options', 'ct_most_popular_plugin', 'ct_most_popular_plugin_validate' );
}
 
// sanitize and validate input
function ct_most_popular_plugin_validate($input) {
	$input['host'] =  wp_filter_nohtml_kses($input['host']);
	$input['chartbeat_api_key'] =  wp_filter_nohtml_kses($input['chartbeat_api_key']);
	$input['limit'] =  (int)($input['limit']);
	if($input['limit'] == 0) $input['limit'] = 10;
	return $input;
}
 
// display options page html
function ct_most_popular_plugin_options() {
	if (!current_user_can('manage_options'))  {
		wp_die(__('You do not have sufficient permissions to access this page.') );
	}
?>
<div class="wrap">
	<h2>Ct Most Popular Plugin Options Title</h2>
	<form method="post" action="options.php">
		<?php settings_fields('ct_most_popular_plugin_options'); ?>
		<?php $options = get_option('ct_most_popular_plugin'); ?>
		<table class="form-table">
		<tr valign="top">
			<th scope="row">Host</th>
			<td><input type="text" name="ct_most_popular_plugin[host]" value="<?php echo $options['host']; ?>" /></td>
			<td><i>ie, example.com</i></td>
		</tr>
		<tr valign="top">
			<th scope="row">Chartbeat API Key</th>
			<td><input type="text" name="ct_most_popular_plugin[chartbeat_api_key]" value="<?php echo $options['chartbeat_api_key']; ?>" /></td>
			<td><i><a href="http://chartbeat.com/apikeys/">http://chartbeat.com/apikeys/</a></i></td>
		</tr>
		<tr valign="top">
			<th scope="row">Limit</th>
			<td><input type="text" name="ct_most_popular_plugin[limit]" value="<?php echo $options['limit']; ?>" /></td>
			<td><i>number of items to show, 10</i></td>
		</tr>
		</table>
		<p class="submit">
			<input type="submit" class="button-primary" value="<?php _e('Save Changes') ?>" />
		</p>
		<p>
		This plugin uses the <a href="http://chartbeat.pbworks.com/">Chartbeat API</a> to show the most popular pages on your site, updated hourly.
		</p>
		<p>
		This plugin was created for my own amusement and to practice creating Wordpress plugins, it is <strong>NOT RECOMMENDED</strong> for use.
		</p>
		<p>
		Chartbeat has released a perfectly good plugin that does this and more: <a href="http://wordpress.org/extend/plugins/chartbeat/">http://wordpress.org/extend/plugins/chartbeat/</a>
		</p>
		<p>
		This plugin fetches new data once every hour using Wordpress's built-in <a href="http://codex.wordpress.org/Function_Reference/wp_schedule_event">scheduling hooks</a> to update the list of popular posts hourly.
		This keeps things self-contained, but doesn't provide much flexibility. You may want to use cron instead, which would require a little hacking.
		</p>
	</form>
</div>
<?php
}
 
// get popularity data from chartbeat, store in db
add_action('ct_most_popular_plugin_update_event', 'ct_most_popular_plugin_update_chartbeat');
function ct_most_popular_plugin_update_chartbeat() {
	// construct chartbeat call
	$options = get_option('ct_most_popular_plugin');
	$host = $options['host'];
	$apikey = $options['chartbeat_api_key'];
	$limit = $options['limit'];
	// build url
	$url = 'http://api.chartbeat.com/toppages/?host=HOST&limit=LIMIT&apikey=APIKEY';
	$url = str_replace('HOST', $host, $url);
	$url = str_replace('APIKEY', $apikey, $url);
	$url = str_replace('LIMIT', $limit, $url);
	// fetch data
	$data = file_get_contents($url);
	$data = json_decode($data, true);
	// exit if not enough results back
	if(count($data) < $limit)
		return;
	$result = array();
	for($i=0; $i<count($data); $i++) {
		if($data[$i]['path'] == "/")
			continue;
		$result[] = $data[$i];
	}
	$result = array_slice($result, 0, $limit);
	// store in db
	update_option("ct_most_popular_plugin_data", $result);
}
 
// add this function in your sidebar
function ct_most_popular_plugin_widget() {
	$data = get_option("ct_most_popular_plugin_data");
	echo('<ul>');
	foreach ($data as $post) {
		echo('<li>');
		echo('<a href="'.$post['path'].'">'.$post['visitors'].'-'.$post['i'].'</a>');
		echo('</li>');
	}
	echo('</ul>');
}

import sys
sys.path.append('/the/path/to/selenium-python-client-driver-1.0.1')
 
from selenium import selenium
 
email = 'YOUR_GOOGLE_LOGIN'
passwd = 'YOUR_PASSWORD'
 
s = selenium("localhost", 4444, "*firefox", "http://market.android.com")
s.start()
s.open("/publish/Home")
s.type("Email", email)
s.type("Passwd", passwd)
s.click("signIn")
s.wait_for_page_to_load("30000")
 
n = int(s.get_xpath_count("//div[@class='listingRow']"))
for i in range(3,n):
  try:
    title = s.get_text("xpath=(//div[@class='listingRow'])[%s]/div[1]/div[1]" % i)
    downloaded = s.get_text("xpath=(//div[@class='listingRow'])[%s]/div[2]/div[1]/span[1]" % i)
    installed = s.get_text("xpath=(//div[@class='listingRow'])[%s]/div[2]/div[2]/span[1]" % i)
    comments = s.get_text("xpath=(//div[@class='listingRow'])[%s]/table" % i)[1:-1]
    print title, downloaded, installed, comments
  except:
    pass

cd /path/to/selenium
java -jar selenium-server.jar

//bad - don't do this
long TS0 = 1272690000000L; //may 1st, 2010
long millis = System.currentTimeMillis() + 1000*60*60*24*365; //one year from today
while(millis > TS0) {
  String date = DateFormat.format(yyyyMMdd, millis).toString();
  millis -= 1000*60*60*24;
}

public class WaitWhat {
  public static void main(String args[]) {
    long millis = 1000*60*60*24*365; // should be 31,536,000,000
    System.out.println(millis);
  }
}

1471228928

//note the "L"
long millis = 1000L*60*60*24*365;

;; import enlive
(use 'net.cgrand.enlive-html)
 
;; html helper
(defn fetch-url [url]
  (html-resource (java.net.URL. url)))
 
;; pulls link from paragraph
;; ie, (map get-link (select *cl* [:p]))
(defn get-link [p]
  (:href (:attrs (first (:content p)))))
 
;; pulls text of link from paragraph
(defn get-link-text [p]
  (:content (first (:content p))))
 
;; pulls text of parens following link
;; usually this is zipcode/location info
;; "", if absent
(defn get-paren-text [p]
  (let [content (:content p)]
    (if (< 2 (count content))
      (:content (nth content 2))
      "")))
 
;; pulls link/text/location into a map
(defn get-all [p]
  {:link (get-link p)
   :text (str (get-link-text p)
	      (get-paren-text p))})
 
;; some helpers to remove links we don't care about 
 
;; (affordable "$800" 600 1000) #t
;; (affordable "$1500" 600 1000) #f
(defn affordable? [text min max]
  (let [price (second (re-find #"\$(\d+)" text))]
    (if price
      (let [price (Integer/parseInt price)]
	(and (<= min price)
	     (>= max price))))))
 
;; (has-kword "downtown" (list "down")) #t
;; (has-kword "down" (list "downtown")) #f
(defn has-kword? [text kwords]
  (let [vals (map #(re-find (re-matcher (re-pattern %) text)) kwords)]
    (some #(not (= nil %)) vals)))
 
;; parameterizes a function to decide if a link is worth retrieving
;; this would be cooler if the criteria functions
;; came in as a list too.. but that makes my head
;; spin.. maybe later
(defn keep-link? [min max areas beds]
  (fn [{link :link text :text}]
    (let [text (.toLowerCase text)]
      (and link
	   (re-find #"/apa/" link)
	   (affordable? text min max)
	   (has-kword? text areas)
	   (has-kword? text beds)))))
 
;; some top level definitions
;; you may need to change these to get non-empty results
(def *url* "http://losangeles.craigslist.org/apa/")
(def *min-price* 100)
(def *max-price* 10000)
;; I kinda like it in the South Bay, but whatever..
(def *areas* (list "hollywood" "weho"))
(def *beds* (list "2br" "3br"))
(def my-keep-link? (keep-link? *min-price* *max-price* *areas* *beds*))
 
;; actually do the work
(filter my-keep-link? (map get-all (select (fetch-url *url*) [:p])))
 
;; References
;; 1) http://wiki.github.com/cgrand/enlive/
;; 2) http://github.com/swannodette/enlive-tutorial/
;; 3) Programming Clojure, Stuart Halloway
;; 4) lots and lots of Googling