// PythonScript Runtime - regenerated on: Thu Nov 7 21:54:00 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);

if (! (iter instanceof Array) ) { iter = Object.keys(iter) }

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 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;

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);

if (! (iter instanceof Array) ) { iter = Object.keys(iter) }

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);

if (! (iter instanceof Array) ) { iter = Object.keys(iter) }

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]["get"]([object], 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;

object[attribute] = method;

return method;

}

else {

return attr;

}

}

bases = __class__.__bases__;

var iter = bases;

if (! (iter instanceof Array) ) { iter = Object.keys(iter) }

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;

object[attribute] = method;

return method;

}

else {

return attr;

}

}

base = backup;

}

var iter = bases;

if (! (iter instanceof Array) ) { iter = Object.keys(iter) }

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

var backup = base;

base = iter[base];

var prop;

prop = _get_upstream_property(base, attribute);

if(prop) {

return prop["get"]([object], Object());

}

base = backup;

}

if("__getattr__" in __dict__) {

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

}

var iter = bases;

if (! (iter instanceof Array) ) { iter = Object.keys(iter) }

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__;

if (! (iter instanceof Array) ) { iter = Object.keys(iter) }

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__;

if (! (iter instanceof Array) ) { iter = Object.keys(iter) }

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);

if (! (iter instanceof Array) ) { iter = Object.keys(iter) }

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

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

_PythonJS_UID = 0;

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

var metaclass, klass;

"Create a PythonScript class";

if(attrs.__metaclass__) {

metaclass = attrs.__metaclass__;

attrs.__metaclass__=undefined;

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

}

klass = { };

klass.__bases__=parents;

klass.__name__=class_name;

klass.__dict__=attrs;

klass.__properties__=props;

var __call__ = function() {

var init, object;

"Create a PythonJS object";

var object;

object = { };

object.__class__=klass;

object.__dict__={ };

var iter = klass.__dict__;

if (! (iter instanceof Array) ) { iter = Object.keys(iter) }

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

var backup = name;

name = iter[name];

if(typeof(klass.__dict__[name]) == "function") {

get_attribute( object,name );

}

name = backup;

}

init = get_attribute( object,"__init__" );

if(init) {

init.apply( undefined,arguments );

}

return object;

}

__call__.NAME = "__call__";

__call__.args_signature = [];

__call__.kwargs_signature = {};

__call__.types_signature = {};

__call__.pythonscript_function=true;

klass.__call__=__call__;

return klass;

}

window["create_class"] = create_class

create_class.NAME = "create_class";

create_class.args_signature = ["class_name","parents","attrs","props"];

create_class.kwargs_signature = {};

create_class.types_signature = {};

var type = 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": {"bases": undefined, "class_dict": undefined}, "args": create_array("ob_or_class_name", "bases", "class_dict")};

signature["function_name"] = "type";

arguments = get_arguments(signature, args, kwargs);

var ob_or_class_name = arguments['ob_or_class_name'];

var bases = arguments['bases'];

var class_dict = arguments['class_dict'];

"\n type(object) -> the object's type\n type(name, bases, dict) -> a new type ## broken? - TODO test\n ";

if(bases === undefined && class_dict === undefined) {

return ob_or_class_name.__class__;

}

else {

return create_class( ob_or_class_name,bases,class_dict );

}

}

window["type"] = type

type.NAME = "type";

type.args_signature = ["ob_or_class_name", "bases", "class_dict"];

type.kwargs_signature = { bases:undefined,class_dict:undefined };

type.types_signature = { bases:"None",class_dict:"None" };

type.pythonscript_function = true;

var getattr = 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": {"property": false}, "args": create_array("ob", "attr", "property")};

signature["function_name"] = "getattr";

arguments = get_arguments(signature, args, kwargs);

var ob = arguments['ob'];

var attr = arguments['attr'];

var property = arguments['property'];

if(property) {

prop = _get_upstream_property( ob.__class__,attr );

if(prop && prop["get"]) {

return prop[ "get" ]( [ob],{ } );

}

else {

console.log("ERROR: getattr property error", prop);

}

}

else {

return get_attribute( ob,attr );

}

}

window["getattr"] = getattr

getattr.NAME = "getattr";

getattr.args_signature = ["ob", "attr", "property"];

getattr.kwargs_signature = { property:false };

getattr.types_signature = { property:"False" };

getattr.pythonscript_function = true;

var setattr = 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": {"property": false}, "args": create_array("ob", "attr", "value", "property")};

signature["function_name"] = "setattr";

arguments = get_arguments(signature, args, kwargs);

var ob = arguments['ob'];

var attr = arguments['attr'];

var value = arguments['value'];

var property = arguments['property'];

