__NULL_OBJECT__ = Object.create(null);

__WEBWORKER__ = false;

__NODEJS__ = false;

__BROWSER__ = false;

if (typeof(process)!=="undefined")

{

__NODEJS__ = true;

}

if (typeof(window)!=="undefined")

{

__BROWSER__ = true;

}

if (typeof(importScripts)==="function")

{

__WEBWORKER__ = true;

}

/* Used to fix a bug/feature of Javascript where new Array(number)

created a array with number of undefined elements which is not

what we want */

var __create_array__ = function()

{

var i,array;

array = [];

i = 0;

while (( i ) < arguments.length)

{

array.push(arguments[i]);

i += 1;

}

return array;

}

/* Retrieve an attribute, method, property, or wrapper function.

method are actually functions which are converted to methods by

prepending their arguments with the current object. Properties are

not functions!

DOM support:

http://stackoverflow.com/questions/14202699/document-createelement-not-working

https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/instanceof

Direct JavaScript Calls:

if an external javascript function is found, and it was not a wrapper that was generated here,

check the function for a 'cached_wrapper' attribute, if none is found then generate a new

wrapper, cache it on the function, and return the wrapper. */

var __get__ = function(object, attribute, error_message)

{

if (( object ) === null)

{

if (error_message)

{

throw new AttributeError(("(`null` has no attributes) " + error_message));

}

else

{

throw new AttributeError(("null object (None) has no attribute: " + attribute));

}

}

else

{

if (( object ) === undefined)

{

if (error_message)

{

throw new AttributeError(("(`undefined` has no attributes) " + error_message));

}

else

{

throw new AttributeError(("undefined has no attribute: " + attribute));

}

}

}

if (attribute==="__call__")

{

if (object.pythonscript_function || object.is_wrapper)

{

return object;

}

else

{

if (object.cached_wrapper)

{

return object.cached_wrapper;

}

else

{

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

{

var wrapper = function(args, kwargs)

{

var i,arg,keys;

if (args!==null)

{

i = 0;

while (( i ) < args.length)

{

arg = args[i];

if (arg && (typeof(arg)==="object"))

{

if (arg.jsify)

{

args[i] = arg.jsify();

}

}

i += 1;

}

}

if (kwargs!==null)

{

keys = __object_keys__(kwargs);

if (keys.length!==0)

{

args.push(kwargs);

i = 0;

while (( i ) < keys.length)

{

arg = kwargs[keys[i]];

if (arg && (typeof(arg)==="object"))

{

if (arg.jsify)

{

kwargs[keys[i]] = arg.jsify();

}

}

i += 1;

}

}

}

return object.apply(null, args);

}

wrapper.is_wrapper = true;

object.cached_wrapper = wrapper;

return wrapper;

}

}

}

}

if (Object.hasOwnProperty.call(object, "__getattribute__"))

{

return object.__getattribute__(attribute);

}

var attr;

attr = object[attribute];

if (( __NODEJS__ ) === false && ( __WEBWORKER__ ) === false)

{

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

{

if (attr.pythonscript_function === undefined && attr.is_wrapper === undefined)

{

if (attr.prototype instanceof Object && ( Object.keys(attr.prototype).length ) > 0)

{

return attr;

}

var wrapper = function(args, kwargs)

{

var i,arg,keys;

if (args!==null)

{

i = 0;

while (( i ) < args.length)

{

arg = args[i];

if (arg && (typeof(arg)==="object"))

{

if (arg.jsify)

{

args[i] = arg.jsify();

}

}

i += 1;

}

}

if (kwargs!==null)

{

keys = __object_keys__(kwargs);

if (keys.length!==0)

{

args.push(kwargs);

i = 0;

while (( i ) < keys.length)

{

arg = kwargs[keys[i]];

if (arg && (typeof(arg)==="object"))

{

if (arg.jsify)

{

kwargs[keys[i]] = arg.jsify();

}

}

i += 1;

}

}

}

return attr.apply(object, args);

}

wrapper.is_wrapper = true;

wrapper.wrapped = attr;

return wrapper;

}

else

{

if (attr.is_classmethod)

{

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, {}];

}

if (object.__class__)

{

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

}

else

{

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

}

return attr.apply(this, args);

}

method.is_wrapper = true;

object[attribute] = method;

return method;

}

else

{

return attr;

}

}

}

else

{

return attr;

}

}

var __class__,bases;

__class__ = object.__class__;

if (__class__)

