// PythonScript Runtime - regenerated on: Mon Oct 28 16:21:46 2013

var jsrange = function(num) {

"Emulates Python's range function";

var i, r;

i = 0;

r = [];

while(i < num) {

r.push(i);

i = i + 1;

}

return r;

}

window["jsrange"] = jsrange

var create_array = function() {

"Used to fix a bug/feature of Javascript where new Array(number)\n created a array with number of undefined elements which is not\n what we want";

var array;

array = [];

var iter = jsrange(arguments.length);

for (var i=0; i < iter.length; i++) {

var backup = i;

i = iter[i];

array.push(arguments[i]);

i = backup;

}

return array;

}

window["create_array"] = create_array

var adapt_arguments = function(handler) {

"Useful to transform Javascript arguments to Python arguments";

var func = function() {

handler(Array.prototype.slice.call(arguments));

}

return func;

}

window["adapt_arguments"] = adapt_arguments

var create_class = function(class_name, parents, attrs, props) {

"Create a PythonScript class";

if(attrs.__metaclass__) {

var metaclass;

metaclass = attrs.__metaclass__;

attrs.__metaclass__ = undefined;

return metaclass([class_name, parents, attrs]);

}

var klass;

klass = Object();

klass.bases = parents;

klass.__name__ = class_name;

klass.__dict__ = attrs;

klass.__properties__ = props;

var __call__ = function() {

"Create a PythonScript object";

var object;

object = Object();

object.__class__ = klass;

object.__dict__ = Object();

var init;

init = get_attribute(object, "__init__");

if(init) {

init.apply(undefined, arguments);

}

return object;

}

__call__.pythonscript_function = true;

klass.__call__ = __call__;

return klass;

}

window["create_class"] = create_class

