rapydscript-ns 0.8.2 → 0.8.4

package/release/signatures.json

@@ -1,31 +1,33 @@
 {
-    "ast": "7a1a1800d9ee7af7f7153eee38002e4e9dcfb71e",
-    "baselib-builtins": "50927b38fded9bd9dbe14c42a20dd8e930ac021f",
-    "baselib-containers": "f7ac21a4dfc6311693239ea1eb45e74fae45a3f5",
-    "baselib-errors": "f2423e1e2489bdd7fb8c8725bb76436898c8008c",
-    "baselib-internal": "1b77d40970a8ef2d886132dc7c21c9510d2eb4cd",
-    "baselib-itertools": "ab1f3257642c8d26fab1ff9d392814a459a60cdb",
-    "baselib-str": "8c396e4fae02ae34b6d3d805becf7bfdd36625ee",
-    "compiler": "cfbfceb0439fed3302f78d80b303dca713b25e7b",
-    "errors": "d1b33848d19b141e19cc079cf78421f29b6d2c05",
-    "output/__init__": "da39a3ee5e6b4b0d3255bfef95601890afd80709",
-    "output/classes": "d05c1992cc91b337a4e4ff137b0aa3d626e6624b",
-    "output/codegen": "0519a88c2704fe60b98fe747ca39f6be43b9abf3",
-    "output/comments": "78ec38d8b34da96c078653e2d0d4049d7003906b",
-    "output/exceptions": "c7d90155694c7108e94d0940a160ae83725421d7",
-    "output/functions": "abaa81b171359eb77be6ea87cbdf9d7421d4622b",
-    "output/literals": "fdbfb744fec8dfea1e1c62cb49767c60160fd402",
-    "output/loops": "f59cc623320f57edb01953f7877d712758e9f825",
-    "output/modules": "bd3e3f3f6794fb6e401867b4d011c4e3aab98893",
-    "output/operators": "f8142836a13b75680cb4874391db9e871fad0cad",
-    "output/statements": "7d8dfdc0b43e3e430be7ce3b23ffaf1b41408d8c",
-    "output/stream": "46375cb467477ac898546e818bfdfa5be738c352",
-    "output/utils": "595968f96f6fdcc51eb41c34d64c92bb595e3cb1",
-    "parse": "d5c1a77662dfcff841dfcd368d5dbb129a592f5d",
-    "string_interpolation": "bff1cc76d772d24d35707f6c794f38734ca08376",
-    "tokenizer": "00fc24a41edac9f9b31735e6290348005a623cef",
-    "unicode_aliases": "79ac6eaa5e6be44a5397d62c561f854a8fe7528e",
-    "utils": "c1666db819aa7c8db38697e34e18362e3cb45869",
-    "#compiler#": "d98fcbb15d08dae74d9c7371ea28fea676642e67",
-    "#compiled_with#": "d98fcbb15d08dae74d9c7371ea28fea676642e67"
+    "ast": "c8f6f1be6f7f73b1b9e2bbf470f5e2e5fff879df",
+    "baselib-builtins": "ced189b19392b1f425a1a180b90bc61e5e1b022f",
+    "baselib-containers": "d2f534e6530dfb309b074bf7fac082c65779e778",
+    "baselib-errors": "a9e8c63e450360fd0bd70642d4c107672d395ccf",
+    "baselib-internal": "b020b5154a7ee023ceb5852bf35eeee31e285d87",
+    "baselib-itertools": "425f5c45bbd5de894cae891e71ba1a9e9e2063d5",
+    "baselib-str": "a00bdd267521d31d97cdc76581f955b6fafb4bae",
+    "compiler": "bb16e915c60dc4ffb5bfe98bef411736d19fa297",
+    "errors": "257eca38b6de987e5fd80672bec9b9981847e1bd",
+    "output\\classes": "a88c3c84ded9049d7a5052fb151d51bdbb600dcd",
+    "output\\codegen": "69151b2cd53ff8b3270a122c65e1a0f56735150e",
+    "output\\comments": "63b39620f9d6f407aa2d4ddb557d1c60ef296b05",
+    "output\\exceptions": "e7d9119550403e6c5730d40b9bc9c923a23d6eb7",
+    "output\\functions": "58972ccc4562ab3422317f79f68ea3e00b765279",
+    "output\\jsx": "14f32c048301965de7764c5b74b651bc279de937",
+    "output\\literals": "287ec4222c79f1ebfa2c6efae925e794cbb931ab",
+    "output\\loops": "93afeea09e81382edf1c2f6009f4811430d0ebb8",
+    "output\\modules": "15735b9b07260d11ba231fc3439818bd1a54947e",
+    "output\\operators": "d9ebb70a00cfe6be60c5d75596edf7986f619644",
+    "output\\statements": "94ee0cd084f22aea451b96eb1a9a831084cc4267",
+    "output\\stream": "2723d80bc398468e0828f50fb0837095c52f45dc",
+    "output\\treeshake": "4a490ba097739d924db9e3cd9eb7718db5e24cae",
+    "output\\utils": "e957919bfccb9a3ab510d824a8f2ee3fc2689795",
+    "output\\__init__": "da39a3ee5e6b4b0d3255bfef95601890afd80709",
+    "parse": "1815f278b2b974ed79973f792a4dbcccfb35c2b8",
+    "string_interpolation": "88dce6c2c5ee75126a6838a1506841c6531a0d15",
+    "tokenizer": "6c06a87951cc4cfe6256dfa4f22ab3533967e856",
+    "unicode_aliases": "7fbcbc9c24adcb2e33fac8d69aaafe5047fcc2c2",
+    "utils": "35a2a707c841da851e18c64edac54e7c20b7dfc9",
+    "#compiler#": "724970153770773cd9e1ff1e588f17df9c607ee9",
+    "#compiled_with#": "724970153770773cd9e1ff1e588f17df9c607ee9"
 }

