Skip to main content
This is a pre-production deployment of Warehouse. Changes made here affect the production instance of PyPI (pypi.python.org).
Help us improve Python packaging - Donate today!

Simple JavaScript interpreter for Python

Project Description

DukPy is a simple javascript interpreter for Python built on top of duktape engine without any external dependency. It comes with a bunch of common transpilers built-in for convenience:

  • CoffeeScript
  • BabelJS
  • TypeScript

Dukpy has been tested on Python 3.4, dukpy is currently not production ready and might actually crash your program as it is mostly implemented in C.

dukpy-lukegb is a fork of Alessandro Molina’s dukpy: https://github.com/amol-/dukpy

CoffeeScript Compiler

Using the coffeescript compiler is as easy as running:

>>> import dukpy
>>> dukpy.coffee_compile('''
...     fill = (container, liquid = "coffee") ->
...         "Filling the #{container} with #{liquid}..."
... ''')
'(function() {\n  var fill;\n\n  fill = function*(container, liquid) {\n    if (liquid == null) {\n      liquid = "coffee";\n    }\n    return "Filling the " + container + " with " + liquid + "...";\n  };\n\n}).call(this);\n'

TypeScript Transpiler

The TypeScript compiler can be used through the dukpy.typescript_compile function:

>>> import dukpy
>>> dukpy.typescript_compile('''
... class Greeter {
...     constructor(public greeting: string) { }
...     greet() {
...         return "<h1>" + this.greeting + "</h1>";
...     }
... };
...
... var greeter = new Greeter("Hello, world!");
... ''')
'var Greeter = (function () {\n    function Greeter(greeting) {\n        this.greeting = greeting;\n    }\n    Greeter.prototype.greet = function () {\n        return "<h1>" + this.greeting + "</h1>";\n    };\n    return Greeter;\n})();\n;\nvar greeter = new Greeter("Hello, world!");\n'

Currently the compiler has built-in options and doesn’t accept additional ones,

EcmaScript6 BabelJS Transpiler

To compile ES6 code to ES5 for everyday usage you can use dukpy.babel_compile:

>>> import dukpy
>>> dukpy.babel_compile('''
... class Point {
...     constructor(x, y) {
...             this.x = x;
...         this.y = y;
...         }
...         toString() {
...             return '(' + this.x + ', ' + this.y + ')';
...         }
... }
... ''')
'"use strict";\n\nvar _prototypeProperties = function (child, staticProps, instanceProps) { if (staticProps) Object.defineProperties(child, staticProps); if (instanceProps) Object.defineProperties(child.prototype, instanceProps); };\n\nvar _classCallCheck = function (instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } };\n\nvar Point = (function () {\n    function Point(x, y) {\n        _classCallCheck(this, Point);\n\n        this.x = x;\n        this.y = y;\n    }\n\n    _prototypeProperties(Point, null, {\n        toString: {\n            value: function toString() {\n                return "(" + this.x + ", " + this.y + ")";\n            },\n            writable: true,\n            configurable: true\n        }\n    });\n\n    return Point;\n})();\n'

The DukPY based BabelJS compiler also provides a WebAssets ( http://webassets.readthedocs.org/en/latest/ ) filter to automatically compile ES6 code in your assets pipeline. You register this filter as babeljs within WebAssets using:

from webassets.filter import register_filter
from dukpy.webassets import BabelJS

register_filter(BabelJS)

Which makes the filter available with the babeljs name.

NOTE: When using the BabelJS compiler for code that needs to run in the browser, make sure to add https://cdnjs.cloudflare.com/ajax/libs/babel-core/4.6.6/browser-polyfill.js dependency.

Using the JavaScript Interpreter

Using dukpy is as simple as calling the dukpy.evaljs function with the javascript code:

>>> import dukpy
>>> dukpy.evaljs("var o = {'value': 5}; o['value'] += 3; o")
{'value': 8}

The evaljs function executes the javascript and returns the resulting value as far as it is possible to encode it in JSON.

If execution fails a dukpy.JSRuntimeError exception is raised with the failure reason.

Passing Arguments

Any argument passed to evaljs is available in JavaScript inside the dukpy object in javascript. It must be possible to encode the arguments using JSON for them to be available in Javascript:

>>> import dukpy
>>>
>>> def sum3(value):
...     return dukpy.evaljs("dukpy['value'] + 3", value=value)
...
>>> sum3(7)
10

Running Multiple Scripts

The evaljs function supports providing multiple source codes to be executed in the same context.

Multiple script can be passed in a list or tuple:

>>> import dukpy
>>> dukpy.evaljs(["var o = {'value': 5}",
...               "o['value'] += 3",
...               "o"])
{'value': 8}

This is useful when your code requires dependencies to work, as you can load the dependency and then your code.

This is actually how the coffeescript compiler is implemented by DukPy itself:

def coffee_compile(source):
    with open(COFFEE_COMPILER, 'r') as coffeescript_js:
        return evaljs((coffeescript_js.read(), 'CoffeeScript.compile(dukpy.coffeecode)'),
                      coffeecode=source)
Release History

Release History

This version
History Node

0.2.2

History Node

0.2.1

History Node

0.2.0

History Node

0.1.0

History Node

0.0.2

Download Files

Download Files

Download the file for your platform. If you're not sure which to choose, learn more about installing packages.

File Name & Checksum SHA256 Checksum Help Version File Type Upload Date
dukpy-lukegb-0.2.2.tar.gz (1.6 MB) Copy SHA256 Checksum SHA256 Source Feb 10, 2016

Supported By

WebFaction WebFaction Technical Writing Elastic Elastic Search Pingdom Pingdom Monitoring Dyn Dyn DNS Sentry Sentry Error Logging CloudAMQP CloudAMQP RabbitMQ Heroku Heroku PaaS Kabu Creative Kabu Creative UX & Design Fastly Fastly CDN DigiCert DigiCert EV Certificate Rackspace Rackspace Cloud Servers DreamHost DreamHost Log Hosting