var get_attribute = function(object, attribute) {

"Retrieve an attribute, method, property, or wrapper function.\n\n method are actually functions which are converted to methods by\n prepending their arguments with the current object. Properties are\n not functions!\n\n DOM support:\n http://stackoverflow.com/questions/14202699/document-createelement-not-working\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/instanceof\n\n Direct JavaScript Calls:\n if an external javascript function is found, and it was not a wrapper that was generated here,\n check the function for a 'cached_wrapper' attribute, if none is found then generate a new\n wrapper, cache it on the function, and return the wrapper.\n ";

if(attribute == "__call__") {

if({}.toString.call(object) === '[object Function]') {

if(object.pythonscript_function === true) {

return object;

}

else {

if(object.is_wrapper !== undefined) {

return object;

}

else {

var cached = object.cached_wrapper;

if(cached) {

return cached;

}

else {

var wrapper = function(args, kwargs) {

return object.apply(undefined, args);

}

wrapper.is_wrapper = true;

object.cached_wrapper = wrapper;

return wrapper;

}

}

}

}

}

var attr;

if(attribute == "__contains__") {

attribute = "__CONTAINS__";

}

attr = object[attribute];

if(object instanceof HTMLDocument) {

if(typeof(attr) === 'function') {

var wrapper = function(args, kwargs) {

return attr.apply(object, args);

}

wrapper.is_wrapper = true;

return wrapper;

}

else {

return attr;

}

}

else {

if(object instanceof HTMLElement) {

if(typeof(attr) === 'function') {

var wrapper = function(args, kwargs) {

return attr.apply(object, args);

}

wrapper.is_wrapper = true;

return wrapper;

}

else {

return attr;

}

}

}

if(attr !== undefined) {

if(typeof(attr) === 'function' && attr.pythonscript_function === undefined && attr.is_wrapper === undefined) {

var wrapper = function(args, kwargs) {

return attr.apply(object, args);

}

wrapper.is_wrapper = true;

return wrapper;

}

else {

return attr;

}

}

var __class__, __dict__, __get__, bases;

__class__ = object.__class__;

if(__class__) {

__dict__ = __class__.__dict__;

attr = __dict__[attribute];

if(attr) {

__get__ = get_attribute(attr, "__get__");

if(__get__) {

return __get__([object, __class__]);

}

}

bases = __class__.bases;

var iter = jsrange(bases.length);

for (var i=0; i < iter.length; i++) {

var backup = i;

i = iter[i];

var base, attr;

base = bases[i];

attr = get_attribute(base, attribute);

if(attr) {

__get__ = get_attribute(attr, "__get__");

if(__get__) {

return __get__([object, __class__]);

}

}

i = backup;

}

}

__dict__ = object.__dict__;

bases = object.__bases__;

if(__dict__) {

attr = __dict__[attribute];

if(attr != undefined) {

if(bases) {

__get__ = get_attribute(attr, "__get__");

if(__get__) {

return __get__([undefined, __class__]);

}

}

return attr;

}

}

if(bases) {

var iter = jsrange(bases.length);

for (var i=0; i < iter.length; i++) {

var backup = i;

i = iter[i];

var base, attr;

base = bases[i];

attr = get_attribute(base, attribute);

if(attr) {

__get__ = get_attribute(attr, "__get__");

if(__get__) {

return __get__([object, __class__]);

}

}

i = backup;

}

}

if(__class__) {

if(attribute in __class__.__properties__) {

return __class__.__properties__[attribute]([object]);

}

__dict__ = __class__.__dict__;

attr = __dict__[attribute];

if(attribute in __dict__) {

if({}.toString.call(attr) === '[object Function]') {

var method = function() {

var args;

args = Array.prototype.slice.call(arguments);

if(args[0] instanceof Array && {}.toString.call(args[1]) === '[object Object]' && args.length == 2) {

/*pass*/

}

else {

args = [args, Object()];

}

args[0].splice(0, 0, object);

return attr.apply(undefined, args);

}

method.is_wrapper = true;

return method;

}

else {

return attr;

}

}

bases = __class__.bases;

var iter = bases;

for (var base=0; base < iter.length; base++) {

var backup = base;

base = iter[base];

attr = _get_upstream_attribute(base, attribute);

if(attr) {

if({}.toString.call(attr) === '[object Function]') {

var method = function() {

var args;

args = Array.prototype.slice.call(arguments);

if(args[0] instanceof Array && {}.toString.call(args[1]) === '[object Object]' && args.length == 2) {

/*pass*/

}

else {

args = [args, Object()];

}

args[0].splice(0, 0, object);

return attr.apply(undefined, args);

}

method.is_wrapper = true;

return method;

}

else {

return attr;

}

}

base = backup;

}

var iter = bases;

for (var base=0; base < iter.length; base++) {

var backup = base;

base = iter[base];

var getter;

getter = _get_upstream_property(base, attribute);

if(getter) {

return getter([object], Object());

}

base = backup;

}

if("__getattr__" in __dict__) {

return __dict__["__getattr__"]([object, attribute], Object());

}

var iter = bases;

for (var base=0; base < iter.length; base++) {

var backup = base;

base = iter[base];

var f;

f = _get_upstream_attribute(base, "__getattr__");

if(f) {

return f([object, attribute], Object());

}

base = backup;

}

}

if(object instanceof Array) {

if(attribute == "__getitem__") {

var wrapper = function(args, kwargs) {

return object[args[0]];

}

wrapper.is_wrapper = true;

return wrapper;

}

else {

if(attribute == "__setitem__") {

var wrapper = function(args, kwargs) {

object[args[0]] = args[1];

}

wrapper.is_wrapper = true;

return wrapper;

}

}

}

else {

if(attribute == "__getitem__") {

var wrapper = function(args, kwargs) {

return object[args[0]];

}

wrapper.is_wrapper = true;

return wrapper;

}

else {

if(attribute == "__setitem__") {

var wrapper = function(args, kwargs) {

object[args[0]] = args[1];

}

wrapper.is_wrapper = true;

return wrapper;

}

}

}

return undefined;

}

window["get_attribute"] = get_attribute

var _get_upstream_attribute = function(base, attr) {

if(attr in base.__dict__) {

return base.__dict__[attr];

}

var iter = base.bases;

for (var parent=0; parent < iter.length; parent++) {

var backup = parent;

parent = iter[parent];

return _get_upstream_attribute(parent, attr);

parent = backup;

}

}

window["_get_upstream_attribute"] = _get_upstream_attribute

var _get_upstream_property = function(base, attr) {

if(attr in base.__properties__) {

return base.__properties__[attr];

}

var iter = base.bases;

for (var parent=0; parent < iter.length; parent++) {

var backup = parent;

parent = iter[parent];

return _get_upstream_property(parent, attr);

parent = backup;

}

}

window["_get_upstream_property"] = _get_upstream_property

var set_attribute = function(object, attribute, value) {

"Set an attribute on an object by updating its __dict__ property";

var __dict__, __class__;

__class__ = object.__class__;

if(__class__) {

var attr, bases;

__dict__ = __class__.__dict__;

attr = __dict__[attribute];

if(attr != undefined) {

__set__ = get_attribute(attr, "__set__");

if(__set__) {

__set__([object, value]);

return undefined;

}

}

bases = __class__.bases;

var iter = jsrange(bases.length);

for (var i=0; i < iter.length; i++) {

var backup = i;

i = iter[i];

var base;

base = bases[i];

attr = get_attribute(base, attribute);

if(attr) {

__set__ = get_attribute(attr, "__set__");

if(__set__) {

__set__([object, value]);

return undefined;

}

}

i = backup;

}

}

__dict__ = object.__dict__;

if(__dict__) {

__dict__[attribute] = value;

}

else {

object[attribute] = value;

}

}

