# PythonJS builtins

# by Amirouche Boubekki and Brett Hartshorn - copyright 2013

# License: "New BSD"

pythonjs.configure( runtime_exceptions=False )

pythonjs.configure( direct_operator='+' )

pythonjs.configure( direct_operator='*' )

pythonjs.configure( direct_keys=True )

_PythonJS_UID = 0

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

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

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

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

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

with javascript:

def __gpu_object(cls, struct_name, data_name):

cls.prototype.__struct_name__ = struct_name

cls.prototype.__struct_data__ = data_name

with lowlevel:

gpu = {

'object' : __gpu_object

}

def glsljit_runtime(header):

return new( GLSLJITRuntime(header) )

class GLSLJITRuntime:

def __init__(self, header):

self.header = header

self.shader = []

self.object_packagers = []

self.struct_types = {}

self.glsltypes = ['vec2', 'vec3', 'vec4', 'mat4']

self.matrices = []

def compile_header(self):

a = [] ## insert structs at top of header

for sname in self.struct_types:

if sname in self.glsltypes:

pass

else:

a.push( self.struct_types[sname]['code'] )

## calls get_global_id, see WebCLGL API docs. ##

a.push('int matrix_index() { return int(get_global_id().y*%s.0); }' %self.matrices.length)

a.push('int matrix_row() { return int(get_global_id().x*4.0); }') ## returns: 0, 1, 2, 3

a = '\n'.join(a)

## code in header could be methods that reference the struct types above.

b = "\n".join(self.header)

return '\n'.join([a,b])

def compile_main(self):

return '\n'.join(self.shader)

def push(self, s):

self.shader.push(s)

def define_structure(self, ob):

struct_name = None

#if Object.hasOwnProperty.call(ob,'__struct_name__'):

if ob.__struct_name__:

struct_name = ob.__struct_name__

if struct_name in self.struct_types:

return struct_name

arrays = []

floats = []

integers = []

structs = []

struct_type = [] ## fallback for javascript objects

if struct_name and struct_name in self.glsltypes:

return struct_name

#for key in ob.keys():

for key in dir( ob ):

if key.length==1 and key in '0123456789':

raise RuntimeError(key)

t = typeof( ob[key] )

if t=='object' and instanceof(ob[key], Array) and ob[key].length and typeof(ob[key][0])=='number':

struct_type.push( 'ARY_'+key )

arrays.push(key)

elif t=='number':

struct_type.push( 'NUM_'+key)

floats.push(key)

elif instanceof(ob[key], Int16Array):

struct_type.push( 'INT_'+key)

if ob[key].length == 1:

integers.push(key)

else:

pass ## TODO int16array

elif t=='object' and ob[key].__struct_name__:

struct_type.push( 'S_'+key)

structs.push( key )

if ob[key].__struct_name__ not in self.struct_types:

if ob[key].__struct_name__ in self.glsltypes:

pass

else:

self.define_structure( ob[key] )

if struct_name is None:

#print('DEGUG: new struct name', ob.__struct_name__)

#print(ob)

struct_name = ''.join( struct_type )

ob.__struct_name__ = struct_name

if struct_name not in self.struct_types:

member_list = []

for key in integers:

member_list.append('int '+key+';')

for key in floats:

member_list.append('float '+key+';')

for key in arrays:

arr = ob[key]

member_list.append('float '+key+'['+arr.length+'];')

for key in structs:

subtype = ob[key].__struct_name__

member_list.append( subtype+' '+key+';')

if len(member_list)==0:

raise RuntimeError(struct_name)

members = ''.join(member_list)

code = 'struct ' +struct_name+ ' {' +members+ '};'

#print('-------struct glsl code-------')

#print(code)

#print('------------------------------')

self.struct_types[ struct_name ] = {

'arrays' : arrays,

'floats' : floats,

'integers': integers,

'structs' : structs,

'code' : code

}

return struct_name

def structure(self, ob, name):

wrapper = None

if instanceof(ob, Object):

pass

