pypkjs 1.1.2__py3-none-any.whl

pypkjs/__init__.py

@@ -0,0 +1,5 @@
+
+__author__ = 'katharine'
+
+from gevent import monkey
+monkey.patch_all()

pypkjs/javascript/__init__.py

@@ -0,0 +1,40 @@
+
+__author__ = 'katharine'
+
+from .console import Console
+from .performance import Performance
+from .timers import Timers
+from .localstorage import LocalStorage
+from .pebble import Pebble
+from .xhr import prepare_xhr
+from .navigator import Navigator
+from .ws import prepare_ws
+
+
+class PebbleKitJS(object):
+    def __init__(self, runtime, pebble, persist=None):
+        self.runtime = runtime
+        self.pebble = Pebble(runtime, pebble)
+        self.local_storage = LocalStorage(runtime, persist)
+
+        self.extensions = [
+            Console(runtime),
+            Performance(runtime),
+            self.local_storage,
+            Navigator(runtime),
+            Timers(runtime),
+            self.pebble,
+        ]
+
+    def get_extension_names(self):
+        return [x.extension.name for x in self.extensions] + ["runtime/events/progress", "runtime/xhr", "runtime/ws",
+                                                              "runtime/geolocation/position",
+                                                              "runtime/geolocation/coordinates"]
+
+    def do_post_setup(self):
+        prepare_xhr(self.runtime)
+        prepare_ws(self.runtime)
+
+    def shutdown(self):
+        self.local_storage._shutdown()
+        self.pebble._shutdown()

pypkjs/javascript/console.py

@@ -0,0 +1,39 @@
+
+__author__ = 'katharine'
+
+import STPyV8 as v8
+
+
+class Console(object):
+    def __init__(self, runtime):
+        self.runtime = runtime
+        self.extension = v8.JSExtension(self.runtime.ext_name("console"), """
+        console = new (function () {
+            native function _internal_console();
+            _make_proxies(this, _internal_console(), ['log', 'warn', 'info', 'error']);
+        })();
+        """, lambda f: lambda: self, dependencies=["runtime/internal/proxy"])
+
+    def log(self, *params):
+        # kOverview == kLineNumber | kColumnOffset | kScriptName | kFunctionName
+        trace_str = str(v8.JSStackTrace.GetCurrentStackTrace(2, v8.JSStackTrace.Options.Overview))
+        try:
+            frames = v8.JSError.parse_stack(trace_str.strip())
+            caller_frame = frames[0]
+            filename = caller_frame[1]
+            line_num = caller_frame[2]
+            file_and_line = "{}:{}".format(filename, line_num)
+        except:
+            file_and_line = "???:?:?"
+        log_str = ' '.join([x.toString().decode('utf-8') if hasattr(x, 'toString')
+                                           else bytes(x).decode('utf-8') for x in params])
+        self.runtime.log_output("{} {}".format(file_and_line, log_str))
+
+    def warn(self, *params):
+        self.log(*params)
+
+    def info(self, *params):
+        self.log(*params)
+
+    def error(self, *params):
+        self.log(*params)

pypkjs/javascript/events.py

