rapydscript-ns 0.9.3 → 0.9.4

package/src/lib/pprint.pyj

@@ -0,0 +1,455 @@
+###########################################################
+# RapydScript Standard Library
+# License: Apache License 2.0
+# This library is covered under Apache license, so that
+# you can distribute it with your RapydScript applications.
+###########################################################
+
+
+# Implementation of Python's 'pprint' module.
+#
+# Pretty-prints arbitrary RapydScript / Python data structures.
+#
+# A value's repr() is used when it fits within `width`; otherwise containers
+# are broken across multiple lines with Python-style indentation.
+#
+# Public API:
+#   pformat(object, ...)   -> str
+#   pprint(object, ...)
+#   pp(object, ...)        same as pprint but defaults sort_dicts=False
+#   saferepr(object)       repr() with recursive references marked
+#   isreadable(object)     whether pformat output can be parsed back
+#   isrecursive(object)    whether the object has recursive references
+#   class PrettyPrinter
+
+
+# ── private helpers ─────────────────────────────────────────────────────────
+
+v"""
+function _pp_is_plain_dict_like(obj) {
+    if (obj === null || obj === undefined) return false;
+    if (typeof obj !== 'object') return false;
+    if (Array.isArray(obj)) return false;
+    if (obj.jsmap && typeof obj.jsmap.forEach === 'function') return false;
+    if (obj.jsset && typeof obj.jsset.values === 'function') return false;
+    var proto = Object.getPrototypeOf(obj);
+    return proto === null || proto === Object.prototype;
+}
+var _pp_id_counter = 0;
+function _pp_id(obj) {
+    if (obj === null || obj === undefined) return 0;
+    if (typeof obj !== 'object') return 0;
+    if (!obj.__pp_id__) {
+        Object.defineProperty(obj, '__pp_id__',
+            { value: ++_pp_id_counter, configurable: true, writable: true });
+    }
+    return obj.__pp_id__;
+}
+"""
+
+
+def _try_repr(x):
+    try:
+        return repr(x)
+    except:
+        return str(x)
+
+
+def _cmp_pair(a, b):
+    try:
+        if a[0] < b[0]:
+            return -1
+        if a[0] > b[0]:
+            return 1
+        return 0
+    except:
+        return 0
+
+
+def _cmp_value(a, b):
+    try:
+        if a < b:
+            return -1
+        if a > b:
+            return 1
+        return 0
+    except:
+        return 0
+
+
+def _is_dict(obj):
+    if isinstance(obj, dict):
+        return True
+    return v'_pp_is_plain_dict_like(obj)'
+
+
+def _get_dict_pairs(obj, sort_dicts):
+    pairs = v'[]'
+    if isinstance(obj, dict):
+        iterator = obj.items()
+        r = iterator.next()
+        while not r.done:
+            pairs.push(v'[r.value[0], r.value[1]]')
+            r = iterator.next()
+    else:
+        v"""
+        var _keys = Object.keys(obj);
+        for (var _i = 0; _i < _keys.length; _i++) {
+            pairs.push([_keys[_i], obj[_keys[_i]]]);
+        }
+        """
+    if sort_dicts:
+        pairs.sort(_cmp_pair)
+    return pairs
+
+
+def _get_set_items(obj):
+    items = v'[]'
+    iterator = obj.jsset.values()
+    r = iterator.next()
+    while not r.done:
+        items.push(r.value)
+        r = iterator.next()
+    items.sort(_cmp_value)
+    return items
+
+
+def _recursion_marker(obj):
+    name = 'object'
+    try:
+        if obj.constructor and obj.constructor.name:
+            name = obj.constructor.name
+        elif isinstance(obj, dict):
+            name = 'dict'
+        elif isinstance(obj, set):
+            name = 'set'
+        elif Array.isArray(obj):
+            name = 'list'
+    except:
+        pass
+    return '<Recursion on ' + name + ' with id=' + str(v'_pp_id(obj)') + '>'
+
+
+def _safe_repr(obj, context, maxlevels, level, sort_dicts):
+    """Return [repr_string, readable, recursive].
+
+    readable  -- True if the output is parseable back by eval
+    recursive -- True if obj (or any sub-object) recursively contains itself
+    """
+    if obj is None:
+        return v'["None", true, false]'
+    if obj is True:
+        return v'["True", true, false]'
+    if obj is False:
+        return v'["False", true, false]'
+    t = jstype(obj)
+    if t is 'number' or t is 'string' or t is 'bigint':
+        return v'[_try_repr(obj), true, false]'
+
+    obj_id = v'_pp_id(obj)'
+
+    if Array.isArray(obj):
+        if obj.length is 0:
+            return v'["[]", true, false]'
+        if maxlevels is not None and level >= maxlevels:
+            return v'["[...]", false, false]'
+        if context.has(obj):
+            return v'[_recursion_marker(obj), false, true]'
+        context.set(obj, 1)
+        components = v'[]'
+        readable = True
+        recursive = False
+        for v'var i = 0; i < obj.length; i++':
+            r = _safe_repr(obj[i], context, maxlevels, level + 1, sort_dicts)
+            components.push(r[0])
+            if not r[1]:
+                readable = False
+            if r[2]:
+                recursive = True
+        context.delete(obj)
+        return v'["[" + components.join(", ") + "]", readable, recursive]'
+
+    if isinstance(obj, set):
+        if obj.size is 0:
+            return v'["set()", false, false]'
+        if maxlevels is not None and level >= maxlevels:
+            return v'["{...}", false, false]'
+        if context.has(obj):
+            return v'[_recursion_marker(obj), false, true]'
+        context.set(obj, 1)
+        items = _get_set_items(obj)
+        components = v'[]'
+        readable = True
+        recursive = False
+        for v'var j = 0; j < items.length; j++':
+            r = _safe_repr(items[j], context, maxlevels, level + 1, sort_dicts)
+            components.push(r[0])
+            if not r[1]:
+                readable = False
+            if r[2]:
+                recursive = True
+        context.delete(obj)
+        return v'["{" + components.join(", ") + "}", readable, recursive]'
+
+    if isinstance(obj, frozenset):
+        if obj.size is 0:
+            return v'["frozenset()", true, false]'
+        if maxlevels is not None and level >= maxlevels:
+            return v'["frozenset({...})", false, false]'
+        items = _get_set_items(obj)
+        components = v'[]'
+        readable = True
+        recursive = False
+        for v'var k = 0; k < items.length; k++':
+            r = _safe_repr(items[k], context, maxlevels, level + 1, sort_dicts)
+            components.push(r[0])
+            if not r[1]:
+                readable = False
+            if r[2]:
+                recursive = True
+        return v'["frozenset({" + components.join(", ") + "})", readable, recursive]'
+
+    if _is_dict(obj):
+        pairs = _get_dict_pairs(obj, sort_dicts)
+        if pairs.length is 0:
+            return v'["{}", true, false]'
+        if maxlevels is not None and level >= maxlevels:
+            return v'["{...}", false, false]'
+        if context.has(obj):
+            return v'[_recursion_marker(obj), false, true]'
+        context.set(obj, 1)
+        components = v'[]'
+        readable = True
+        recursive = False
+        for v'var m = 0; m < pairs.length; m++':
+            kr = _safe_repr(pairs[m][0], context, maxlevels, level + 1, sort_dicts)
+            vr = _safe_repr(pairs[m][1], context, maxlevels, level + 1, sort_dicts)
+            components.push(kr[0] + ': ' + vr[0])
+            if not kr[1] or not vr[1]:
+                readable = False
+            if kr[2] or vr[2]:
+                recursive = True
+        context.delete(obj)
+        return v'["{" + components.join(", ") + "}", readable, recursive]'
+
+    # Class instance, function, etc. — fall back to repr().
+    rep = _try_repr(obj)
+    return v'[rep, false, false]'
+
+
+# ── stream buffer used when no stream is given ──────────────────────────────
+
+class _StreamBuffer:
+    def __init__(self):
+        self.parts = v'[]'
+
+    def write(self, s):
+        self.parts.push(s)
+
+    def getvalue(self):
+        return self.parts.join('')
+
+
+# ── PrettyPrinter ───────────────────────────────────────────────────────────
+
+class PrettyPrinter:
+    """Handle pretty-printing operations onto a stream."""
+
+    def __init__(self, indent=1, width=80, depth=None, stream=None,
+                 compact=False, sort_dicts=True, underscore_numbers=False):
+        if jstype(indent) is not 'number' or indent < 0:
+            raise ValueError('indent must be a non-negative integer')
+        if jstype(width) is not 'number' or width < 0:
+            raise ValueError('width must be a non-negative integer')
+        if depth is not None:
+            if jstype(depth) is not 'number' or depth <= 0:
+                raise ValueError('depth must be > 0')
+        self._depth = depth
+        self._indent_per_level = indent
+        self._width = width
+        self._compact = bool(compact)
+        self._sort_dicts = bool(sort_dicts)
+        self._underscore_numbers = bool(underscore_numbers)
+        self._stream = stream
+
+    def pprint(self, object):
+        if self._stream is not None:
+            self._format(object, self._stream, 0, 0, v'new Map()', 0)
+            self._stream.write('\n')
+        else:
+            print(self.pformat(object))
+
+    def pformat(self, object):
+        buf = _StreamBuffer()
+        self._format(object, buf, 0, 0, v'new Map()', 0)
+        return buf.getvalue()
+
+    def isreadable(self, object):
+        r = _safe_repr(object, v'new Map()', self._depth, 0, self._sort_dicts)
+        return r[1] and not r[2]
+
+    def isrecursive(self, object):
+        r = _safe_repr(object, v'new Map()', self._depth, 0, self._sort_dicts)
+        return r[2]
+
+    def _format(self, obj, stream, indent, allowance, context, level):
+        if obj is not None and jstype(obj) is 'object' and context.has(obj):
+            stream.write(_recursion_marker(obj))
+            return
+
+        rep = self._repr(obj, context, level)
+        max_width = self._width - indent - allowance
+
+        if rep.length <= max_width:
+            stream.write(rep)
+            return
+
+        # too wide -- try to expand the container across multiple lines
+        if Array.isArray(obj) and obj.length > 0:
+            if self._depth is not None and level >= self._depth:
+                stream.write(rep)
+                return
+            context.set(obj, 1)
+            stream.write('[')
+            self._format_items(obj, stream, indent, allowance + 1, context, level + 1)
+            stream.write(']')
+            context.delete(obj)
+            return
+
+        if isinstance(obj, set) and obj.size > 0:
+            if self._depth is not None and level >= self._depth:
+                stream.write(rep)
+                return
+            context.set(obj, 1)
+            items = _get_set_items(obj)
+            stream.write('{')
+            self._format_items(items, stream, indent, allowance + 1, context, level + 1)
+            stream.write('}')
+            context.delete(obj)
+            return
+
+        if isinstance(obj, frozenset) and obj.size > 0:
+            if self._depth is not None and level >= self._depth:
+                stream.write(rep)
+                return
+            items = _get_set_items(obj)
+            stream.write('frozenset({')
+            self._format_items(items, stream, indent + 10, allowance + 2, context, level + 1)
+            stream.write('})')
+            return
+
+        if _is_dict(obj):
+            pairs = _get_dict_pairs(obj, self._sort_dicts)
+            if pairs.length > 0:
+                if self._depth is not None and level >= self._depth:
+                    stream.write(rep)
+                    return
+                context.set(obj, 1)
+                stream.write('{')
+                if self._indent_per_level > 1:
+                    stream.write(' '.repeat(self._indent_per_level - 1))
+                self._format_dict_items(pairs, stream, indent, allowance + 1, context, level + 1)
+                stream.write('}')
+                context.delete(obj)
+                return
+
+        stream.write(rep)
+
+    def _format_items(self, items, stream, indent, allowance, context, level):
+        indent = indent + self._indent_per_level
+        if self._indent_per_level > 1:
+            stream.write(' '.repeat(self._indent_per_level - 1))
+        delimnl = ',\n' + ' '.repeat(indent)
+        delim = ''
+        width = self._width - indent + 1
+        max_width = width
+        last_index = items.length - 1
+        for v'var i = 0; i < items.length; i++':
+            last = i is last_index
+            ent = items[i]
+            if self._compact:
+                rep = self._repr(ent, context, level)
+                w = rep.length + 2
+                if width < w:
+                    width = max_width
+                    if delim:
+                        delim = delimnl
+                if width >= w:
+                    width -= w
+                    stream.write(delim)
+                    delim = ', '
+                    stream.write(rep)
+                    continue
+            stream.write(delim)
+            delim = delimnl
+            self._format(ent, stream, indent,
+                         allowance if last else 1,
+                         context, level)
+
+    def _format_dict_items(self, items, stream, indent, allowance, context, level):
+        indent = indent + self._indent_per_level
+        delimnl = ',\n' + ' '.repeat(indent)
+        last_index = items.length - 1
+        for v'var i = 0; i < items.length; i++':
+            last = i is last_index
+            key = items[i][0]
+            ent = items[i][1]
+            rep = self._repr(key, context, level)
+            stream.write(rep)
+            stream.write(': ')
+            self._format(ent, stream, indent + rep.length + 2,
+                         allowance if last else 1, context, level)
+            if not last:
+                stream.write(delimnl)
+
+    def _repr(self, obj, context, level):
+        r = _safe_repr(obj, context, self._depth, level, self._sort_dicts)
+        return r[0]
+
+    def format(self, object, context, maxlevels, level):
+        """Hook for subclasses; returns (string, readable, recursive)."""
+        return _safe_repr(object, context, maxlevels, level, self._sort_dicts)
+
+
+# ── module-level convenience functions ──────────────────────────────────────
+
+def pformat(object, indent=1, width=80, depth=None, compact=False,
+            sort_dicts=True, underscore_numbers=False):
+    """Pretty-print a value as a string."""
+    return PrettyPrinter(indent=indent, width=width, depth=depth,
+                         compact=compact, sort_dicts=sort_dicts,
+                         underscore_numbers=underscore_numbers).pformat(object)
+
+
+def pprint(object, stream=None, indent=1, width=80, depth=None,
+           compact=False, sort_dicts=True, underscore_numbers=False):
+    """Pretty-print a value to a stream, or to stdout if stream is None."""
+    PrettyPrinter(indent=indent, width=width, depth=depth, stream=stream,
+                  compact=compact, sort_dicts=sort_dicts,
+                  underscore_numbers=underscore_numbers).pprint(object)
+
+
+def pp(object, stream=None, indent=1, width=80, depth=None,
+       compact=False, sort_dicts=False, underscore_numbers=False):
+    """Pretty-print with sort_dicts=False by default."""
+    pprint(object, stream=stream, indent=indent, width=width, depth=depth,
+           compact=compact, sort_dicts=sort_dicts,
+           underscore_numbers=underscore_numbers)
+
+
+def saferepr(object):
+    """Like repr() but recursive references are marked as <Recursion ...>."""
+    r = _safe_repr(object, v'new Map()', None, 0, True)
+    return r[0]
+
+
+def isreadable(object):
+    """True if pformat(object) is readable by eval()."""
+    r = _safe_repr(object, v'new Map()', None, 0, True)
+    return r[1] and not r[2]
+
+
+def isrecursive(object):
+    """True if object contains any recursive references."""
+    r = _safe_repr(object, v'new Map()', None, 0, True)
+    return r[2]