elif ob.__class__ is dict:

wrapper = ob

ob = ob[...]

sname = self.define_structure(ob)

if wrapper:

wrapper.__struct_name__ = sname

args = []

stype = self.struct_types[ sname ]

# if stype is None: ## TODO fix me

if sname not in self.struct_types:

if sname in self.glsltypes:

if sname == 'mat4':

if ob.__struct_data__:

o = ob[ ob.__struct_data__ ]

else:

o = ob

for i in range(o.length):

value = o[i] +''

if '.' not in value: value += '.0'

args.push( value )

else:

raise RuntimeError('no method to pack structure: ' +sname)

if stype:

for key in stype['integers']:

args.push( ob[key][0]+'' )

for key in stype['floats']:

value = ob[key] + ''

if '.' not in value:

value += '.0'

args.push( value )

for key in stype['arrays']:

#args.push( '{'+ob[key].toString()+ '}') ## this will not work

## arrays need to be assigned to a local variable before passing

## it to the struct constructor.

aname = '_'+key+name

self.array(ob[key], aname)

args.push( aname )

for key in stype['structs']:

aname = '_'+key+name

self.structure(ob[key], aname)

args.push( aname )

args = ','.join(args)

self.shader.push( sname + ' ' +name+ '=' +sname+ '(' +args+ ');' )

def int16array(self, ob, name):

a = ['int ' + name + '[' + ob.length + ']']

i = 0

while i < ob.length:

a.push(';'+name+'['+i+']='+ob[i])

i += 1

self.shader.push( ''.join(a) )

def array(self, ob, name):

if instanceof(ob[0], Array):

a = [] #'float ' + name + '[' + ob.length + ']']

i = 0

while i < ob.length:

subarr = ob[i]

subname = '%s_%s'%(name,i)

if a.length==0:

a.append('float ' + subname + '[' + subarr.length + ']')

else:

a.append(';float ' + subname + '[' + subarr.length + ']')

j = 0

while j < subarr.length:

v = subarr[j] + ''

if '.' not in v:

v += '.0'

a.push(';'+subname+'['+j+']='+v)

j += 1

i += 1

self.shader.push( ''.join(a) )

elif instanceof(ob[0], Object) or ob[0].__class__ is dict:

i = 0

while i < ob.length:

self.structure( ob[i], name+'_'+i)

i += 1

else:

a = ['float ' + name + '[' + ob.length + '];']

i = 0

while i < ob.length:

a.push(name+'['+i+']='+ob[i] + ';')

i += 1

self.shader.push( ''.join(a) )

def object(self, ob, name):

for p in self.object_packagers:

cls, func = p

if instanceof(ob, cls):

return func(ob)

def unpack_array2d(self, arr, dims):

if typeof(dims)=='number':

return arr

w,h = dims

row = []

rows = [row]

for value in arr:

row.append(value)

if row.length >= w:

row = []

rows.append(row)

rows.pop()

if rows.length != h:

print('ERROR: __unpack_array2d, invalid height.')

return rows

def unpack_vec4(self, arr, dims):

if typeof(dims)=='number':

w = dims

h = 1

else:

w,h = dims

rows = []

i=0

for y in range(h):

row = []

rows.append( row )

for x in range(w):

vec = []

for j in range(4):

vec.append( arr[i])

i += 1

row.append( vec )

if rows.length != h:

print('ERROR: __unpack_vec4, invalid height.')

return rows

def unpack_mat4(self, arr):

i = 0

for mat in self.matrices:

for j in range(16):

mat[j] = arr[i]

i += 1

return self.matrices

with lowlevel:

def __getattr__(ob, a ):

if ob.__getattr__:

return JS("ob.__getattr__(a)")

#else:

# raise AttributeError(a)

def __test_if_true__( ob ):

if ob is True:

return True

elif ob is False:

return False

elif typeof(ob) == 'string':

return ob.length != 0

elif not ob:

return False

elif instanceof(ob, Array):

return ob.length != 0

elif typeof(ob) == 'function':

return True

