rapydscript-ns 0.9.2 → 0.9.3

package/src/lib/urllib/request.pyj

@@ -0,0 +1,86 @@
+###########################################################
+# RapydScript Standard Library
+# urllib.request — HTTP requests via the Fetch API
+###########################################################
+#
+# Provides:
+#   urlopen(url[, data[, timeout]])  — open a URL; returns a Promise
+#
+# Usage (inside an async function):
+#   from urllib.request import urlopen
+#
+#   async def fetch_json(url):
+#       resp = await urlopen(url)
+#       data = await resp.json()
+#       return data
+#
+# The response object exposes:
+#   .status   -- HTTP status code (int)
+#   .reason   -- HTTP status text (str)
+#   .url      -- final URL after any redirects (str)
+#   .headers  -- plain dict of lowercase header names → values
+#   .read()   -- Promise → response body as a string
+#   .json()   -- Promise → parsed JSON response body
+#   .close()  -- no-op (for API compatibility)
+#
+# Raises urllib.error.HTTPError for non-2xx responses.
+# Raises urllib.error.URLError for network/timeout failures.
+#
+# Note: urlopen() wraps the browser/Node Fetch API and therefore returns a
+# Promise.  It must be awaited inside an async function.  There is no
+# synchronous version because JavaScript has no synchronous HTTP.
+
+from urllib.error import URLError, HTTPError
+
+
+def urlopen(url, data=None, timeout=None):
+    """Open url, returning a Promise that resolves to a response object.
+
+    url     -- the URL to open (string)
+    data    -- if given, the request uses POST and sends data as the body
+    timeout -- seconds before an AbortController cancels the request (float)
+
+    On success the Promise resolves to an object with .status, .reason, .url,
+    .headers, .read(), .json(), and .close() (see module docstring).
+    On HTTP error (non-2xx status) the Promise rejects with HTTPError.
+    On network failure the Promise rejects with URLError.
+    """
+    v"""
+    var _opts = { method: data != null ? 'POST' : 'GET' };
+    if (data != null) {
+        _opts.body = data;
+        _opts.headers = { 'Content-Type': 'application/x-www-form-urlencoded' };
+    }
+    var _abort = null;
+    if (timeout != null && typeof AbortController !== 'undefined') {
+        var _ctrl = new AbortController();
+        _opts.signal = _ctrl.signal;
+        _abort = setTimeout(function() { _ctrl.abort(); }, timeout * 1000);
+    }
+    return Promise.resolve()
+        .then(function() { return fetch(url, _opts); })
+        .then(function(resp) {
+            if (_abort) { clearTimeout(_abort); _abort = null; }
+            var hdrs = {};
+            if (resp.headers && typeof resp.headers.forEach === 'function') {
+                resp.headers.forEach(function(v, k) { hdrs[k] = v; });
+            }
+            if (!resp.ok) {
+                throw new HTTPError(resp.url, resp.status, resp.statusText, hdrs, null);
+            }
+            return {
+                status:  resp.status,
+                reason:  resp.statusText,
+                url:     resp.url,
+                headers: hdrs,
+                read:    function() { return resp.text(); },
+                json:    function() { return resp.json(); },
+                close:   function() {}
+            };
+        })
+        .catch(function(e) {
+            if (_abort) { clearTimeout(_abort); _abort = null; }
+            if (e instanceof HTTPError) throw e;
+            throw new URLError(String(e));
+        });
+    """

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/analyzer.js

@@ -236,6 +236,7 @@ class ScopeBuilder {
             return_type:    opts.return_type    || null,
             source_module:  opts.source_module  || null,
             original_name:  opts.original_name  || null,
+            is_bare_import: opts.is_bare_import || false,
         });
         scope.addSymbol(sym);
         return sym;
@@ -362,8 +363,10 @@ class ScopeBuilder {
             if (name) {
                 this._add_symbol({
                     name,
-                    kind:       'import',
-                    defined_at: pos_from_token(node.start),
+                    kind:           'import',
+                    defined_at:     pos_from_token(node.start),
+                    source_module:  node.key || null,
+                    is_bare_import: true,
                 });
             }
 

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

@@ -523,6 +523,32 @@ export class CompletionEngine {
             }
         }
 