{

if (( attribute ) in __class__.__properties__)

{

return __class__.__properties__[attribute]["get"]([object], {});

}

if (( attribute ) in __class__.__unbound_methods__)

{

attr = __class__.__unbound_methods__[attribute];

if (attr.fastdef)

{

var method = function(args, kwargs)

{

if (arguments && arguments[0])

{

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

return attr.apply(this, arguments);

}

else

{

return attr([object], { });

}

}

}

else

{

var method = function(args, kwargs)

{

if (arguments.length===0)

{

return attr([object], __NULL_OBJECT__);

}

else

{

if (args instanceof Array && ( typeof(kwargs) ) === "object" && (arguments.length===2))

{

args.splice(0, 0, object);

if (( kwargs ) === undefined)

{

return attr(args, __NULL_OBJECT__);

}

else

{

return attr(args, kwargs);

}

}

else

{

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

args.splice(0, 0, object);

args = [args, __NULL_OBJECT__];

return attr.apply(this, args);

}

}

}

}

method.is_wrapper = true;

object[attribute] = method;

return method;

}

attr = __class__[attribute];

if (( attribute ) in __class__)

{

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

{

if (attr.is_wrapper)

{

return attr;

}

else

{

if (attr.fastdef)

{

var method = function(args, kwargs)

{

if (arguments && arguments[0])

{

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

return attr.apply(this, arguments);

}

else

{

return attr([object], { });

}

}

}

else

{

var method = function(args, kwargs)

{

if (arguments.length===0)

{

return attr([object], __NULL_OBJECT__);

}

else

{

if (args instanceof Array && ( typeof(kwargs) ) === "object" && (arguments.length===2))

{

args.splice(0, 0, object);

if (( kwargs ) === undefined)

{

return attr(args, __NULL_OBJECT__);

}

else

{

return attr(args, kwargs);

}

}

else

{

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

args.splice(0, 0, object);

args = [args, __NULL_OBJECT__];

return attr.apply(this, args);

}

}

}

}

}

method.is_wrapper = true;

object[attribute] = method;

return method;

}

else

{

return attr;

}

}

bases = __class__.__bases__;

var __iter1 = bases;

if (! (__iter1 instanceof Array || typeof __iter1 == "string" || __is_typed_array(__iter1) || __is_some_array(__iter1) )) { __iter1 = __object_keys__(__iter1) }

for (var __i1=0; __i1 < __iter1.length; __i1++) {

var base = __iter1[ __i1 ];

attr = _get_upstream_attribute(base, attribute);

if (( attr ) !== undefined)

{

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

{

if (attr.fastdef)

{

var method = function(args, kwargs)

{

if (arguments && arguments[0])

{

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

return attr.apply(this, arguments);

}

else

{

return attr([object], { });

}

}

}

else

{

var method = function(args, kwargs)

{

if (arguments.length===0)

{

return attr([object], __NULL_OBJECT__);

}

else

{

if (args instanceof Array && ( typeof(kwargs) ) === "object" && (arguments.length===2))

{

args.splice(0, 0, object);

if (( kwargs ) === undefined)

{

return attr(args, __NULL_OBJECT__);

}

else

{

return attr(args, kwargs);

}

}

else

{

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

args.splice(0, 0, object);

args = [args, __NULL_OBJECT__];

return attr.apply(this, args);

}

}

}

}

method.is_wrapper = true;

object[attribute] = method;

return method;

}

else

{

return attr;

}

}

}

var __iter2 = bases;

if (! (__iter2 instanceof Array || typeof __iter2 == "string" || __is_typed_array(__iter2) || __is_some_array(__iter2) )) { __iter2 = __object_keys__(__iter2) }

for (var __i2=0; __i2 < __iter2.length; __i2++) {

var base = __iter2[ __i2 ];

var prop;

prop = _get_upstream_property(base, attribute);

if (( prop ) !== undefined)

{

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

}

}

if (( "__getattr__" ) in __class__)

{

return __class__["__getattr__"]([object, attribute], {});

}

var __iter3 = bases;

if (! (__iter3 instanceof Array || typeof __iter3 == "string" || __is_typed_array(__iter3) || __is_some_array(__iter3) )) { __iter3 = __object_keys__(__iter3) }

for (var __i3=0; __i3 < __iter3.length; __i3++) {

var base = __iter3[ __i3 ];

var f;

f = _get_upstream_attribute(base, "__getattr__");

if (( f ) !== undefined)

{

return f([object, attribute], {});

}

}

}

if (attribute==="__getitem__")

