import sys

import types

import collections

import weakref

cdef:

ctypedef unsigned short bool

include "stdlib.pyi"

include "python.pyi"

include "jsbase.pyi"

include "jscontextref.pyi"

include "jsstringref.pyi"

include "jsvalueref.pyi"

include "jsobjectref.pyi"

class NullType(object):

return False

Null = None

Null = NullType()

cdef object _pyWrappedJSObjs = weakref.WeakValueDictionary()

cdef object _pyWrappedPyObjs = {}

cdef object wrapJSObject(JSContextRef jsCtx, JSValueRef jsValue):

cdef object wrapper

try:

return _pyWrappedJSObjs[<long>jsValue]

except KeyError:

pass

if JSObjectIsFunction(jsCtx, jsValue):

wrapper = makeJSFunction(jsCtx, jsValue)

else:

wrapper = makeJSObject(jsCtx, jsValue)

_pyWrappedJSObjs[<long>jsValue] = wrapper

return wrapper

cdef object jsToPython(JSContextRef jsCtx, JSValueRef jsValue):

"""Convert a JavaScript value into a Python value."""

cdef int jsType = JSValueGetType(jsCtx, jsValue)

cdef JSStringRef jsStr

cdef double doubleVal

cdef long intVal

if jsType == kJSTypeUndefined:

return None

if jsType == kJSTypeNull:

return Null

elif jsType == kJSTypeBoolean:

return types.BooleanType(JSValueToBoolean(jsCtx, jsValue))

elif jsType == kJSTypeNumber:

# If the value is actually an integer, return it is an

# instance of Python's int type.

doubleVal = JSValueToNumber(jsCtx, jsValue, NULL)

intVal = <long>doubleVal

if intVal == doubleVal:

return intVal

else:

return doubleVal

elif jsType == kJSTypeString:

jsStr = JSValueToStringCopy(jsCtx, jsValue, NULL)

try:

return PyUnicode_DecodeUTF16(<Py_UNICODE*>JSStringGetCharactersPtr(jsStr),

JSStringGetLength(jsStr) * 2,

NULL, 0)

finally:

JSStringRelease(jsStr)

elif JSValueIsObjectOfClass(jsCtx, jsValue, pyObjectClass):

# This is a wrapped Python object. Just unwrap it.

return <object>JSObjectGetPrivate(jsValue)

else:

return wrapJSObject(jsCtx, jsValue)

return None

class JSException(Exception):

"""Python exception class to encapsulate JavaScript exceptions."""

def __init__(self, pyWrapped):

self.message = '<no message>'

def __str__(self):

return self.message

cdef object jsExceptionToPython(JSContextRef jsCtx, JSValueRef jsException):

"""Factory function for creating exception objects."""

return JSException(jsToPython(jsCtx, jsException))

cdef object pyStringFromJS(JSStringRef jsString):

return PyUnicode_DecodeUTF16(<Py_UNICODE *>JSStringGetCharactersPtr(jsString),

JSStringGetLength(jsString) * 2,

NULL, 0)

cdef JSStringRef createJSStringFromPython(object pyStr):

"""Create a ``JSString`` from a Python object.

pyStr = unicode(pyStr).encode('utf-8')

return JSStringCreateWithUTF8CString(pyStr)

cdef JSObjectRef wrapPyObject(JSContextRef jsCtx, object pyValue):

cdef JSObjectRef wrapper

try:

return <JSObjectRef>PyCObject_AsVoidPtr(_pyWrappedPyObjs[id(pyValue)])

except KeyError:

pass

wrapper = makePyObject(jsCtx, pyValue)

_pyWrappedPyObjs[id(pyValue)] = PyCObject_FromVoidPtr(wrapper, NULL)

return wrapper

cdef JSValueRef pythonToJS(JSContextRef jsCtx, object pyValue):

"""Convert a Python value into a JavaScript value.

if isinstance(pyValue, types.NoneType):

return JSValueMakeUndefined(jsCtx)

elif isinstance(pyValue, NullType):

return JSValueMakeNull(jsCtx)

elif isinstance(pyValue, types.BooleanType):

return JSValueMakeBoolean(jsCtx, pyValue)

elif isinstance(pyValue, (types.IntType, types.FloatType)):

return JSValueMakeNumber(jsCtx, pyValue)

elif isinstance(pyValue, types.StringTypes):

return JSValueMakeString(jsCtx, createJSStringFromPython(pyValue))

elif isinstance(pyValue, _JSBaseObject):

# This is a wrapped JavaScript object, just unwrap it.

return (<_JSObject>pyValue).jsObject

else:

# Wrap all other Python objects into a generic wrapper.

return wrapPyObject(jsCtx, pyValue)

cdef JSStringRef jsLengthName = JSStringCreateWithUTF8CString("length")

cdef class _JSBaseObject:

JSValueProtect(self.jsCtx, self.jsObject)