+        // 1.1. Module member completions — `import X; X.attr`
+        //      When the symbol is a bare import, parse the module source and
+        //      expose its top-level symbols as dot-completions.
+        if (!scope_matched && obj_sym && obj_sym.is_bare_import && obj_sym.source_module) {
+            const mod_src = this._virtualFiles[obj_sym.source_module]
+                         || this._stdlibFiles[obj_sym.source_module];
+            if (mod_src) {
+                let mod_map;
+                try { mod_map = this._analyzer.analyze(mod_src, {}); } catch (_e) { /* ignore */ }
+                if (mod_map) {
+                    const mod_frame = mod_map.frames.find(f => f.kind === 'module');
+                    if (mod_frame) {
+                        scope_matched = true;
+                        for (const [name, sym] of mod_frame.symbols) {
+                            if (!ctx.prefix || name.startsWith(ctx.prefix)) {
+                                if (!seen.has(name)) {
+                                    seen.add(name);
+                                    items.push(symbol_to_item(sym, range, monacoKind, '0'));
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        }
+
         // 1.5. Built-in type members — list, str, dict, number.
         //      Used when inferred_class names a built-in type, not a user class.
         if (!scope_matched && this._builtins && obj_sym && obj_sym.inferred_class) {

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

@@ -20,15 +20,20 @@ const MESSAGES = {
     'def-after-use':  'The symbol "{name}" is defined (at line {line}) after it is used',
     'dup-key':        'Duplicate key "{name}" in object literal',
     'dup-method':     'The method "{name}" was defined previously at line: {line}',
+    'infinite-loop':  'This while loop may never exit (condition is always true and there is no await in the body)',
+    // type_enforcement diagnostics
+    'type-posonly-kwarg':   '"{name}" is positional-only and cannot be passed as a keyword argument to {func}()',
+    'type-too-many-args':   '{func}() takes at most {max} positional argument{plural} but {got} were given',
+    'type-missing-kwonly':  '"{name}" is a required keyword-only argument of {func}() and must be passed by name',
 };
 
 // Built-in stdlib modules that are always available in RapydScript (bundled
 // 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 = [
-    'abc', 'aes', 'collections', 'contextlib', 'copy', 'dataclasses', 'datetime', 'elementmaker', 'encodings', 'enum',
-    'functools', 'gettext', 'io', 'itertools', 'json', 'math', 'numpy', 'operator',
-    'pythonize', 'random', 're', 'react', 'traceback', 'typing', 'uuid',
+    'abc', 'aes', 'asyncio', 'base64', 'bisect', 'collections', 'contextlib', 'copy', 'csv', 'dataclasses', 'datetime', 'elementmaker', 'encodings', 'enum',
+    'functools', 'gettext', 'heapq', 'html', 'http', 'io', 'itertools', 'json', 'logging', 'math', 'numpy', 'operator',
+    'pythonize', 'random', 're', 'react', 'string', 'textwrap', 'traceback', 'typing', 'urllib', 'uuid',
     // Pseudo-modules for language feature flags (from __python__ import ...)
     '__python__', '__builtins__',
 ];
@@ -497,6 +502,42 @@ function Linter(RS, toplevel, code, builtins, knownModules) {
         if (node.alias) this.add_binding(node.alias.name);
     };
 
+    this.handle_while = function() {
+        const node = this.current_node;
+        const cond = node.condition;
+        const RS   = this.RS;
+
+        const is_trivially_true = (
+            (cond instanceof RS.AST_True) ||
+            (cond instanceof RS.AST_Number && cond.value !== 0)
+        );
+        if (!is_trivially_true) return;
+
+        let has_await = false;
+        const await_finder = {
+            _visit: function(n, cont) {
+                if (n instanceof RS.AST_Await) { has_await = true; return; }
+                if (cont) cont();
+            }
+        };
+        if (node.body) node.body._walk(await_finder);
+
+        if (!has_await) {
+            const sline = node.start ? node.start.line : 1;
+            const scol  = node.start ? node.start.col  : 0;
+            const eline = (node.condition && node.condition.end) ? node.condition.end.line : sline;
+            const ecol  = (node.condition && node.condition.end) ? node.condition.end.col  : scol;
+            this.messages.push({
+                start_line: sline, start_col: scol,
+                end_line:   eline, end_col:   ecol,
+                ident:   'infinite-loop',
+                message: MESSAGES['infinite-loop'],
+                level:   WARN,
+                name:    '',
+            });
+        }
+    };
+
     // The visitor function called by toplevel.walk()
     this._visit = function(node, cont) {
         if (node.lint_visited) return;
@@ -530,6 +571,7 @@ function Linter(RS, toplevel, code, builtins, knownModules) {
         else if (node instanceof RS.AST_EmptyStatement)  this.handle_empty_statement();
         else if (node instanceof RS.AST_WithClause)      this.handle_with_clause();
         else if (node instanceof RS.AST_Object)          this.handle_object_literal();
+        else if (node instanceof RS.AST_While)           this.handle_while();
 
         if (node instanceof RS.AST_Scope) this.handle_scope();
 
@@ -580,6 +622,143 @@ function Linter(RS, toplevel, code, builtins, knownModules) {
     };
 }
 
+// ---------------------------------------------------------------------------
+// Type-enforcement static checker
+// Runs a two-pass walk when any function in the file has type_enforce=true:
+//   Pass 1 — collect signatures of enforced functions.
+//   Pass 2 — inspect call sites and report violations.
+// ---------------------------------------------------------------------------
+
+function check_type_enforcement(RS, toplevel, messages) {
+    // Pass 1: collect signatures of functions compiled with type_enforce=true
+    const sigs = Object.create(null);
+
+    const col1 = {
+        _visit: function(node, cont) {
+            if (node instanceof RS.AST_Lambda && node.type_enforce && node.name) {
+                const a    = node.argnames;
+                const is_m = node instanceof RS.AST_Method;
+                const off  = (is_m && !node.static) ? 1 : 0;
+                const posonly_names = [];
+                const kwonly_req    = [];
+                let max_pos = 0;
+                const defs = (a.defaults) || {};
+                for (let i = off; i < a.length; i++) {
+                    const arg = a[i];
+                    if (arg.posonly) posonly_names.push(arg.name);
+                    if (arg.kwonly) {
+                        if (!has_prop(defs, arg.name)) kwonly_req.push(arg.name);
+                        continue;
+                    }
+                    max_pos++;
+                }
+                sigs[node.name.name] = {
+                    node,
+                    posonly_names,
+                    kwonly_req,
+                    max_pos,
+                    has_starargs: !!a.starargs,
+                    has_kwargs:   !!a.kwargs,
+                };
+            }
+            if (cont) cont();
+        }
+    };
+    toplevel.walk(col1);
+
+    if (Object.keys(sigs).length === 0) return;
+
+    // Pass 2: check call sites
+    const col2 = {
+        _visit: function(node, cont) {
+            if (node instanceof RS.AST_BaseCall) {
+                let fname = null;
+                const expr = node.expression;
+                if (expr instanceof RS.AST_SymbolRef) fname = expr.name;
+                else if (expr instanceof RS.AST_Dot)  fname = expr.property;
+
+                if (fname && has_prop(sigs, fname)) {
+                    const sig         = sigs[fname];
+                    const args        = node.args;
+                    const pos_count   = args ? args.length : 0;
+                    const named_kw    = (args && args.kwargs) ? args.kwargs : [];
+                    const kw_expand   = args && args.kwarg_items && args.kwarg_items.length > 0;
+
+                    // Positional-only args passed as named kwargs
+                    sig.posonly_names.forEach(argname => {
+                        for (let ki = 0; ki < named_kw.length; ki++) {
+                            const knode = named_kw[ki][0];
+                            const kname = knode.name || (knode.value !== undefined ? String(knode.value) : null);
+                            if (kname === argname) {
+                                const msg = MESSAGES['type-posonly-kwarg']
+                                    .replace('{name}', argname)
+                                    .replace('{func}', fname);
+                                messages.push({
+                                    ident:      'type-posonly-kwarg',
+                                    message:    msg,
+                                    level:      ERROR,
+                                    name:       argname,
+                                    start_line: knode.start ? knode.start.line : 1,
+                                    start_col:  knode.start ? knode.start.col  : 0,
+                                    end_line:   knode.end   ? knode.end.line   : undefined,
+                                    end_col:    knode.end   ? knode.end.col    : undefined,
+                                });
+                            }
+                        }
+                    });
+
+                    // Too many positional args (skip when *args or **expansion present)
+                    if (!sig.has_starargs && !kw_expand && pos_count > sig.max_pos) {
+                        const plural = sig.max_pos === 1 ? '' : 's';
+                        const msg = MESSAGES['type-too-many-args']
+                            .replace('{func}', fname)
+                            .replace('{max}',  String(sig.max_pos))
+                            .replace('{plural}', plural)
+                            .replace('{got}',  String(pos_count));
+                        messages.push({
+                            ident:      'type-too-many-args',
+                            message:    msg,
+                            level:      ERROR,
+                            name:       fname,
+                            start_line: node.start ? node.start.line : 1,
+                            start_col:  node.start ? node.start.col  : 0,
+                            end_line:   node.end   ? node.end.line   : undefined,
+                            end_col:    node.end   ? node.end.col    : undefined,
+                        });
+                    }
+
+                    // Required keyword-only args not provided (skip when **expansion present)
+                    if (!kw_expand) {
+                        sig.kwonly_req.forEach(argname => {
+                            const provided = named_kw.some(pair => {
+                                const kn = pair[0].name || (pair[0].value !== undefined ? String(pair[0].value) : null);
+                                return kn === argname;
+                            });
+                            if (!provided) {
+                                const msg = MESSAGES['type-missing-kwonly']
+                                    .replace('{name}', argname)
+                                    .replace('{func}', fname);
+                                messages.push({
+                                    ident:      'type-missing-kwonly',
+                                    message:    msg,
+                                    level:      ERROR,
+                                    name:       argname,
+                                    start_line: node.start ? node.start.line : 1,
+                                    start_col:  node.start ? node.start.col  : 0,
+                                    end_line:   node.end   ? node.end.line   : undefined,
+                                    end_col:    node.end   ? node.end.col    : undefined,
+                                });
+                            }
+                        });
+                    }
+                }
+            }
+            if (cont) cont();
+        }
+    };
+    toplevel.walk(col2);
+}
+
 // ---------------------------------------------------------------------------
 // Convert lint message → Monaco IMarkerData
 // markerSeverity should be { Error, Warning, Info, Hint } numeric values
@@ -709,6 +888,26 @@ export class Diagnostics {
         toplevel.walk(linter);
         messages = linter.resolve(noqa);
 
+        // --- Type enforcement static checks ---
+        // Run when type_enforcement is active at the file level (either via
+        // pythonFlags constructor arg or from __python__ import type_enforcement).
+        const te_active =
+            (this._scoped_flags && this._scoped_flags.type_enforcement) ||
+            (toplevel.scoped_flags && toplevel.scoped_flags.type_enforcement);
+        if (te_active) {
+            const te_messages = [];
+            check_type_enforcement(RS, toplevel, te_messages);
+            // Filter noqa, then convert to markers inline
+            te_messages.forEach(m => {
+                if (noqa && has_prop(noqa, m.ident)) return;
+                messages.push(m);
+            });
+            messages.sort((a, b) => {
+                const dl = (a.start_line || 0) - (b.start_line || 0);
+                return dl !== 0 ? dl : (a.start_col || 0) - (b.start_col || 0);
+            });
+        }
+
         return messages.map(m => to_marker(m, markerSeverity));
     }
 }