rapydscript-ns 0.8.4 → 0.9.0

package/src/lib/uuid.pyj

@@ -1,77 +1,77 @@
-# vim:fileencoding=utf-8
-# License: BSD Copyright: 2017, Kovid Goyal <kovid at kovidgoyal.net>
-# globals: crypto
-from __python__ import hash_literals
-
-from encodings import hexlify, urlsafe_b64decode, urlsafe_b64encode
-
-RFC_4122 = 1
-
-if jstype(crypto) is 'object' and crypto.getRandomValues:
-    random_bytes = def (num):
-        ans = Uint8Array(num or 16)
-        crypto.getRandomValues(ans)
-        return ans
-else:
-    random_bytes = def (num):
-        ans = Uint8Array(num or 16)
-        for i in range(ans.length):
-            ans[i] = Math.floor(Math.random() * 256)
-        return ans
-
-
-def uuid4_bytes():
-    data = random_bytes()
-    data[6] = 0b01000000 | (data[6] & 0b1111)
-    data[8] = (((data[8] >> 4) & 0b11 | 0b1000) << 4) | (data[8] & 0b1111)
-    return data
-
-
-def as_str():
-    h = this.hex
-    return h[:8] + '-' + h[8:12] + '-' + h[12:16] + '-' + h[16:20] + '-' + h[20:]
-
-
-def uuid4():
-    b = uuid4_bytes()
-    return {
-        'hex': hexlify(b),
-        'bytes': b,
-        'variant': RFC_4122,
-        'version': 4,
-        '__str__': as_str,
-        'toString': as_str,
-    }
-
-
-def num_to_string(numbers, alphabet, pad_to_length):
-    ans = v'[]'
-    alphabet_len = alphabet.length
-    numbers = Array.prototype.slice.call(numbers)
-    for v'var i = 0; i < numbers.length - 1; i++':
-        x = divmod(numbers[i], alphabet_len)
-        numbers[i] = x[0]
-        numbers[i+1] += x[1]
-    for v'var i = 0; i < numbers.length; i++':
-        number = numbers[i]
-        while number:
-            x = divmod(number, alphabet_len)
-            number = x[0]
-            ans.push(alphabet[x[1]])
-    if pad_to_length and pad_to_length > ans.length:
-        ans.push(alphabet[0].repeat(pad_to_length - ans.length))
-    return ans.join('')
-
-
-def short_uuid():
-    # A totally random uuid encoded using only URL and filename safe characters
-    return urlsafe_b64encode(random_bytes(), '')
-
-
-def short_uuid4():
-    # A uuid4 encoded using only URL and filename safe characters
-    return urlsafe_b64encode(uuid4_bytes(), '')
-
-
-def decode_short_uuid(val):
-    return urlsafe_b64decode(val + '==')
+# vim:fileencoding=utf-8
+# License: BSD Copyright: 2017, Kovid Goyal <kovid at kovidgoyal.net>
+# globals: crypto
+from __python__ import hash_literals
+
+from encodings import hexlify, urlsafe_b64decode, urlsafe_b64encode
+
+RFC_4122 = 1
+
+if jstype(crypto) is 'object' and crypto.getRandomValues:
+    random_bytes = def (num):
+        ans = Uint8Array(num or 16)
+        crypto.getRandomValues(ans)
+        return ans
+else:
+    random_bytes = def (num):
+        ans = Uint8Array(num or 16)
+        for i in range(ans.length):
+            ans[i] = Math.floor(Math.random() * 256)
+        return ans
+
+
+def uuid4_bytes():
+    data = random_bytes()
+    data[6] = 0b01000000 | (data[6] & 0b1111)
+    data[8] = (((data[8] >> 4) & 0b11 | 0b1000) << 4) | (data[8] & 0b1111)
+    return data
+
+
+def as_str():
+    h = this.hex
+    return h[:8] + '-' + h[8:12] + '-' + h[12:16] + '-' + h[16:20] + '-' + h[20:]
+
+
+def uuid4():
+    b = uuid4_bytes()
+    return {
+        'hex': hexlify(b),
+        'bytes': b,
+        'variant': RFC_4122,
+        'version': 4,
+        '__str__': as_str,
+        'toString': as_str,
+    }
+
+
+def num_to_string(numbers, alphabet, pad_to_length):
+    ans = v'[]'
+    alphabet_len = alphabet.length
+    numbers = Array.prototype.slice.call(numbers)
+    for v'var i = 0; i < numbers.length - 1; i++':
+        x = divmod(numbers[i], alphabet_len)
+        numbers[i] = x[0]
+        numbers[i+1] += x[1]
+    for v'var i = 0; i < numbers.length; i++':
+        number = numbers[i]
+        while number:
+            x = divmod(number, alphabet_len)
+            number = x[0]
+            ans.push(alphabet[x[1]])
+    if pad_to_length and pad_to_length > ans.length:
+        ans.push(alphabet[0].repeat(pad_to_length - ans.length))
+    return ans.join('')
+
+
+def short_uuid():
+    # A totally random uuid encoded using only URL and filename safe characters
+    return urlsafe_b64encode(random_bytes(), '')
+
+
+def short_uuid4():
+    # A uuid4 encoded using only URL and filename safe characters
+    return urlsafe_b64encode(uuid4_bytes(), '')
+
+
+def decode_short_uuid(val):
+    return urlsafe_b64decode(val + '==')