{

var wrapper = function(args, kwargs)

{

v = object[args[0]];

if (( v ) === undefined)

{

throw new KeyError(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;

}

}

if (typeof(object, "function") && object.is_wrapper)

{

return object.wrapped[attribute];

}

if ((attribute==="__iter__") && object instanceof Object)

{

var wrapper = function(args, kwargs)

{

return new __ArrayIterator(Object.keys(object), 0);

}

wrapper.is_wrapper = true;

return wrapper;

}

if ((attribute==="__contains__") && object instanceof Object)

{

var wrapper = function(args, kwargs)

{

return (Object.keys(object).indexOf(args[0])!==-1);

}

wrapper.is_wrapper = true;

return wrapper;

}

if (( attr ) === undefined)

{

if (error_message)

{

throw new AttributeError(error_message);

}

else

{

throw new AttributeError(attribute);

}

}

else

{

return attr;

}

}

var _get_upstream_attribute = function(base, attr)

{

if (( attr ) in base)

{

return base[attr];

}

var __iter4 = base.__bases__;

if (! (__iter4 instanceof Array || typeof __iter4 == "string" || __is_typed_array(__iter4) || __is_some_array(__iter4) )) { __iter4 = __object_keys__(__iter4) }

for (var __i4=0; __i4 < __iter4.length; __i4++) {

var parent = __iter4[ __i4 ];

return _get_upstream_attribute(parent, attr);

}

}

var _get_upstream_property = function(base, attr)

{

if (( attr ) in base.__properties__)

{

return base.__properties__[attr];

}

var __iter5 = base.__bases__;

if (! (__iter5 instanceof Array || typeof __iter5 == "string" || __is_typed_array(__iter5) || __is_some_array(__iter5) )) { __iter5 = __object_keys__(__iter5) }

for (var __i5=0; __i5 < __iter5.length; __i5++) {

var parent = __iter5[ __i5 ];

return _get_upstream_property(parent, attr);

}

}

/* __setattr__ is always called when an attribute is set,

unlike __getattr__ that only triggers when an attribute is not found,

this asymmetry is in fact part of the Python spec.

note there is no __setattribute__

In normal Python a property setter is not called before __setattr__,

this is bad language design because the user has been more explicit

in having the property setter.

In PythonJS, property setters are called instead of __setattr__. */

var __set__ = function(object, attribute, value)

{

if (( "__class__" ) in object && (object.__class__.__setters__.indexOf(attribute)!==-1))

{

object[attribute] = value;

}

else

{

if (( "__setattr__" ) in object)

{

object.__setattr__(attribute, value);

}

else

{

object[attribute] = value;

}

}

}

/* Based on ``signature`` and ``args``, ``kwargs`` parameters retrieve

the actual parameters.

This will set default keyword arguments and retrieve positional arguments

in kwargs if their called as such */

var __getargs__ = function(func_name, signature, args, kwargs)

{

if (( args ) === null)

{

args = [];

}

if (( kwargs ) === null)

{

kwargs = { };

}

out = { };

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

{

if (signature.vararg)

{

/*pass*/

}

else

{

console.log(("Error in function->" + func_name));

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

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

}

IndexError = function(msg) {this.message = msg || "";}; IndexError.prototype = Object.create(Error.prototype); IndexError.prototype.name = "IndexError";

KeyError = function(msg) {this.message = msg || "";}; KeyError.prototype = Object.create(Error.prototype); KeyError.prototype.name = "KeyError";

ValueError = function(msg) {this.message = msg || "";}; ValueError.prototype = Object.create(Error.prototype); ValueError.prototype.name = "ValueError";

AttributeError = function(msg) {this.message = msg || "";}; AttributeError.prototype = Object.create(Error.prototype);AttributeError.prototype.name = "AttributeError";

RuntimeError = function(msg) {this.message = msg || "";}; RuntimeError.prototype = Object.create(Error.prototype);RuntimeError.prototype.name = "RuntimeError";

var hasattr = function(ob, attr)

{

return Object.hasOwnProperty.call(ob, attr);

}

var len = function(ob)

{

if (ob instanceof Array)

{

return ob.length;

}

else

{

if (__is_typed_array(ob))

{

return ob.length;

}

else

{

if (ob instanceof ArrayBuffer)

{

return ob.byteLength;

}

else

{

if (ob.__len__)

{

return ob.__len__();

}

else

{

return Object.keys(ob).length;

}

}

}

}

}

var func = function(a)

{

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

{

return false;

}

else

{

return true;

}

}

Object.defineProperty(String.prototype, "__contains__", { enumerable:false, value:func, writeable:true, configurable:true });

var func = function(start, stop, step)

{

if (( start ) === undefined && ( stop ) === undefined && (step===-1))

{

return this.split("").reverse().join("");

}

else

{

if (( stop ) < 0)

{

stop = (this.length + stop);

}

return this.substring(start, stop);

}

}

Object.defineProperty(String.prototype, "__getslice__", { enumerable:false, value:func, writeable:true, configurable:true });

var func = function()

{

return this.split("\n");

}

Object.defineProperty(String.prototype, "splitlines", { enumerable:false, value:func, writeable:true, configurable:true });

var func = function()

{

return this.trim();

}

Object.defineProperty(String.prototype, "strip", { enumerable:false, value:func, writeable:true, configurable:true });

var func = function(a)

{

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

{

return true;

}

else

{

return false;

}

}

Object.defineProperty(String.prototype, "startswith", { enumerable:false, value:func, writeable:true, configurable:true });

var func = function(a)

{

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

{

return true;

}

else

{

return false;

}

}

Object.defineProperty(String.prototype, "endswith", { enumerable:false, value:func, writeable:true, configurable:true });

var func = function(a)

{

var i,arr,out;

out = "";

if (a instanceof Array)

{

arr = a;

}

else

{

arr = a["$wrapped"];

}

i = 0;

var __iter1 = arr;

if (! (__iter1 instanceof Array || typeof __iter1 == "string" || __is_typed_array(__iter1) || __is_some_array(__iter1) )) { __iter1 = __object_keys__(__iter1) }

for (var __i1=0; __i1 < __iter1.length; __i1++) {

var value = __iter1[ __i1 ];

out += value;

i += 1;

if (( i ) < arr.length)

{

out += this;

}

}

return out;

}

Object.defineProperty(String.prototype, "join", { enumerable:false, value:func, writeable:true, configurable:true });

var func = function()

{

return this.toUpperCase();

}

Object.defineProperty(String.prototype, "upper", { enumerable:false, value:func, writeable:true, configurable:true });

var func = function()

{

return this.toLowerCase();

}

Object.defineProperty(String.prototype, "lower", { enumerable:false, value:func, writeable:true, configurable:true });

var func = function(a)

{

var i;

i = this.indexOf(a);

if (i===-1)

{

throw new ValueError((a + " - not in string"));

}

return i;

}

Object.defineProperty(String.prototype, "index", { enumerable:false, value:func, writeable:true, configurable:true });

var func = function(a)

{

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

{

return false;

}

else

{

return true;

}

}

Object.defineProperty(Array.prototype, "__contains__", { enumerable:false, value:func, writeable:true, configurable:true });

var func = function(start, stop, step)

{

var i,arr,n;

arr = [];

start = (start | 0);

if (( stop ) === undefined)

{

stop = this.length;

}

if (( start ) < 0)

{

start = (this.length + start);

}

if (( stop ) < 0)

{

stop = (this.length + stop);

}

if (typeof(step)==="number")

{

if (( step ) < 0)

{

i = start;

while (( i ) >= 0)

{

arr.push(this[i]);

i += step;

}

return arr;

}

else

{

i = start;

n = stop;

while (( i ) < n)

{

arr.push(this[i]);

i += step;

}

return arr;

}

}

else

{

i = start;

n = stop;

while (( i ) < n)

{

arr.push(this[i]);

i += 1;

}

return arr;

}

}

Object.defineProperty(Array.prototype, "__getslice__", { enumerable:false, value:func, writeable:true, configurable:true });

var func = function(start, stop, step, items)

{

var arr;

if (( start ) === undefined)

{

start = 0;

}

if (( stop ) === undefined)

{

stop = this.length;

}

arr = [start, (stop - start)];

var __iter2 = items;

if (! (__iter2 instanceof Array || typeof __iter2 == "string" || __is_typed_array(__iter2) || __is_some_array(__iter2) )) { __iter2 = __object_keys__(__iter2) }

for (var __i2=0; __i2 < __iter2.length; __i2++) {

var item = __iter2[ __i2 ];

arr.push(item);

}

this.splice.apply(this, arr);

}

Object.defineProperty(Array.prototype, "__setslice__", { enumerable:false, value:func, writeable:true, configurable:true });

var func = function(item)

{

this.push(item);

return this;

}

Object.defineProperty(Array.prototype, "append", { enumerable:false, value:func, writeable:true, configurable:true });

var extend = function(other)

{

var __iter3 = other;

if (! (__iter3 instanceof Array || typeof __iter3 == "string" || __is_typed_array(__iter3) || __is_some_array(__iter3) )) { __iter3 = __object_keys__(__iter3) }

for (var __i3=0; __i3 < __iter3.length; __i3++) {

var obj = __iter3[ __i3 ];

this.push(obj);

}

return this;

}

Object.defineProperty(Array.prototype, "extend", { enumerable:false, value:extend, writeable:true, configurable:true });

var func = function(item)

{

var index;

index = this.indexOf(item);

this.splice(index, 1);

}

Object.defineProperty(Array.prototype, "remove", { enumerable:false, value:func, writeable:true, configurable:true });

var insert = function(index, obj)

{