window["set_attribute"] = set_attribute

set_attribute.pythonscript_function = true;

var get_arguments = function(signature, args, kwargs) {

"Based on ``signature`` and ``args``, ``kwargs`` parameters retrieve\n the actual parameters.\n\n This will set default keyword arguments and retrieve positional arguments\n in kwargs if their called as such";

if(args === undefined) {

args = [];

}

if(kwargs === undefined) {

kwargs = Object();

}

out = Object();

if(args.length > signature.args.length) {

if(signature.vararg) {

/*pass*/

}

else {

console.log("ERROR args:", args, "kwargs:", kwargs, "sig:", signature);

throw TypeError("Supplemental positional arguments provided but signature doesn't accept them");

}

}

j = 0;

while(j < signature.args.length) {

name = signature.args[j];

if(name in kwargs) {

out[name] = kwargs[name];

}

else {

if(j < args.length) {

out[name] = args[j];

}

else {

if(name in signature.kwargs) {

out[name] = signature.kwargs[name];

}

}

}

j += 1

}

args = args.slice(j);

if(signature.vararg) {

out[signature.vararg] = args;

}

if(signature.varkwarg) {

out[signature.varkwarg] = kwargs;

}

return out;

}

window["get_arguments"] = get_arguments

get_arguments.pythonscript_function = true;

var type = function(args, kwargs) {

var class_name, parents, attrs;

class_name = args[0];

parents = args[1];

attrs = args[2];

return create_class(class_name, parents, attrs);

}

window["type"] = type

type.pythonscript_function = true;

var getattr = function(args, kwargs) {

var object, attribute;

object = args[0];

attribute = args[1];

return get_attribute(object, attribute);

}

window["getattr"] = getattr

getattr.pythonscript_function = true;

var setattr = function(args, kwargs) {

var object, attribute, value;

object = args[0];

attribute = args[1];

value = args[2];

return set_attribute(object, attribute, value);

}

window["setattr"] = setattr

setattr.pythonscript_function = true;

var issubclass = function(args, kwargs) {

var C, B, base;

C = args[0];

B = args[1];

if(C === B) {

return true;

}

var iter = jsrange(C.bases.length);

for (var index=0; index < iter.length; index++) {

var backup = index;

index = iter[index];

base = C.bases[index];

if(issubclass([base, B], Object())) {

return true;

}

index = backup;

}

return false;

}

window["issubclass"] = issubclass

issubclass.pythonscript_function = true;

var isinstance = function(args, kwargs) {

var object_class, object, klass;

object = args[0];

klass = args[1];

object_class = object.__class__;

if(object_class === undefined) {

return false;

}

return issubclass(create_array(object_class, klass));

}

window["isinstance"] = isinstance

isinstance.pythonscript_function = true;

_PythonJS_UID = 0;

var _JSNew = function(T) {

return new T;

}

window["_JSNew"] = _JSNew

_JSNew.NAME = "_JSNew";

_JSNew.args_signature = ["T"];

_JSNew.kwargs_signature = {};

var int = function(args, kwargs) {

if(args instanceof Array && {}.toString.call(kwargs) === '[object Object]' && arguments.length == 2) {

/*pass*/

}

else {

args = Array.prototype.slice.call(arguments);

kwargs = Object();

}

var signature, arguments;

signature = {"kwargs": Object(), "args": create_array("a")};

signature["function_name"] = "int";

arguments = get_arguments(signature, args, kwargs);

var a = arguments['a'];

if(a instanceof String) {

return window.parseInt( a );

}

else {

return Math.round( a );

}

}

window["int"] = int

int.NAME = "int";

int.args_signature = ["a"];

int.kwargs_signature = { };

int.pythonscript_function = true;

var float = function(args, kwargs) {

if(args instanceof Array && {}.toString.call(kwargs) === '[object Object]' && arguments.length == 2) {

/*pass*/

}

else {

args = Array.prototype.slice.call(arguments);

kwargs = Object();

}

var signature, arguments;

signature = {"kwargs": Object(), "args": create_array("a")};

signature["function_name"] = "float";

arguments = get_arguments(signature, args, kwargs);

var a = arguments['a'];

if(a instanceof String) {

return window.parseFloat( a );

}

else {

return a;

}

}