@@ -0,0 +1,91 @@
+
+__author__ = 'katharine'
+
+import STPyV8 as v8
+
+from .exceptions import JSRuntimeException
+
+event = v8.JSExtension("runtime/event", """
+    Event = function(event_type, event_init_dict) {
+        var self = this;
+        this.stopPropagation = function() {};
+        this.stopImmediatePropagation = function() { self._aborted = true; }
+        this.preventDefault = function() { self.defaultPrevented = true; }
+        this.initEvent = function(event_type, bubbles, cancelable) {
+            self.type = event_type;
+            self.bubbles = bubbles;
+            self.cancelable = cancelable
+        };
+        if(!event_init_dict) event_init_dict = {};
+
+        this.type = event_type;
+        this.bubbles = event_init_dict.bubbles || false;
+        this.cancelable = event_init_dict.cancelable || false;
+        this.defaultPrevented = false;
+        this.target = null;
+        this.currentTarget = null;
+        this.eventPhase = 2;
+        this._aborted = false;
+    };
+    Event.NONE = 0;
+    Event.CAPTURING_PHASE = 1;
+    Event.AT_TARGET = 2;
+    Event.BUBBLING_PHASE = 3;
+""")
+
+Event = lambda runtime, *args: v8.JSObject.create(runtime.context.locals.Event, args)
+
+
+class EventSourceMixin(object):
+    def __init__(self, runtime):
+        self.__listeners = {}
+        self.__runtime = runtime
+        super(EventSourceMixin, self).__init__()
+
+    def addEventListener(self, event, listener, capture=False):
+        self.__listeners.setdefault(event, []).append(listener)
+
+    def removeEventListener(self, event, listener=None):
+        if event not in self.__listeners:
+            return
+        if listener is None:
+            del self.__listeners[event]
+        else:
+            for i, listener_i in enumerate(self.__listeners[event]):
+                if listener_i == listener:
+                    del listener[i]
+                    break
+
+    def triggerEvent(self, event_name, event=None, *params):
+        if event is None:
+            event = Event(self.__runtime, event_name)
+
+        def go():
+            for listener in self.__listeners.get(event_name, []):
+                try:
+                    listener.call(self, event, *params)
+                except (v8.JSError, JSRuntimeException) as e:
+                    self.__runtime.log_output(e.stackTrace)
+                except Exception as e:
+                    self.__runtime.log_output(e.message)
+                    raise
+                finally:
+                    if event._aborted:
+                        break
+            #TODO: Figure out if these come before or after addEventListener handlers.
+            try:
+                dom_event = getattr(self, "on" + event_name)
+            except AttributeError:
+                pass
+            else:
+                try:
+                    if dom_event is not None:
+                        dom_event.call(self, event, *params)
+                except (v8.JSError, JSRuntimeException) as e:
+                    self.__runtime.log_output(e.stackTrace)
+                except Exception as e:
+                    self.__runtime.log_output(e.message)
+                    raise
+
+        self.__runtime.enqueue(go)
+

pypkjs/javascript/exceptions.py

@@ -0,0 +1,11 @@
+
+__author__ = 'katharine'
+
+import STPyV8 as v8
+
+
+class JSRuntimeException(Exception):
+    def __init__(self, message):
+        trace = v8.JSStackTrace.GetCurrentStackTrace(20, v8.JSStackTrace.Options.Detailed)
+        self.stackTrace = "Error: %s\n%s" % (message, str(trace))
+        Exception.__init__(self, message)

pypkjs/javascript/localstorage.py

@@ -0,0 +1,88 @@
+
+__author__ = 'katharine'
+
+import STPyV8 as v8
+import errno
+import logging
+import os
+import os.path
+import dbm.dumb  # This is the only one that actually syncs data if the process dies before I can close().
+logger = logging.getLogger("pypkjs.javascript.localstorage")
+
+_storage_cache = {}  # This is used when filesystem-based storage is unavailable.
+
+
+class LocalStorage(object):
+    def __init__(self, runtime, persist_dir=None):
+        self.storage = None
+        if persist_dir is not None:
+            try:
+                try:
+                    os.makedirs(os.path.join(persist_dir, 'localstorage'))
+                except OSError as e:
+                    if e.errno != errno.EEXIST:
+                        raise
+
+                self.storage = dbm.dumb.open(os.path.join(persist_dir, 'localstorage', str(runtime.pbw.uuid)), 'c')
+            except IOError:
+                pass
+        if self.storage is None:
+            logger.warning("Using transient store.")
+            self.storage = _storage_cache.setdefault(str(runtime.pbw.uuid), {})
+
+        self.extension = v8.JSExtension(runtime.ext_name("localstorage"), """
+        (function() {
+            native function _internal();
+
+            var proxy = _make_proxies({}, _internal(), ['set', 'has', 'delete_', 'keys', 'enumerate']);
+            var methods = _make_proxies({}, _internal(), ['clear', 'getItem', 'setItem', 'removeItem', 'key']);
+            proxy.get = function get(p, name) { return methods[name] || _internal().get(p, name); }
+
+            this.localStorage = Proxy.create(proxy);
+        })();
+        """, lambda f: lambda: self, dependencies=["runtime/internal/proxy"])
+
+    def get(self, p, name):
+        return self.storage.get(str(name), v8.JSNull())
+
+    def set(self, p, name, value):
+        self.storage[str(name)] = str(value)
+        return True
+
+    def has(self, p, name):
+        return name in self.storage
+
+    def delete_(self, p, name):
+        if name in self.storage:
+            del self.storage[name]
+            return True
+        else:
+            return False
+
+    def keys(self, p):
+        return v8.JSArray(list(self.storage.keys()))
+
+    def enumerate(self):
+        return v8.JSArray(list(self.storage.keys()))
+
+    def clear(self, *args):
+        self.storage.clear()
+
+    def getItem(self, name, *args):
+        return self.get(None, name)
+
+    def setItem(self, name, value, *args):
+        self.set(None, name, value)
+
+    def removeItem(self, name, *args):
+        return self.delete_(None, name)
+
+    def key(self, index, *args):
+        if len(self.storage) > index:
+            return list(self.storage.keys())[index]
+        else:
+            return v8.JSNull()
+
+    def _shutdown(self):
+        if hasattr(self.storage, 'close'):
+            self.storage.close()