if(property) {

prop = _get_upstream_property( ob.__class__,attr );

if(prop && prop["set"]) {

prop[ "set" ]( [ob, value],{ } );

}

else {

console.log("ERROR: setattr property error", prop);

}

}

else {

set_attribute( ob,attr,value );

}

}

window["setattr"] = setattr

setattr.NAME = "setattr";

setattr.args_signature = ["ob", "attr", "value", "property"];

setattr.kwargs_signature = { property:false };

setattr.types_signature = { property:"False" };

setattr.pythonscript_function = true;

var issubclass = function(args, kwargs) {

var i, bases;

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("C", "B")};

signature["function_name"] = "issubclass";

arguments = get_arguments(signature, args, kwargs);

var C = arguments['C'];

var B = arguments['B'];

if(C === B) {

return true;

}

bases = C.__bases__;

i = 0;

while(i < get_attribute(bases, "length")) {

if(get_attribute(issubclass, "__call__")([get_attribute(bases, "__getitem__")([i], Object()), B], Object())) {

return true;

}

i += 1

}

return false;

}

window["issubclass"] = issubclass

issubclass.NAME = "issubclass";

issubclass.args_signature = ["C", "B"];

issubclass.kwargs_signature = { };

issubclass.types_signature = { };

issubclass.pythonscript_function = true;

var isinstance = function(args, kwargs) {

var ob_class;

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("ob", "klass")};

signature["function_name"] = "isinstance";

arguments = get_arguments(signature, args, kwargs);

var ob = arguments['ob'];

var klass = arguments['klass'];

ob_class = ob.__class__;

if(ob_class === undefined) {

return false;

}

else {

return get_attribute(issubclass, "__call__")([ob_class, klass], Object());

}

}

window["isinstance"] = isinstance

isinstance.NAME = "isinstance";

isinstance.args_signature = ["ob", "klass"];

isinstance.kwargs_signature = { };

isinstance.types_signature = { };

isinstance.pythonscript_function = true;

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.types_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.types_signature = { };

float.pythonscript_function = true;

var round = function(args, kwargs) {

var b;

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", "places")};

signature["function_name"] = "round";

arguments = get_arguments(signature, args, kwargs);

var a = arguments['a'];

var places = arguments['places'];

b = "" + a;

if(b.indexOf(".") == -1) {

return a;

}

else {

c = b.split( "." );

x = c[ 0 ];

y = c[ 1 ].substring( 0,places );

return parseFloat( x + "." + y );

}

}

window["round"] = round

round.NAME = "round";

round.args_signature = ["a", "places"];

round.kwargs_signature = { };

round.types_signature = { };

round.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.types_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(a) {

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

return false;

}

else {

return true;

}

}

func.NAME = "func";

func.args_signature = ["a"];

func.kwargs_signature = {};

func.types_signature = {};

String.prototype.__contains__=func;

var func = function(index) {

return this[ index ];

}

func.NAME = "func";

func.args_signature = ["index"];

func.kwargs_signature = {};

func.types_signature = {};

String.prototype.get=func;

var func = function(self) {

return get_attribute(Iterator, "__call__")([this, 0], Object());

}

func.NAME = "func";

func.args_signature = ["self"];

func.kwargs_signature = {};

func.types_signature = {};

String.prototype.__iter__=func;

var func = function(idx) {

return this[ idx ];

}

func.NAME = "func";

func.args_signature = ["idx"];

func.kwargs_signature = {};

func.types_signature = {};

String.prototype.__getitem__=func;

var func = function() {

return this.length;

}

func.NAME = "func";

func.args_signature = [];

func.kwargs_signature = {};

func.types_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 = {};

func.types_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 = {};

func.types_signature = {};

String.prototype.endswith=func;

var func = function(a) {

var i, arr, out;

out = "";

if(a instanceof Array) {

arr = a;

}

else {

arr = a.__dict__.js_object;

}

i = 0;

var iter = arr;

if (! (iter instanceof Array) ) { iter = Object.keys(iter) }

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 = {};

func.types_signature = {};

String.prototype.join=func;

var func = function() {

return this.toUpperCase( );

}

func.NAME = "func";

func.args_signature = [];

func.kwargs_signature = {};

func.types_signature = {};

String.prototype.upper=func;

var func = function() {

return this.toLowerCase( );

}

func.NAME = "func";

func.args_signature = [];

func.kwargs_signature = {};

func.types_signature = {};

String.prototype.lower=func;

var func = function(a) {

return this.indexOf( a );

}

func.NAME = "func";

func.args_signature = ["a"];

func.kwargs_signature = {};

func.types_signature = {};

String.prototype.index=func;

var func = function() {

var digits;

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

var iter = this;

if (! (iter instanceof Array) ) { iter = Object.keys(iter) }

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;

}