window["float"] = float

float.NAME = "float";

float.args_signature = ["a"];

float.kwargs_signature = { };

float.pythonscript_function = true;

var str = function(args, kwargs) {

if(args instanceof Array && {}.toString.call(kwargs) === '[object Object]' && arguments.length == 2) {

/*pass*/

}

else {

args = Array.prototype.slice.call(arguments);

kwargs = Object();

}

var signature, arguments;

signature = {"kwargs": Object(), "args": create_array("s")};

signature["function_name"] = "str";

arguments = get_arguments(signature, args, kwargs);

var s = arguments['s'];

return "" + s;

}

window["str"] = str

str.NAME = "str";

str.args_signature = ["s"];

str.kwargs_signature = { };

str.pythonscript_function = true;

var _setup_str_prototype = function(args, kwargs) {

"\n Extend JavaScript String.prototype with methods that implement the Python str API.\n The decorator @String.prototype.[name] assigns the function to the prototype,\n and ensures that the special 'this' variable will work.\n ";

var func = function(idx) {

return this[ idx ];

}

func.NAME = "func";

func.args_signature = ["idx"];

func.kwargs_signature = {};

String.prototype.__getitem__=func;

var func = function() {

return this.length;

}

func.NAME = "func";

func.args_signature = [];

func.kwargs_signature = {};

String.prototype.__len__=func;

var func = function(a) {

if(this.substring(0, a.length) == a) {

return true;

}

else {

return false;

}

}

func.NAME = "func";

func.args_signature = ["a"];

func.kwargs_signature = {};

String.prototype.startswith=func;

var func = function(a) {

if(this.substring(this.length - a.length, this.length) == a) {

return true;

}

else {

return false;

}

}

func.NAME = "func";

func.args_signature = ["a"];

func.kwargs_signature = {};

String.prototype.endswith=func;

var func = function(a) {

var i, out;

out = "";

if(a instanceof Array) {

arr = a;

}

else {

arr = a.__dict__.js_object;

}

i = 0;

var iter = arr;

for (var value=0; value < iter.length; value++) {

var backup = value;

value = iter[value];

out += value;

i += 1;

if(i < arr.length) {

out += this;

}

value = backup;

}

return out;

}

func.NAME = "func";

func.args_signature = ["a"];

func.kwargs_signature = {};

String.prototype.join=func;

var func = function() {

return this.toUpperCase( );

}

func.NAME = "func";

func.args_signature = [];

func.kwargs_signature = {};

String.prototype.upper=func;

var func = function() {

return this.toLowerCase( );

}

func.NAME = "func";

func.args_signature = [];

func.kwargs_signature = {};

String.prototype.lower=func;

var func = function(a) {

return this.indexOf( a );

}

func.NAME = "func";

func.args_signature = ["a"];

func.kwargs_signature = {};

String.prototype.index=func;

var func = function() {

var digits;

digits = ["0", "1", "2", "3", "4", "5", "6", "7", "8", "9"];

var iter = this;

for (var char=0; char < iter.length; char++) {

var backup = char;

char = iter[char];

if(char in digits || Object.hasOwnProperty.call(digits, "__contains__") && digits["__contains__"](char)) {

/*pass*/

}

else {

return false;

}

char = backup;

}

return true;

}

func.NAME = "func";

func.args_signature = [];

func.kwargs_signature = {};

String.prototype.isdigit=func;

}

window["_setup_str_prototype"] = _setup_str_prototype

_setup_str_prototype.NAME = "_setup_str_prototype";

_setup_str_prototype.args_signature = [];

_setup_str_prototype.kwargs_signature = { };

_setup_str_prototype.pythonscript_function = true;

_setup_str_prototype(create_array(), Object());

var _setup_array_prototype = function(args, kwargs) {

var func = function(a) {

if(this.indexOf(a) == -1) {

return false;

}

else {

return true;

}

}

func.NAME = "func";

func.args_signature = ["a"];

func.kwargs_signature = {};

Array.prototype.__contains__=func;

var func = function() {

return this.length;

}

func.NAME = "func";

func.args_signature = [];

func.kwargs_signature = {};

Array.prototype.__len__=func;

}

window["_setup_array_prototype"] = _setup_array_prototype

_setup_array_prototype.NAME = "_setup_array_prototype";

_setup_array_prototype.args_signature = [];

_setup_array_prototype.kwargs_signature = { };

_setup_array_prototype.pythonscript_function = true;

_setup_array_prototype(create_array(), Object());