package/src/monaco-language-service/builtins.js

@@ -79,6 +79,11 @@ const STUBS = [
         return_type: 'str',
         doc: 'Return the string representing a character at Unicode code point i.' }),
 
+    new BuiltinInfo({ name: 'complex', kind: 'class',
+        params: [p('real_or_string', { optional: true }), p('imag', { type: 'number', optional: true })],
+        return_type: 'complex',
+        doc: 'Create a complex number.\n\nForms:\n- `complex()` → `0j`\n- `complex(x)` → `x+0j` (from int/float/bool/complex), or parse Python complex string\n- `complex(real, imag)` → `real + imag*j`\n\nLiteral syntax: `4j` is equivalent to `complex(0, 4)`, and `3+4j` creates a complex number via addition.\n\nAttributes:\n- `.real` — the real part (float)\n- `.imag` — the imaginary part (float)\n\nMethods:\n- `.conjugate()` — return the complex conjugate `(real - imag*j)`\n\nSupports: `+`, `-`, `*`, `/`, `**`, unary `-`/`+`, `abs()`, `bool()`, `==`, `repr()`, `str()`.\n\nExample:\n\n    c = complex(3, 4)\n    c.real            # 3\n    c.imag            # 4\n    abs(c)            # 5.0\n    c.conjugate()     # (3-4j)\n    c * complex(1, 2) # (-5+10j)\n    3 + 4j            # (3+4j)  — literal syntax' }),
+
     new BuiltinInfo({ name: 'dict', kind: 'class',
         params: [p('**kwargs', { rest: true })],
         return_type: 'dict',
@@ -112,7 +117,7 @@ const STUBS = [
     new BuiltinInfo({ name: 'float', kind: 'class',
         params: [p('x', { optional: true })],
         return_type: 'float',
-        doc: 'Return a floating-point number from x.' }),
+        doc: 'Return a floating-point number from x.\n\nInstance method:\n- `.is_integer()` — return `True` if the float has no fractional part (i.e. is a whole number), `False` otherwise. `Infinity` and `NaN` return `False`.\n\nExample:\n\n    (1.0).is_integer()   # True\n    (1.5).is_integer()   # False\n    (1e10).is_integer()  # True' }),
 
     new BuiltinInfo({ name: 'getattr',
         params: [p('obj'), p('name', { type: 'str' }), p('default', { optional: true })],
@@ -142,7 +147,7 @@ const STUBS = [
     new BuiltinInfo({ name: 'int', kind: 'class',
         params: [p('x', { optional: true }), p('base', { type: 'int', optional: true })],
         return_type: 'int',
-        doc: 'Return an integer from x, optionally in the given base.' }),
+        doc: 'Return an integer from x, optionally in the given base.\n\nInstance method:\n- `.bit_length()` — return the number of bits needed to represent the integer in binary, excluding the sign and leading zeros. Equivalent to `floor(log2(abs(n))) + 1` for nonzero `n`; returns `0` for `0`.\n\nExample:\n\n    (0).bit_length()    # 0\n    (1).bit_length()    # 1\n    (255).bit_length()  # 8\n    (256).bit_length()  # 9\n    (-5).bit_length()   # 3  (sign ignored)' }),
 
     new BuiltinInfo({ name: 'isinstance',
         params: [p('obj'), p('classinfo')],
@@ -174,6 +179,11 @@ const STUBS = [
         return_type: 'any',
         doc: 'Retrieve the next item from an iterator. If the iterator is exhausted, return default; if default is not given, raise StopIteration.' }),
 
+    new BuiltinInfo({ name: 'object', kind: 'class',
+        params: [],
+        return_type: 'object',
+        doc: 'Create a new featureless base object instance.\n\nThe base class of all Python classes. Calling `object()` with no arguments returns a new, unique instance useful as a sentinel value:\n\n    MISSING = object()   # unique sentinel\n    if value is MISSING:\n        ...\n\nKey behaviours:\n- Each call returns a distinct instance (`object() is not object()`).\n- `isinstance(x, object)` returns `True` for any `object()` instance (and subclasses).\n- `class Foo(object):` works as an explicit base class.\n- `repr()` returns `\'<object object at 0x…>\'`.\n- `hash()` returns a stable identity hash.\n\nNote: unlike Python, you *can* add arbitrary attributes to an `object()` instance in RapydScript (JS objects are open by default).' }),
+
     new BuiltinInfo({ name: 'map',
         params: [p('function'), p('iterable'), p('*iterables', { rest: true })],
         return_type: 'iterable',
@@ -265,9 +275,9 @@ const STUBS = [
         doc: 'Return the type of an object.' }),
 
     new BuiltinInfo({ name: 'zip',
-        params: [p('*iterables', { rest: true })],
+        params: [p('*iterables', { rest: true }), p('strict', { optional: true })],
         return_type: 'iterable',
-        doc: 'Return an iterator of tuples, where each tuple groups the i-th element from each iterable.' }),
+        doc: 'Return an iterator of tuples, where each tuple groups the i-th element from each iterable. With strict=True, raises ValueError if the iterables have different lengths.' }),
 
     // ── RapydScript-specific ──────────────────────────────────────────────
     new BuiltinInfo({ name: 'jstype',

package/src/monaco-language-service/diagnostics.js

@@ -26,9 +26,9 @@ const MESSAGES = {
 // with the compiler from src/lib/).  These should never produce 'Unknown module'
 // errors regardless of what virtualFiles or stdlibFiles are configured.
 export const STDLIB_MODULES = [
-    'aes', 'collections', 'copy', 'elementmaker', 'encodings', 'functools',
-    'gettext', 'itertools', 'math', 'numpy', 'operator', 'pythonize',
-    'random', 're', 'react', 'traceback', 'uuid',
+    'abc', 'aes', 'collections', 'copy', 'dataclasses', 'elementmaker', 'encodings', 'enum',
+    'functools', 'gettext', 'itertools', 'math', 'numpy', 'operator',
+    'pythonize', 'random', 're', 'react', 'traceback', 'typing', 'uuid',
     // Pseudo-modules for language feature flags (from __python__ import ...)
     '__python__', '__builtins__',
 ];
@@ -39,16 +39,16 @@ STDLIB_MODULES.forEach(m => { _STDLIB_MODULE_SET[m] = true; });
 // Symbols always available in RapydScript (from tools/lint.js BUILTINS list).
 export const BASE_BUILTINS = (
     'this self window document chr ord iterator_symbol print len range dir' +
-    ' eval undefined arguments abs max min enumerate pow callable reversed sum' +
+    ' eval exec undefined arguments abs max min enumerate pow callable reversed sum' +
     ' getattr isFinite setattr hasattr parseInt parseFloat options_object' +
     ' isNaN JSON Math list set list_wrap ρσ_modules require bool int bin' +
-    ' float iter Error EvalError set_wrap frozenset RangeError ReferenceError SyntaxError' +
+    ' float complex iter Error EvalError set_wrap frozenset RangeError ReferenceError SyntaxError' +
     ' str TypeError URIError Exception AssertionError IndexError AttributeError KeyError' +
     ' ValueError ZeroDivisionError ImportError ModuleNotFoundError StopIteration map hex filter zip dict dict_wrap UnicodeDecodeError HTMLCollection' +
     ' NodeList alert console Node Symbol NamedNodeMap ρσ_eslice ρσ_delslice Number' +
     ' Boolean encodeURIComponent decodeURIComponent setTimeout setInterval' +
     ' setImmediate clearTimeout clearInterval clearImmediate requestAnimationFrame' +
-    ' id repr sorted __name__ equals get_module ρσ_str jstype divmod NaN super Ellipsis slice all any next __import__ ρσ_new ρσ_object_new hash ρσ_object_setattr ρσ_object_getattr ρσ_object_delattr ExceptionGroup BaseExceptionGroup tuple'
+    ' id repr sorted __name__ equals get_module ρσ_str jstype divmod NaN super Ellipsis slice all any next __import__ ρσ_new ρσ_object_new hash ρσ_object_setattr ρσ_object_getattr ρσ_object_delattr ExceptionGroup BaseExceptionGroup tuple bytes bytearray format object vars locals globals'
 ).split(' ');
 
 // ---------------------------------------------------------------------------
@@ -423,24 +423,23 @@ function Linter(RS, toplevel, code, builtins, knownModules) {
 
     this.handle_for_in = function() {
         const node = this.current_node;
+        const add_loop_var = (cnode) => {
+            if (cnode instanceof RS.AST_Seq) {
+                cnode.to_array().forEach(add_loop_var);
+            } else if (cnode instanceof RS.AST_Array) {
+                cnode.elements.forEach(add_loop_var);
+            } else if (cnode instanceof RS.AST_SymbolRef) {
+                this.current_node = cnode;
+                cnode.lint_visited = true;
+                this.add_binding(cnode.name).is_loop = true;
+                this.current_node = node;
+            }
+        };
         if (node.init instanceof RS.AST_SymbolRef) {
             this.add_binding(node.init.name).is_loop = true;
             node.init.lint_visited = true;
         } else if (node.init instanceof RS.AST_Array) {
-            node.init.elements.forEach(cnode => {
-                if (cnode instanceof RS.AST_Seq) cnode = cnode.to_array();
-                if (cnode instanceof RS.AST_SymbolRef) cnode = [cnode];
-                if (Array.isArray(cnode)) {
-                    cnode.forEach(elem => {
-                        if (elem instanceof RS.AST_SymbolRef) {
-                            this.current_node = elem;
-                            elem.lint_visited = true;
-                            this.add_binding(elem.name).is_loop = true;
-                            this.current_node = node;
-                        }
-                    });
-                }
-            });
+            node.init.elements.forEach(add_loop_var);
         }
     };