pypkjs/javascript/navigator/__init__.py

@@ -0,0 +1,27 @@
+
+__author__ = 'katharine'
+
+import STPyV8 as v8
+from .geolocation import Geolocation
+
+
+class Navigator(object):
+    def __init__(self, runtime):
+
+        self._runtime = runtime
+        self._runtime = runtime
+
+        self.extension = v8.JSExtension(runtime.ext_name("navigator"), """
+        navigator = new (function() {
+            native function _internal_location();
+            this.language = 'en-GB';
+
+            var location = _internal_location();
+            if(true) { // TODO: this should be a check on geolocation being enabled.
+                this.geolocation = new (function() {
+                    _make_proxies(this, location, ['getCurrentPosition', 'watchPosition', 'clearWatch']);
+                })();
+            }
+        })();
+        """, lambda f: lambda: Geolocation(runtime), dependencies=["runtime/internal/proxy"])
+

pypkjs/javascript/navigator/geolocation.py

@@ -0,0 +1,61 @@
+
+__author__ = 'katharine'
+
+import STPyV8 as v8
+import time
+import requests
+import pygeoip
+import os.path
+
+position = v8.JSExtension("runtime/geolocation/position", """
+    Position = (function(coords, timestamp) {
+        this.coords = coords;
+        this.timestamp = timestamp;
+    });
+""")
+
+Position = lambda runtime, *args: v8.JSObject.create(runtime.context.locals.Position, args)
+
+coordinates = v8.JSExtension("runtime/geolocation/coordinates", """
+    Coordinates = (function(long, lat, accuracy) {
+        this.longitude = long
+        this.latitude = lat
+        this.accuracy = accuracy
+    });
+""")
+
+Coordinates = lambda runtime, *args: v8.JSObject.create(runtime.context.locals.Coordinates, args)
+
+
+class Geolocation(object):
+    def __init__(self, runtime):
+        self.runtime = runtime
+
+    def _get_position(self, success, failure):
+        try:
+            resp = requests.get('http://ip.42.pl/raw')
+            resp.raise_for_status()
+            ip = resp.text
+            gi = pygeoip.GeoIP('%s/GeoLiteCity.dat' % os.path.dirname(__file__))
+            record = gi.record_by_addr(ip)
+            if record is None:
+                if callable(failure):
+                    self.runtime.enqueue(failure)
+        except (requests.RequestException, pygeoip.GeoIPError):
+            if callable(failure):
+                self.runtime.enqueue(failure)
+        else:
+            self.runtime.enqueue(success, Position(self.runtime, Coordinates(self.runtime, record['longitude'], record['latitude'], 1000), round(time.time() * 1000)))
+
+    def _enabled(self):
+        return True
+
+    def getCurrentPosition(self, success, failure=None, options=None):
+        self.runtime.group.spawn(self._get_position, success, failure)
+
+    def watchPosition(self, success, failure=None, options=None):
+        self.runtime.group.spawn(self._get_position, success, failure)
+        return 42
+
+    def clearWatch(self, thing):
+        pass