elif ob.__class__ and ob.__class__ is dict: #isinstance(ob, dict):

return Object.keys( ob[...] ).length != 0

elif instanceof(ob, Object):

return Object.keys(ob).length != 0

else:

return True

def __replace_method(ob, a, b):

## this is required because string.replace in javascript only replaces the first occurrence

if typeof(ob) == 'string':

return ob.split(a).join(b)

else:

return ob.replace(a,b)

def __split_method( ob, delim ):

## special case because calling string.split() without args its not the same as python,

## and we do not want to touch the default string.split implementation.

if typeof(ob) == 'string':

if delim is undefined:

return ob.split(' ')

else:

return ob.split( delim )

else:

if delim is undefined:

return ob.split()

else:

return ob.split( delim )

with javascript:

def __is_some_array( ob ):

if typeof(NodeList) == 'function': ## NodeList is only available in browsers

dom_array_types = [ NodeList, FileList, ClientRectList, DOMStringList, HTMLCollection, HTMLAllCollection, SVGElementInstanceList, SVGNumberList, SVGTransformList]

if typeof(DataTransferItemList) == 'function': ## missing in NodeWebkit

dom_array_types.append( DataTransferItemList )

for t in dom_array_types:

if instanceof(ob, t):

return True

return False

def __is_typed_array( ob ):

if instanceof( ob, Int8Array ) or instanceof( ob, Uint8Array ):

return True

elif instanceof( ob, Int16Array ) or instanceof( ob, Uint16Array ):

return True

elif instanceof( ob, Int32Array ) or instanceof( ob, Uint32Array ):

return True

elif instanceof( ob, Float32Array ) or instanceof( ob, Float64Array ):

return True

else:

return False

def __js_typed_array( t, a ):

if t == 'i':

arr = new( Int32Array(a.length) )

arr.set( a )

return arr

def __contains__( ob, a ):

t = typeof(ob)

if t == 'string':

if ob.indexOf(a) == -1: return False

else: return True

elif t == 'number':

raise TypeError

elif __is_typed_array(ob):

for x in ob:

if x == a:

return True

return False

elif ob.__contains__:

return ob.__contains__(a)

elif instanceof(ob, Object) and Object.hasOwnProperty.call(ob, a):

return True

else:

return False

def __add_op(a, b):

## 'number' is already checked before this gets called (ternary op)

## but it can still appear here when called from an inlined lambda

t = typeof(a)

if t == 'string' or t == 'number':

return JS("a+b")

elif instanceof(a, Array):

c = []

c.extend(a)

c.extend(b)

return c

elif a.__add__:

return a.__add__(b)

else:

raise TypeError('invalid objects for addition')

def __mul_op(a, b):

t = typeof(a)

if t == 'number':

return JS("a * b")

elif t == 'string':

arr = []

for i in range(b):

arr.append(a)

return ''.join(arr)

elif instanceof(a, Array):

c = []

for i in range(b):

c.extend(a)

return c

elif a.__mul__:

return a.__mul__(b)

else:

raise TypeError('invalid objects for multiplication')

def __jsdict( items ):

d = JS("{}")

for item in items:

key = item[0]

if key.__uid__:

key = key.__uid__

d[ key ] = item[1]

return d

def __jsdict_get(ob, key, default_value):

if instanceof(ob, Object):

if JS("key in ob"): return ob[key]

return default_value

else: ## PythonJS object instance ##

## this works because instances from PythonJS are created using Object.create(null) ##

if default_value is not undefined:

return JS("ob.get(key, default_value)")

else:

return JS("ob.get(key)")

def __jsdict_set(ob, key, value):

if instanceof(ob, Object):

ob[ key ] = value

else: ## PythonJS object instance ##

## this works because instances from PythonJS are created using Object.create(null) ##

JS("ob.set(key,value)")

def __jsdict_keys(ob):

if instanceof(ob, Object):

return JS("Object.keys( ob )")

else: ## PythonJS object instance ##

## this works because instances from PythonJS are created using Object.create(null) ##