var range = function(args, kwargs) {

var i, r;

if(args instanceof Array && {}.toString.call(kwargs) === '[object Object]' && arguments.length == 2) {

/*pass*/

}

else {

args = Array.prototype.slice.call(arguments);

kwargs = Object();

}

var signature, arguments;

signature = {"kwargs": Object(), "args": create_array("num")};

signature["function_name"] = "range";

arguments = get_arguments(signature, args, kwargs);

var num = arguments['num'];

"Emulates Python's range function";

var i, r;

i = 0;

r = get_attribute(list, "__call__")(create_array(), Object());

while(i < num) {

get_attribute(get_attribute(r, "append"), "__call__")([i], Object());

i += 1

}

return r;

}

window["range"] = range

range.NAME = "range";

range.args_signature = ["num"];

range.kwargs_signature = { };

range.pythonscript_function = true;

var StopIteration, __StopIteration_attrs, __StopIteration_parents;

window["__StopIteration_attrs"] = Object();

window["__StopIteration_parents"] = create_array();

window["__StopIteration_properties"] = Object();

StopIteration = create_class("StopIteration", window["__StopIteration_parents"], window["__StopIteration_attrs"], window["__StopIteration_properties"]);

var len = function(args, kwargs) {

if(args instanceof Array && {}.toString.call(kwargs) === '[object Object]' && arguments.length == 2) {

/*pass*/

}

else {

args = Array.prototype.slice.call(arguments);

kwargs = Object();

}

var signature, arguments;

signature = {"kwargs": Object(), "args": create_array("obj")};

signature["function_name"] = "len";

arguments = get_arguments(signature, args, kwargs);

var obj = arguments['obj'];

return get_attribute(obj, "__len__")(create_array(), Object());

}

window["len"] = len

len.NAME = "len";

len.args_signature = ["obj"];

len.kwargs_signature = { };

len.pythonscript_function = true;

var next = function(args, kwargs) {

if(args instanceof Array && {}.toString.call(kwargs) === '[object Object]' && arguments.length == 2) {

/*pass*/

}

else {

args = Array.prototype.slice.call(arguments);

kwargs = Object();

}

var signature, arguments;

signature = {"kwargs": Object(), "args": create_array("obj")};

signature["function_name"] = "next";

arguments = get_arguments(signature, args, kwargs);

var obj = arguments['obj'];

return get_attribute(obj, "next")(create_array(), Object());

}

window["next"] = next

next.NAME = "next";

next.args_signature = ["obj"];

next.kwargs_signature = { };

next.pythonscript_function = true;

var map = function(args, kwargs) {

var out;

if(args instanceof Array && {}.toString.call(kwargs) === '[object Object]' && arguments.length == 2) {

/*pass*/

}

else {

args = Array.prototype.slice.call(arguments);

kwargs = Object();

}

var signature, arguments;

signature = {"kwargs": Object(), "args": create_array("func", "objs")};

signature["function_name"] = "map";

arguments = get_arguments(signature, args, kwargs);

var func = arguments['func'];

var objs = arguments['objs'];

out = get_attribute(list, "__call__")(create_array(), Object());

set_attribute(out, "js_object", get_attribute(map, "__call__")([func, get_attribute(objs, "js_object")], Object()));

return out;

}

window["map"] = map

map.NAME = "map";

map.args_signature = ["func", "objs"];

map.kwargs_signature = { };

map.pythonscript_function = true;

var min = function(args, kwargs) {

var a;

if(args instanceof Array && {}.toString.call(kwargs) === '[object Object]' && arguments.length == 2) {

/*pass*/

}

else {

args = Array.prototype.slice.call(arguments);

kwargs = Object();

}

var signature, arguments;

signature = {"kwargs": Object(), "args": create_array("lst")};

signature["function_name"] = "min";

arguments = get_arguments(signature, args, kwargs);

var lst = arguments['lst'];

a = undefined;

var __iterator__, value;

__iterator__ = get_attribute(get_attribute(lst, "__iter__"), "__call__")(create_array(), Object());

try {

value = get_attribute(__iterator__, "next")(create_array(), Object());

while(true) {

if(a === undefined) {

a = value;

}

else {

if(value < a) {

a = value;

}

}

value = get_attribute(__iterator__, "next")(create_array(), Object());

}

}

catch(__exception__) {

if (__exception__ == StopIteration || isinstance([__exception__, StopIteration], Object())) {

/*pass*/

}

}

return a;

}

window["min"] = min

min.NAME = "min";

min.args_signature = ["lst"];

min.kwargs_signature = { };

min.pythonscript_function = true;

var max = function(args, kwargs) {

var a;

if(args instanceof Array && {}.toString.call(kwargs) === '[object Object]' && arguments.length == 2) {