package/src/lib/random.pyj

@@ -1,118 +1,118 @@
-###########################################################
-# RapydScript Standard Library
-# Author: Alexander Tsepkov
-# Copyright 2013 Pyjeon Software LLC
-# License: Apache License    2.0
-# This library is covered under Apache license, so that
-# you can distribute it with your RapydScript applications.
-###########################################################
-
-
-# basic implementation of Python's 'random' library
-
-# JavaScript's Math.random() does not allow seeding its random generator, to bypass that, this module implements its own
-# version that can be seeded. I decided on RC4 algorithm for this.
-
-# please don't mess with this from the outside
-
-ρσ_seed_state = {
-    'key': [],
-    'key_i': 0,
-    'key_j': 0
-}
-
-ρσ_get_random_byte = def():
-    ρσ_seed_state.key_i = (ρσ_seed_state.key_i + 1) % 256
-    ρσ_seed_state.key_j = (ρσ_seed_state.key_j + ρσ_seed_state.key[ρσ_seed_state.key_i]) % 256
-    ρσ_seed_state.key[ρσ_seed_state.key_i], ρσ_seed_state.key[ρσ_seed_state.key_j] = \
-            ρσ_seed_state.key[ρσ_seed_state.key_j], ρσ_seed_state.key[ρσ_seed_state.key_i]
-    return ρσ_seed_state.key[(ρσ_seed_state.key[ρσ_seed_state.key_i] + \
-            ρσ_seed_state.key[ρσ_seed_state.key_j]) % 256]
-
-def seed(x=Date().getTime()):
-    ρσ_seed_state.key_i = ρσ_seed_state.key_j = 0
-    if jstype(x) is 'number':
-        x = x.toString()
-    elif jstype(x) is not 'string':
-        raise TypeError("unhashable type: '" + jstype(x) + "'")
-    for i in range(256):
-        ρσ_seed_state.key[i] = i
-    j = 0
-    for i in range(256):
-        j = (j + ρσ_seed_state.key[i] + x.charCodeAt(i % x.length)) % 256
-        ρσ_seed_state.key[i], ρσ_seed_state.key[j] = ρσ_seed_state.key[j], ρσ_seed_state.key[i]
-seed()
-
-def random():
-    n = 0
-    m = 1
-    for i in range(8):
-        n += ρσ_get_random_byte() * m
-        m *= 256
-    return v'n / 0x10000000000000000'
-
-def randrange():
-    if arguments.length is 1:
-        return randbelow(int(arguments[0]))
-    start = int(arguments[0])
-    stop = int(arguments[1])
-    if arguments.length < 3:
-        step = 1
-    else:
-        step = int(arguments[2])
-    width = stop - start
-    if step is 1:
-        if width > 0:
-            return start + randbelow(width)
-        raise ValueError("empty range for randrange()")
-    if step > 0:
-        n = (width + step - 1) // step
-    elif step < 0:
-        n = (width + step + 1) // step
-    else:
-        raise ValueError("zero step for randrange()")
-    if n <= 0:
-        raise ValueError(f"empty range in randrange({start}, {stop}, {step})")
-    return start + step * randbelow(n)
-
-
-def randint(a, b):
-    return int(random()*(b-a+1) + a)
-
-def uniform(a, b):
-    return random()*(b-a) + a
-
-def randbelow(n):
-    return Math.floor(random()*n)
-
-def choice(seq):
-    if seq.length > 0:
-        return seq[randbelow(seq.length)]
-    else:
-        raise IndexError()
-
-# uses Fisher-Yates algorithm to shuffle an array
-def shuffle(x, random_f=random):
-    for i in range(x.length):
-        j = Math.floor(random_f() * (i+1))
-        x[i], x[j] = x[j], x[i]
-    return x
-
-# similar to shuffle, but only shuffles a subset and creates a copy
-def sample(population, k):
-    x = population.slice()
-    for i in range(population.length-1, population.length-k-1, -1):
-        j = Math.floor(random() * (i+1))
-        x[i], x[j] = x[j], x[i]
-    return x.slice(population.length-k)
-
-
-#import stdlib
-#a = range(50)
-#random.seed(5)
-#print(random.choice(a))
-#print(random.shuffle(a))
-#print(random.randrange(10))
-#print(random.randint(1,5))
-#print(random.uniform(1,5))
-#print(random.sample(range(20),5))
+###########################################################
+# RapydScript Standard Library
+# Author: Alexander Tsepkov
+# Copyright 2013 Pyjeon Software LLC
+# License: Apache License    2.0
+# This library is covered under Apache license, so that
+# you can distribute it with your RapydScript applications.
+###########################################################
+
+
+# basic implementation of Python's 'random' library
+
+# JavaScript's Math.random() does not allow seeding its random generator, to bypass that, this module implements its own
+# version that can be seeded. I decided on RC4 algorithm for this.
+
+# please don't mess with this from the outside
+
+ρσ_seed_state = {
+    'key': [],
+    'key_i': 0,
+    'key_j': 0
+}
+
+ρσ_get_random_byte = def():
+    ρσ_seed_state.key_i = (ρσ_seed_state.key_i + 1) % 256
+    ρσ_seed_state.key_j = (ρσ_seed_state.key_j + ρσ_seed_state.key[ρσ_seed_state.key_i]) % 256
+    ρσ_seed_state.key[ρσ_seed_state.key_i], ρσ_seed_state.key[ρσ_seed_state.key_j] = \
+            ρσ_seed_state.key[ρσ_seed_state.key_j], ρσ_seed_state.key[ρσ_seed_state.key_i]
+    return ρσ_seed_state.key[(ρσ_seed_state.key[ρσ_seed_state.key_i] + \
+            ρσ_seed_state.key[ρσ_seed_state.key_j]) % 256]
+
+def seed(x=Date().getTime()):
+    ρσ_seed_state.key_i = ρσ_seed_state.key_j = 0
+    if jstype(x) is 'number':
+        x = x.toString()
+    elif jstype(x) is not 'string':
+        raise TypeError("unhashable type: '" + jstype(x) + "'")
+    for i in range(256):
+        ρσ_seed_state.key[i] = i
+    j = 0
+    for i in range(256):
+        j = (j + ρσ_seed_state.key[i] + x.charCodeAt(i % x.length)) % 256
+        ρσ_seed_state.key[i], ρσ_seed_state.key[j] = ρσ_seed_state.key[j], ρσ_seed_state.key[i]
+seed()
+
+def random():
+    n = 0
+    m = 1
+    for i in range(8):
+        n += ρσ_get_random_byte() * m
+        m *= 256
+    return v'n / 0x10000000000000000'
+
+def randrange():
+    if arguments.length is 1:
+        return randbelow(int(arguments[0]))
+    start = int(arguments[0])
+    stop = int(arguments[1])
+    if arguments.length < 3:
+        step = 1
+    else:
+        step = int(arguments[2])
+    width = stop - start
+    if step is 1:
+        if width > 0:
+            return start + randbelow(width)
+        raise ValueError("empty range for randrange()")
+    if step > 0:
+        n = (width + step - 1) // step
+    elif step < 0:
+        n = (width + step + 1) // step
+    else:
+        raise ValueError("zero step for randrange()")
+    if n <= 0:
+        raise ValueError(f"empty range in randrange({start}, {stop}, {step})")
+    return start + step * randbelow(n)
+
+
+def randint(a, b):
+    return int(random()*(b-a+1) + a)
+
+def uniform(a, b):
+    return random()*(b-a) + a
+
+def randbelow(n):
+    return Math.floor(random()*n)
+
+def choice(seq):
+    if seq.length > 0:
+        return seq[randbelow(seq.length)]
+    else:
+        raise IndexError()
+
+# uses Fisher-Yates algorithm to shuffle an array
+def shuffle(x, random_f=random):
+    for i in range(x.length):
+        j = Math.floor(random_f() * (i+1))
+        x[i], x[j] = x[j], x[i]
+    return x
+
+# similar to shuffle, but only shuffles a subset and creates a copy
+def sample(population, k):
+    x = population.slice()
+    for i in range(population.length-1, population.length-k-1, -1):
+        j = Math.floor(random() * (i+1))
+        x[i], x[j] = x[j], x[i]
+    return x.slice(population.length-k)
+
+
+#import stdlib
+#a = range(50)
+#random.seed(5)
+#print(random.choice(a))
+#print(random.shuffle(a))
+#print(random.randrange(10))
+#print(random.randint(1,5))
+#print(random.uniform(1,5))
+#print(random.sample(range(20),5))