return JS("ob.keys()")

def __jsdict_values(ob):

if instanceof(ob, Object):

arr = []

for key in ob:

if ob.hasOwnProperty(key):

value = ob[key]

arr.push( value )

return arr

else: ## PythonJS object instance ##

## this works because instances from PythonJS are created using Object.create(null) ##

return JS("ob.values()")

def __jsdict_items(ob):

## `ob.items is None` is for: "self.__dict__.items()" because self.__dict__ is not actually a dict

if instanceof(ob, Object) or ob.items is undefined: ## in javascript-mode missing attributes do not raise AttributeError

arr = []

for key in ob:

if Object.hasOwnProperty.call(ob, key):

value = ob[key]

arr.push( [key,value] )

return arr

else: ## PythonJS object instance ##

return JS("ob.items()")

def __jsdict_pop(ob, key, _default=None):

if instanceof(ob, Array):

if ob.length:

## note: javascript array.pop only pops the end of an array

if key is undefined:

return inline("ob.pop()")

else:

return ob.splice( key, 1 )[0]

else:

raise IndexError(key)

elif instanceof(ob, Object):

if JS("key in ob"):

v = ob[key]

JS("delete ob[key]")

return v

elif _default is undefined:

raise KeyError(key)

else:

return _default

else: ## PythonJS object instance ##

## this works because instances from PythonJS are created using Object.create(null) ##

return JS("ob.pop(key, _default)")

def dir(ob):

if instanceof(ob, Object):

return JS("Object.keys( ob )")

else:

return __object_keys__(ob)

def __object_keys__(ob):

'''

notes:

. Object.keys(ob) will not work because we create PythonJS objects using `Object.create(null)`

. this is different from Object.keys because it traverses the prototype chain.

'''

arr = []

JS('for (var key in ob) { arr.push(key) }')

return arr

def __bind_property_descriptors__(o, klass):

for name in klass.__properties__:

desc = {"enumerable":True}

prop = klass.__properties__[ name ]

if prop['get']:

desc['get'] = __generate_getter__(klass, o, name)

if prop['set']:

desc['set'] = __generate_setter__(klass, o, name)

Object.defineProperty( o, name, desc )

for base in klass.__bases__:

__bind_property_descriptors__(o, base)

def __generate_getter__(klass, o, n):

return lambda : klass.__properties__[ n ]['get']([o],{})

def __generate_setter__(klass, o, n):

return lambda v: klass.__properties__[ n ]['set']([o,v],{})

def __sprintf(fmt, args):

## note: '%sXXX%s'.split().length != args.length

## because `%s` at the start or end will split to empty chunks ##

if instanceof(args, Array):

chunks = fmt.split('%s')

arr = []

for i,txt in enumerate(chunks):

arr.append( txt )

if i >= args.length:

break

item = args[i]

if typeof(item) == 'string':

arr.append( item )

elif typeof(item) == 'number':

arr.append( ''+item )

else:

arr.append( Object.prototype.toString.call(item) )

return ''.join(arr)

else:

return fmt.replace('%s', args)

def __create_class__(class_name, parents, attrs, props):

"""Create a PythonScript class"""

#if attrs.__metaclass__:

# metaclass = attrs.__metaclass__

# attrs.__metaclass__ = None

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

klass = Object.create(null)

klass.__bases__ = parents

klass.__name__ = class_name

#klass.__dict__ = attrs

klass.__unbound_methods__ = Object.create(null)

klass.__all_method_names__ = []

klass.__properties__ = props

klass.__attributes__ = attrs

for key in attrs:

if typeof( attrs[key] ) == 'function':

klass.__all_method_names__.push( key )

f = attrs[key]

if hasattr(f, 'is_classmethod') and f.is_classmethod:

pass

elif hasattr(f, 'is_staticmethod') and f.is_staticmethod:

pass

else:

klass.__unbound_methods__[key] = attrs[key]

if key == '__getattribute__': continue

klass[key] = attrs[key]