def __dealloc__(self):

JSValueUnprotect(self.jsCtx, self.jsObject)

JSGlobalContextRelease(self.jsCtx)

cdef class _JSSequence(_JSBaseObject):

return result

cdef int setLength(self, int length) except -1:

cdef JSValueRef jsException = NULL

cdef JSValueRef jsLength = JSValueMakeNumber(self.jsCtx, length)

JSObjectSetProperty(self.jsCtx, self.jsObject, jsLengthName,

jsLength, kJSPropertyAttributeNone, &jsException)

if jsException != NULL:

raise TypeError, "not a mutable array or array-like " \

"JavaScript object"

return 0

cdef JSValueRef getItem(self, int index) except NULL:

cdef JSValueRef jsException = NULL

cdef JSValueRef jsResult

jsResult = JSObjectGetPropertyAtIndex(self.jsCtx, self.jsObject,

index, &jsException)

if jsException != NULL:

raise jsExceptionToPython(self.jsCtx, jsException)

return jsResult

cdef int setItem(self, int index, JSValueRef jsValue) except -1:

cdef JSValueRef jsException = NULL

JSObjectSetPropertyAtIndex(self.jsCtx, self.jsObject, index, jsValue,

&jsException)

if jsException != NULL:

raise jsExceptionToPython(self.jsCtx, jsException)

return 0

cdef int copyBlock(self, int start, int end, int dest) except -1:

"""Copy the elements of ``[start, end]`` to position ``dest``.

cdef int count = end - start

cdef int i

if start < dest:

for i in range(count - 1, -1, -1):

self.setItem(dest + i, self.getItem(start + i))

elif start > dest:

for i in range(count):

self.setItem(dest + i, self.getItem(start + i))

return 0

def __contains__(self, pyItem):

cdef JSValueRef jsItem = pythonToJS(self.jsCtx, pyItem)

cdef JSValueRef jsElem

for i in range(self.getLength()):

jsElem = self.getItem(i)

if JSValueIsObjectOfClass(self.jsCtx, jsElem, pyObjectClass):

# This is a wrapped Python object, compare according

# to Python rules.

if <object>JSObjectGetPrivate(jsElem) == pyItem:

return True

else:

# Compare according to JavaScript rules.

if JSValueIsStrictEqual(self.jsCtx, jsItem, jsElem):

return True

return False

def __len__(self):

return self.getLength()

def __iter__(self):

return _JSSeqIterator(self)

def __getitem__(self, pyIndex):

cdef int index

cdef int length = self.getLength()

cdef int i

if isinstance(pyIndex, int) or isinstance(pyIndex, long):

index = pyIndex

# Handle negative indexes.

if index < 0:

index += length

# Exclude out-of-range indexes.

if index < 0 or index >= length:

raise IndexError, "list index out of range"

return jsToPython(self.jsCtx, self.getItem(index))

elif isinstance(pyIndex, slice):

# Don't know how efficient this is, but it looks cool

# anyway.

return [jsToPython(self.jsCtx, self.getItem(i))

for i in xrange(*pyIndex.indices(length))]

else:

raise TypeError, "list indices must be integers, not %s" % \

pyIndex.__class__.__name__

def __setitem__(self, pyIndex, pyValue):

cdef int index

cdef int length = self.getLength()

cdef int start, end, step

cdef int valueLength

cdef int sliceSize

cdef int i

if isinstance(pyIndex, int) or isinstance(pyIndex, long):

index = pyIndex

# Handle negative indexes.

if index < 0:

index += length

# Exclude out-of-range indexes.

if index < 0 or index >= length:

raise IndexError, "list index out of range"

self.setItem(index, pythonToJS(self.jsCtx, pyValue))

elif isinstance(pyIndex, slice):

start, end, step = pyIndex.indices(length)

pyValueList = list(pyValue)

valueLength = len(pyValueList)

if step == 1:

# Move the elements after the slice to their final

# position.

self.copyBlock(end, length, start + valueLength)

if end - start > valueLength:

# Truncate the list to its new length.

self.setLength(length - (end - start) + valueLength)

else:

# Calculate the size of the extended slice.

sliceSize = (end - start) / step

if (end - start) % step > 0:

sliceSize += 1

if sliceSize != valueLength:

raise ValueError, "attempt to assign sequence of size" \

" %d to extended slice of size %d" % \

(valueLength, sliceSize)

# Copy the elements to their destination.

i = start

for pyElem in pyValueList:

self.setItem(i, pythonToJS(self.jsCtx, pyElem))

i += step

else:

raise TypeError, "list indices must be integers, not %s" % \

pyIndex.__class__.__name__

def __delitem__(self, pyIndex):

cdef int index

cdef int length = self.getLength()

cdef int start, end, step

cdef int frm, dest, nextDel

if isinstance(pyIndex, int) or isinstance(pyIndex, long):

index = pyIndex

# Handle negative indexes.

if index < 0:

index += length

# Exclude out-of-range indexes.

if index < 0 or index >= length:

raise IndexError, "list index out of range"

self.copyBlock(index + 1, length, index)

self.setLength(length - 1)

elif isinstance(pyIndex, slice):

start, end, step = pyIndex.indices(length)

if step == 1:

# Move the elements after the slice to their final

# position.

self.copyBlock(end, length, start)

self.setLength(length - (end - start))

else:

# Copy the elements to their final positions. Elements

# are copied from frm to dest. nextDel marks the

# position of the next element that must be deleted

# (-1 if no more elements have to be deleted).

nextDel = start

if nextDel >= end:

nextDel = -1

dest = start

for frm in range(start, length):

if frm == nextDel:

nextDel += step

if nextDel >= end:

nextDel = -1

else:

self.setItem(dest, self.getItem(frm))

dest += 1

# Truncate the list.

self.setLength(dest)

else:

raise TypeError, "list indices must be integers, not %s" % \

pyIndex.__class__.__name__

def insert(self, pyIndex, pyValue):

cdef int index

cdef int length = self.getLength()

if not isinstance(pyIndex, int) and not isinstance(pyIndex, long):

raise TypeError, "list indices must be integers, not %s" % \

pyIndex.__class__.__name__

index = pyIndex

# The insert method is special in how indexes are handled:

# Handle negative indexes.

if index < 0:

index += length

# Handle out-of-range indexes.

if index < 0:

index = 0

elif index > length:

index = length

self.copyBlock(index, length, index + 1)

self.setItem(index, pythonToJS(self.jsCtx, pyValue))

class JSSequence(_JSSequence, collections.MutableSequence):

"""Mix ``_JSSequence`` and ``collections.MutableSequence``."""

__slots__ = ()

cdef class _JSSeqIterator:

return self.__next__()

cdef class _JSObject(_JSBaseObject):

JSStringRelease(jsKey)

class JSObject(_JSObject, collections.MutableMapping):

"""Mix ``_JSObject`` and ``collections.MutableMapping``."""

__slots__ = ()

cdef class _JSObjectIterator:

JSPropertyNameArrayRelease(self.nameArray)

def asSeq(pyObject):

"""Return the sequence view of ``pyObject``."""

return pyObject.__asSeq__()

cdef makeJSObject(JSContextRef jsCtx, JSObjectRef jsObject):

"""Factory function for 'JSObject' instances."""

cdef _JSObject obj = JSObject()

obj.setup(jsCtx, jsObject)

return obj

cdef class _JSFunction(_JSObject):

return jsToPython(self.jsCtx, result)

class JSFunction(_JSFunction, collections.MutableMapping):

"""Mix ``_JSFunction`` and ``collections.MutableMapping``."""

__slots__ = ()

cdef makeJSFunction(JSContextRef jsCtx, JSObjectRef jsObject):

"""Factory function for 'JSFunction' instances."""

cdef _JSFunction obj = JSFunction()

obj.setup(jsCtx, jsObject)

return obj

cdef class _JSBoundMethod(_JSObject):

self.jsThisObj = jsThisObj

def __call__(self, *args):

return jsToPython(self.jsCtx, result)

def __dealloc__(self):

JSValueUnprotect(self.jsCtx, self.jsThisObj)

class JSBoundMethod(_JSBoundMethod, collections.MutableMapping):

"""Mix ``_JSBoundMethod`` and ``collections.MutableMapping``."""

__slots__ = ()

cdef makeJSBoundMethod(JSContextRef jsCtx, JSObjectRef jsObject,

JSObjectRef thisObj):

"""Factory function for 'JSBoundMethod' instances."""

cdef _JSBoundMethod obj = JSBoundMethod()

obj.setup2(jsCtx, jsObject, thisObj)

return obj

cdef class JSContext:

JSGlobalContextRelease(self.jsCtx)

cdef JSValueRef pyExceptionToJS(JSContextRef jsCtx, object exc):

"""Make a JavaScript exception object from a Python exception

cdef JSStringRef jsMsgStr

cdef JSValueRef jsMsg

# Make a string from the exception object (the unicode conversion

# in createJSStringFromPython takes care of extracting the

# message).

jsMsgStr = createJSStringFromPython(exc)

jsMsg = JSValueMakeString(jsCtx, jsMsgStr)

JSStringRelease(jsMsgStr)

return JSObjectMakeError(jsCtx, 1, &jsMsg, NULL)

cdef void pyObjInitialize(JSContextRef ctx,

JSObjectRef jsObj) with gil:

cdef object pyObj = <object>JSObjectGetPrivate(jsObj)

# Keep a reference to the wrapped Python object during the

# lifetime of the JavaScript wrapper. This reference is released

# in the finalize method.

Py_INCREF(pyObj)