package/session.vim

@@ -1,4 +1,4 @@
-set wildignore+=*.pyj-cached
-set wildignore+=node_modules
-imap <F4> ρσ_
-cmap <F4> ρσ_
+set wildignore+=*.pyj-cached
+set wildignore+=node_modules
+imap <F4> ρσ_
+cmap <F4> ρσ_

package/setup.cfg

@@ -1,2 +1,2 @@
-[rapydscript]
-globals=assert,RapydScript
+[rapydscript]
+globals=assert,RapydScript

package/src/ast.pyj

@@ -600,6 +600,9 @@ class AST_Class(AST_Scope):
         'statements': "[AST_Node*] list of statements in the class scope (excluding method definitions)",
         'dynamic_properties': '[dict] map of dynamic property names to property descriptors of the form {getter:AST_Method, setter:AST_Method',
         'classvars': '[dict] map containing all class variables as keys, to be used to easily test for existence of a class variable',
+        'has_new': "[boolean] true if the class defines a __new__ method",
+        'has_attr_dunders': "[boolean] true if the class defines any of __getattr__/__setattr__/__delattr__/__getattribute__",
+        'class_kwargs': "[array] keyword arguments from class header (e.g. class C(Base, key=val):) as [[key_node, value_node], ...]",
     }
 
     def _walk(self, visitor):
@@ -610,6 +613,9 @@ class AST_Class(AST_Scope):
             self.name._walk(visitor)
             walk_body(self, visitor)
             if (self.parent) self.parent._walk(visitor)
+            if self.class_kwargs:
+                for kw in self.class_kwargs:
+                    kw[1]._walk(visitor)
         )
 
 class AST_Method(AST_Lambda):
@@ -725,7 +731,8 @@ class AST_Except(AST_Block):
     "An `except` node for RapydScript, which resides inside the catch block"
     properties = {
         'argname': "[AST_SymbolCatch] symbol for the exception",
-        'errors': "[AST_SymbolVar*] error classes to catch in this block"
+        'errors': "[AST_SymbolVar*] error classes to catch in this block",
+        'is_star': '[bool] True for except* (exception group) clauses',
     }
 
     def _walk(self, visitor):
@@ -1161,6 +1168,17 @@ class AST_ObjectSpread(AST_Node):
             self.value._walk(visitor)
         )
 
+class AST_Spread(AST_Node):
+    "A *expr spread item inside a list or set literal: [1, *a, 2]"
+    properties = {
+        'expression': "[AST_Node] the expression being spread",
+    }
+
+    def _walk(self, visitor):
+        return visitor._visit(self, def():
+            self.expression._walk(visitor)
+        )
+
 class AST_Set(AST_Node):
     "A set literal"
     properties = {
@@ -1360,6 +1378,80 @@ class TreeWalker:
             self = p
 # }}}
 
+# JSX nodes {{{
+
+class AST_JSXElement(AST_Node):
+    "A JSX element like <div>...</div> or <Component />"
+    properties = {
+        'tag': "[string] The tag name (e.g. 'div', 'MyComponent')",
+        'props': "[AST_JSXAttribute[]] The props/attributes",
+        'children': "[AST_Node[]] The children",
+        'self_closing': "[bool] Whether self-closing (no children)"
+    }
+
+    def _walk(self, visitor):
+        return visitor._visit(self, def():
+            for prop in self.props:
+                prop._walk(visitor)
+            for child in self.children:
+                child._walk(visitor)
+        )
+
+class AST_JSXFragment(AST_Node):
+    "A JSX fragment <>...</>"
+    properties = {
+        'children': "[AST_Node[]] The children"
+    }
+
+    def _walk(self, visitor):
+        return visitor._visit(self, def():
+            for child in self.children:
+                child._walk(visitor)
+        )
+
+class AST_JSXAttribute(AST_Node):
+    "A JSX attribute like prop='val', prop={expr}, or just prop (boolean)"
+    properties = {
+        'name': "[string] The attribute name",
+        'value': "[AST_Node|null] The value (null for boolean attrs)"
+    }
+
+    def _walk(self, visitor):
+        return visitor._visit(self, def():
+            if self.value:
+                self.value._walk(visitor)
+        )
+
+class AST_JSXSpread(AST_Node):
+    "A JSX spread attribute {...expr}"
+    properties = {
+        'expression': "[AST_Node] The spread expression"
+    }
+
+    def _walk(self, visitor):
+        return visitor._visit(self, def():
+            self.expression._walk(visitor)
+        )
+
+class AST_JSXText(AST_Node):
+    "Text content inside a JSX element"
+    properties = {
+        'value': "[string] The text content"
+    }
+
+class AST_JSXExprContainer(AST_Node):
+    "A JSX expression container {expr}"
+    properties = {
+        'expression': "[AST_Node] The expression"
+    }
+
+    def _walk(self, visitor):
+        return visitor._visit(self, def():
+            self.expression._walk(visitor)
+        )
+
+# }}}
+
 class Found(Exception):
     pass
 

package/src/baselib-builtins.pyj

@@ -20,6 +20,7 @@ def ρσ_bool(val):
     v'if ((typeof Set === "function" && val instanceof Set) || (typeof Map === "function" && val instanceof Map)) return val.size > 0'
     v'if (!val.constructor || val.constructor === Object) return Object.keys(val).length > 0'
     return True
+ρσ_bool.__name__ = 'bool'
 
 def ρσ_print(*args, **kwargs):
     if v'typeof console' is 'object':
@@ -35,6 +36,7 @@ def ρσ_int(val, base):
     if isNaN(ans):
         raise ValueError('Invalid literal for int with base ' + (base or 10) + ': ' + val)
     return ans
+ρσ_int.__name__ = 'int'
 
 def ρσ_float(val):
     if jstype(val) is "number":
@@ -44,6 +46,7 @@ def ρσ_float(val):
     if isNaN(ans):
         raise ValueError('Could not convert string to float: ' + arguments[0])
     return ans
+ρσ_float.__name__ = 'float'
 
 def ρσ_arraylike_creator():
     names = 'Int8Array Uint8Array Uint8ClampedArray Int16Array Uint16Array Int32Array Uint32Array Float32Array Float64Array'.split(' ')
@@ -164,7 +167,22 @@ def ρσ_reversed(iterable):
         return ans
     raise TypeError('reversed() can only be called on arrays or strings')
 
-def ρσ_iter(iterable):
+def ρσ_iter(iterable, sentinel):
+    # Two-argument form: iter(callable, sentinel) — call repeatedly until sentinel is returned
+    if arguments.length >= 2:
+        callable_ = iterable
+        ans = v'{"_callable":callable_,"_sentinel":sentinel,"_done":false}'
+        ans[ρσ_iterator_symbol] = def():
+            return this
+        ans['next'] = def():
+            if this._done:
+                return v"{'done':true}"
+            val = ρσ_callable_call(this._callable)
+            if v'val === this._sentinel':
+                this._done = True
+                return v"{'done':true}"
+            return v"{'done':false,'value':val}"
+        return ans
     # Generate a JavaScript iterator object from iterable
     if jstype(iterable[ρσ_iterator_symbol]) is 'function':
         return iterable.keys() if jstype(Map) is 'function' and v'iterable instanceof Map' else iterable[ρσ_iterator_symbol]()
@@ -267,6 +285,23 @@ def ρσ_hasattr(obj, name):
 def ρσ_get_module(name):
     return ρσ_modules[name]
 
+def ρσ__import__(name, globals, locals, fromlist, level):
+    # Return the module from the already-compiled ρσ_modules registry.
+    # Like Python: without fromlist (or empty fromlist) returns the top-level
+    # package; with a non-empty fromlist returns the named (possibly dotted) module.
+    # NOTE: the module must have been statically imported elsewhere in the source;
+    # __import__ only provides a runtime reference to an already-compiled module.
+    if v'typeof ρσ_modules' is 'undefined':
+        raise ImportError('No module named \'' + name + '\'')
+    if fromlist is not undefined and fromlist is not None and fromlist.length:
+        lookup = name
+    else:
+        lookup = name.split('.')[0]
+    module = ρσ_modules[lookup]
+    if module is undefined:
+        raise ModuleNotFoundError('No module named \'' + lookup + '\'')
+    return module
+
 def ρσ_pow(x, y, z):
     ans = Math.pow(x, y)
     if z is not undefined:
@@ -307,6 +342,7 @@ def ρσ_hash(obj):
         }
         return ρσ_h;
     }'''
+    v'if (obj.__hash__ === null) throw new TypeError("unhashable type: \'" + (obj.constructor && obj.constructor.name ? obj.constructor.name : "object") + "\'")'
     v'if (typeof obj.__hash__ === "function") return obj.__hash__()'
     v'if (Array.isArray(obj)) throw new TypeError("unhashable type: \'list\'")'
     v'if (typeof ρσ_set === "function" && obj instanceof ρσ_set) throw new TypeError("unhashable type: \'set\'")'
@@ -363,11 +399,72 @@ def ρσ_max(*args, **kwargs):
     raise TypeError('expected at least one argument')
 
 
+class ρσ_slice:
+    def __init__(self, start_or_stop, stop, step):
+        if arguments.length is 1:
+            self.start = None
+            self.stop = start_or_stop
+            self.step = None
+        elif arguments.length is 2:
+            self.start = start_or_stop
+            self.stop = stop
+            self.step = None
+        else:
+            self.start = start_or_stop
+            self.stop = stop
+            self.step = step
+
+    def indices(self, length):
+        step = 1 if self.step is None else self.step
+        if step is 0:
+            raise ValueError('slice step cannot be zero')
+        if step > 0:
+            lower = 0
+            upper = length
+            start = lower if self.start is None else self.start
+            stop  = upper if self.stop  is None else self.stop
+        else:
+            lower = -1
+            upper = length - 1
+            start = upper if self.start is None else self.start
+            stop  = lower if self.stop  is None else self.stop
+        # Only clamp values that were explicitly provided (None defaults are already correct).
+        if self.start is not None:
+            if start < 0:
+                start = max(start + length, lower)
+            if start > upper:
+                start = upper
+        if self.stop is not None:
+            if stop < 0:
+                stop = max(stop + length, lower)
+            if stop > upper:
+                stop = upper
+        return start, stop, step
+
+    def __repr__(self):
+        s = 'None' if self.start is None else String(self.start)
+        stop = 'None' if self.stop is None else String(self.stop)
+        step = 'None' if self.step is None else String(self.step)
+        return 'slice(' + s + ', ' + stop + ', ' + step + ')'
+
+    def __str__(self):
+        return self.__repr__()
+
+    def __eq__(self, other):
+        if not v'other instanceof ρσ_slice':
+            return False
+        return self.start is other.start and self.stop is other.stop and self.step is other.step
+
+    def __hash__(self):
+        raise TypeError("unhashable type: 'slice'")
+
+
 v'var abs = Math.abs, max = ρσ_max.bind(Math.max), min = ρσ_max.bind(Math.min), bool = ρσ_bool, type = ρσ_type'
 v'var float = ρσ_float, int = ρσ_int, arraylike = ρσ_arraylike_creator(), ρσ_arraylike = arraylike'
-v'var id = ρσ_id, get_module = ρσ_get_module, pow = ρσ_pow, divmod = ρσ_divmod'
+v'var id = ρσ_id, get_module = ρσ_get_module, pow = ρσ_pow, divmod = ρσ_divmod, __import__ = ρσ__import__'
 v'var dir = ρσ_dir, ord = ρσ_ord, chr = ρσ_chr, bin = ρσ_bin, hex = ρσ_hex, callable = ρσ_callable, round = ρσ_round'
 v'var enumerate = ρσ_enumerate, iter = ρσ_iter, reversed = ρσ_reversed, len = ρσ_len'
 v'var range = ρσ_range, getattr = ρσ_getattr, setattr = ρσ_setattr, hasattr = ρσ_hasattr, issubclass = ρσ_issubclass, hash = ρσ_hash, next = ρσ_next'
 v'var ρσ_Ellipsis = Object.freeze({toString: function(){return "Ellipsis";}, __repr__: function(){return "Ellipsis";}})'
 v'var Ellipsis = ρσ_Ellipsis'
+v'var slice = ρσ_slice'

package/src/baselib-containers.pyj

@@ -140,7 +140,7 @@ def ρσ_list_sort(key=None, reverse=False):
         k = this[i]  # noqa:undef
         keymap.set(k, key(k))
         posmap.set(k, i)
-    this.sort(def (a, b): return mult * ρσ_list_sort_cmp(keymap.get(a), keymap.get(b), posmap.get(a), posmap.get(b));)
+    Array.prototype.sort.call(this, def (a, b): return mult * ρσ_list_sort_cmp(keymap.get(a), keymap.get(b), posmap.get(a), posmap.get(b));)
 
 def ρσ_list_concat():  # ensure concat() returns an object of type list
     ans = Array.prototype.concat.apply(this, arguments)
@@ -190,14 +190,18 @@ def ρσ_list_decorate(ans):
     ans.inspect = ρσ_list_to_string
     ans.extend = ρσ_list_extend
     ans.index = ρσ_list_index
-    ans.pypop = ρσ_list_pop
+    ans.jspop = Array.prototype.pop      # native JS pop (no bounds check, ignores args)
+    ans.pop = ρσ_list_pop                # Python pop (bounds-checked, supports negative index)
+    ans.pypop = ρσ_list_pop              # backward-compat alias for pop
     ans.remove = ρσ_list_remove
     ans.insert = ρσ_list_insert
     ans.copy = ρσ_list_copy
     ans.clear = ρσ_list_clear
     ans.count = ρσ_list_count
     ans.concat = ρσ_list_concat
-    ans.pysort = ρσ_list_sort
+    ans.jssort = Array.prototype.sort    # native JS sort (lexicographic by default)
+    ans.sort = ρσ_list_sort              # Python sort (numeric by default)
+    ans.pysort = ρσ_list_sort            # backward-compat alias for sort
     ans.slice = ρσ_list_slice
     ans.as_array = ρσ_list_as_array
     ans.__len__ = ρσ_list_len
@@ -235,10 +239,30 @@ v'var list = ρσ_list_constructor, list_wrap = ρσ_list_decorate'
 
 def sorted(iterable, key=None, reverse=False):
     ans = ρσ_list_constructor(iterable)
-    ans.pysort(key, reverse)
+    ans.sort(key, reverse)
     return ans
 # }}}
 
+# tuple {{{
+def ρσ_tuple_constructor(iterable):
+    if iterable is undefined:
+        return v'[]'
+    if ρσ_arraylike(iterable):
+        return Array.prototype.slice.call(iterable)
+    if jstype(iterable[ρσ_iterator_symbol]) is 'function':
+        iterator = iterable.keys() if jstype(Map) is 'function' and v'iterable instanceof Map' else iterable[ρσ_iterator_symbol]()
+        ans = []
+        result = iterator.next()
+        while not result.done:
+            ans.push(result.value)
+            result = iterator.next()
+        return ans
+    return Object.keys(iterable)
+
+ρσ_tuple_constructor.__name__ = 'tuple'
+v'var tuple = ρσ_tuple_constructor'
+# }}}
+
 # set {{{
 v'var ρσ_global_object_id = 0, ρσ_set_implementation'
 
@@ -694,6 +718,12 @@ def ρσ_dict_polyfill():
         return v"{'done':false, 'value':this._s[this._keys[this._i]]}"
     return ans
 
+ρσ_dict_polyfill.prototype.forEach = def(callback):
+    keys = Object.keys(this._store)
+    for v'var ρσ_fi = 0; ρσ_fi < keys.length; ρσ_fi++':
+        entry = this._store[keys[v'ρσ_fi']]
+        callback(entry[1], entry[0], this)
+
 if jstype(Map) is not 'function' or jstype(Map.prototype.delete) is not 'function':
     v'ρσ_dict_implementation = ρσ_dict_polyfill'
 else:
@@ -858,6 +888,15 @@ Object.defineProperties(ρσ_dict.prototype, {
         r = iterator.next()
     return ans
 
+ρσ_dict.prototype.toJSON = def():
+    ans = {}
+    iterator = this.jsmap.entries()
+    r = iterator.next()
+    while not r.done:
+        ans[r.value[0]] = r.value[1]
+        r = iterator.next()
+    return ans
+
 def ρσ_dict_wrap(x):
     ans = new ρσ_dict()
     ans.jsmap = x
@@ -865,4 +904,68 @@ def ρσ_dict_wrap(x):
 
 v'var dict = ρσ_dict, dict_wrap = ρσ_dict_wrap'
 
+v'''
+function ρσ_kwargs_to_dict(kw) {
+    // Augment the plain kwargs object with non-enumerable Python dict methods so
+    // that kw.items(), kw.keys(), kw.values() work in user code, while plain
+    // property access (kw.propname) and Object.keys(kw) are unaffected.
+    //
+    // items/keys/values return dual-mode arrays: they support both Array indexing
+    // (for ρσ_dict.prototype.update which does pairs[i]) and iterator protocol
+    // (for `for k, v in kw.items():` which calls .next()).
+    function _make_seq(arr) {
+        arr._ρσ_i = 0;
+        arr.next = function() {
+            return this._ρσ_i < this.length
+                ? {done: false, value: this[this._ρσ_i++]}
+                : {done: true, value: undefined};
+        };
+        arr[ρσ_iterator_symbol] = function() { this._ρσ_i = 0; return this; };
+        return arr;
+    }
+    function _def(name, fn) {
+        if (!Object.prototype.hasOwnProperty.call(kw, name)) {
+            Object.defineProperty(kw, name, {value: fn, configurable: true, writable: true, enumerable: false});
+        }
+    }
+    _def("items", function() {
+        var ks = Object.keys(kw), arr = [], i;
+        for (i = 0; i < ks.length; i++) arr.push([ks[i], kw[ks[i]]]);
+        return _make_seq(arr);
+    });
+    _def("entries", kw.items);
+    _def("keys", function() {
+        return _make_seq(Object.keys(kw).slice());
+    });
+    _def("values", function() {
+        var ks = Object.keys(kw), arr = [], i;
+        for (i = 0; i < ks.length; i++) arr.push(kw[ks[i]]);
+        return _make_seq(arr);
+    });
+    _def("get", function(k, d) {
+        return Object.prototype.hasOwnProperty.call(kw, k) ? kw[k] : (d !== undefined ? d : null);
+    });
+    _def("__contains__", function(k) { return Object.prototype.hasOwnProperty.call(kw, k); });
+    _def("has", function(k) { return Object.prototype.hasOwnProperty.call(kw, k); });
+    _def("__len__", function() { return Object.keys(kw).length; });
+    kw[ρσ_iterator_symbol] = function() {
+        var ks = Object.keys(kw), i = 0;
+        return {next: function() {
+            return i < ks.length ? {done: false, value: ks[i++]} : {done: true, value: undefined};
+        }};
+    };
+    return kw;
+}
+'''
+
+v"""var ρσ_json_parse = function(text, reviver) {
+    function dict_reviver(key, value) {
+        if (value !== null && typeof value === "object" && !Array.isArray(value) && !(value instanceof ρσ_dict)) {
+            value = ρσ_dict(value);
+        }
+        return reviver ? reviver.call(this, key, value) : value;
+    }
+    return JSON.parse(text, dict_reviver);
+};"""
+
 # }}}

package/src/baselib-errors.pyj

@@ -38,3 +38,47 @@ class ZeroDivisionError(Exception):
 
 class StopIteration(Exception):
     pass
+
+class ImportError(Exception):
+    pass
+
+class ModuleNotFoundError(ImportError):
+    pass
+
+def _is_exc_class(obj):
+    # True when obj is an Error subclass (or Error itself), not a plain predicate function
+    return jstype(obj) is 'function' and (obj is Error or (obj.prototype and isinstance(obj.prototype, Error)))
+
+
+class ExceptionGroup(Exception):
+
+    def __init__(self, message, exceptions):
+        Exception.__init__(self, message)
+        self.exceptions = exceptions if exceptions else []
+
+    def subgroup(self, condition):
+        if _is_exc_class(condition):
+            matched = [e for e in self.exceptions if isinstance(e, condition)]
+        elif callable(condition):
+            matched = [e for e in self.exceptions if condition(e)]
+        else:
+            matched = [e for e in self.exceptions if isinstance(e, condition)]
+        return ExceptionGroup(self.message, matched) if matched else None
+
+    def split(self, condition):
+        if _is_exc_class(condition):
+            matched = [e for e in self.exceptions if isinstance(e, condition)]
+            rest = [e for e in self.exceptions if not isinstance(e, condition)]
+        elif callable(condition):
+            matched = [e for e in self.exceptions if condition(e)]
+            rest = [e for e in self.exceptions if not condition(e)]
+        else:
+            matched = [e for e in self.exceptions if isinstance(e, condition)]
+            rest = [e for e in self.exceptions if not isinstance(e, condition)]
+        return [
+            ExceptionGroup(self.message, matched) if matched else None,
+            ExceptionGroup(self.message, rest) if rest else None
+        ]
+
+    def __repr__(self):
+        return 'ExceptionGroup(' + repr(self.message) + ', ' + repr(self.exceptions) + ')'