## this is needed for fast lookup of property names in __set__ ##

klass.__setters__ = []

klass.__getters__ = []

for name in klass.__properties__:

prop = klass.__properties__[name]

klass.__getters__.push( name )

if prop['set']:

klass.__setters__.push( name )

for base in klass.__bases__:

Array.prototype.push.apply( klass.__getters__, base.__getters__ )

Array.prototype.push.apply( klass.__setters__, base.__setters__ )

Array.prototype.push.apply( klass.__all_method_names__, base.__all_method_names__ )

def __call__():

"""Create a PythonJS object"""

object = Object.create(null) ## this makes pythonjs object not compatible with things like: Object.hasOwnProperty

object.__class__ = klass

object.__dict__ = object

## we need __dict__ so that __setattr__ can still set attributes using `old-style`: self.__dict__[n]=x

#Object.defineProperty(

# object,

# '__dict__',

# {enumerable:False, value:object, writeable:False, configurable:False}

#)

has_getattribute = False

has_getattr = False

for name in klass.__all_method_names__:

if name == '__getattribute__':

has_getattribute = True

elif name == '__getattr__':

has_getattr = True

else:

wrapper = __get__(object, name)

if not wrapper.is_wrapper:

print 'RUNTIME ERROR: failed to get wrapper for:',name

## to be safe the getters come after other methods are cached ##

if has_getattr:

__get__(object, '__getattr__')

if has_getattribute:

__get__(object, '__getattribute__')

__bind_property_descriptors__(object, klass)

if object.__init__:

object.__init__.apply(this, arguments)

#object.__init__.call(this,args, kwargs)

return object

__call__.is_wrapper = True

klass.__call__ = __call__

return klass

def type(ob_or_class_name, bases=None, class_dict=None):

'''

type(object) -> the object's type

type(name, bases, dict) -> a new type ## broken? - TODO test

'''

with javascript:

if bases is None and class_dict is None:

return ob_or_class_name.__class__

else:

return create_class(ob_or_class_name, bases, class_dict) ## TODO rename create_class to _pyjs_create_class

def hasattr(ob, attr):

## TODO check parent classes for attr

with javascript:

return Object.hasOwnProperty.call(ob, attr)

def getattr(ob, attr, property=False):

with javascript:

if property:

prop = _get_upstream_property( ob.__class__, attr )

if prop and prop['get']:

return prop['get']( [ob], {} )

else:

print "ERROR: getattr property error", prop

else:

return __get__(ob, attr)

def setattr(ob, attr, value, property=False):

with javascript:

if property:

prop = _get_upstream_property( ob.__class__, attr )

if prop and prop['set']:

prop['set']( [ob, value], {} )

else:

print "ERROR: setattr property error", prop

else:

__set__(ob, attr, value)

def issubclass(C, B):

if C is B:

return True

with javascript: bases = C.__bases__ ## js-array

i = 0

while i < bases.length:

if issubclass( bases[i], B ):

return True

i += 1

return False

def isinstance( ob, klass):

with javascript:

if ob is undefined or ob is null:

return False

elif instanceof(ob, Array) and klass is list:

return True

#elif klass is dict and instanceof(ob, Object): ## this is safe because instances created with Object.create(null) are not instances-of Object

# if instanceof(ob, Array):

# return False

# elif ob.__class__:

# return False

# else:

# return True

elif not Object.hasOwnProperty.call(ob, '__class__'):

return False

ob_class = ob.__class__

if ob_class is undefined:

return False

else:

return issubclass( ob_class, klass )

def int(a):

with javascript:

a = Math.round(a)

if isNaN(a):

raise ValueError('not a number')

return a

with javascript:

def int16(a): ## used by glsljit when packing structs.

arr = new(Int16Array(1))

arr[0]=a

return arr

def float(a):

with javascript:

a = Number(a)

if isNaN(a):

raise ValueError('not a number')

return a

def round(a, places):

with javascript:

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 )

def str(s):

return ''+s

def _setup_str_prototype():

'''

Extend JavaScript String.prototype with methods that implement the Python str API.

The decorator @String.prototype.[name] assigns the function to the prototype,

and ensures that the special 'this' variable will work.

'''

with javascript:

@String.prototype.__contains__

def func(a):

if this.indexOf(a) == -1: return False

else: return True

@String.prototype.get

def func(index):

if index < 0:

return this[ this.length + index ]

else:

return this[ index ]

@String.prototype.__iter__

def func(self):

with python:

return Iterator(this, 0)

@String.prototype.__getitem__

def func(idx):

if idx < 0:

return this[ this.length + idx ]

else:

return this[ idx ]

@String.prototype.__len__

def func():

return this.length

@String.prototype.__getslice__

def func(start, stop, step):

if start is undefined and stop is undefined and step == -1:

return this.split('').reverse().join('')

else:

if stop < 0:

stop = this.length + stop

return this.substring(start, stop)

@String.prototype.splitlines

def func():

return this.split('\n')

@String.prototype.strip

def func():

return this.trim() ## missing in IE8

@String.prototype.startswith

def func(a):

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

return True

else:

return False

@String.prototype.endswith

def func(a):

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

return True

else:

return False

@String.prototype.join

def func(a):

out = ''

if instanceof(a, Array):

arr = a

else:

arr = a[...]

i = 0

for value in arr:

out += value

i += 1

if i < arr.length:

out += this

return out

@String.prototype.upper

def func():

return this.toUpperCase()

@String.prototype.lower

def func():

return this.toLowerCase()

@String.prototype.index

def func(a):

i = this.indexOf(a)

if i == -1:

raise ValueError(a + ' - not in string')

return i

@String.prototype.find

def func(a):

return this.indexOf(a)

@String.prototype.isdigit

def func():

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

for char in this:

if char in digits: pass

else: return False

return True

@String.prototype.isnumber

def func():

digits = ['0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '.']

for char in this:

if char in digits: pass

else: return False

return True

## TODO - for now these are just dummy functions.

@String.prototype.decode

def func(encoding):

return this

@String.prototype.encode

def func(encoding):

return this

@String.prototype.format

def func(fmt):

r = this

keys = Object.keys(fmt)

for key in keys:

r = r.split(key).join(fmt[key])

r = r.split('{').join('').split('}').join('')

return r

_setup_str_prototype()

## note Arrays in javascript by default sort by string order, even if the elements are numbers.

with javascript:

def __sort_method(ob):

if instanceof(ob, Array):

def f(a,b):

if a < b:

return -1

elif a > b:

return 1

else:

return 0

return JS("ob.sort( f )")

else:

return JS("ob.sort()")

def _setup_array_prototype():

with javascript:

@Array.prototype.jsify

def func():

i = 0

while i < this.length:

item = this[ i ]

if typeof(item) == 'object':

if item.jsify:

this[ i ] = item.jsify()

i += 1

return this

@Array.prototype.__contains__

def func(a):

if this.indexOf(a) == -1: return False

else: return True

@Array.prototype.__len__

def func():

return this.length

@Array.prototype.get

def func(index):

return this[ index ]

@Array.prototype.__getitem__

def __getitem__(index):

if index < 0: index = this.length + index

return this[index]

@Array.prototype.__setitem__

def __setitem__(index, value):

if index < 0: index = this.length + index

this[ index ] = value

@Array.prototype.__iter__

def func():

with python:

return Iterator(this, 0)

@Array.prototype.__getslice__

def func(start, stop, step):

arr = [] #new(Array(this.length))

start = start | 0

stop = stop | this.length

if start < 0:

start = this.length + start

if stop < 0:

stop = this.length + stop

#reverse = step < 0 ## in javascript `null<0` and `undefined<0` are false

#reverse = False

if typeof(step)=='number':

#reverse = step < 0

#if reverse:

if step < 0:

#step = Math.abs(step)

i = start

while i >= 0:

arr.push( this[i] )

i += step

return arr

else:

i = start

n = stop

while i < n: