rapydscript-ns 0.8.0 → 0.8.2

package/TODO.md

@@ -1,62 +1,30 @@
 
 ### libraries
-- allow var etc as property name
-- revert numpy variance method to be var
 
-- omit_function_metadata breaks imports - it needs to be changed to only affect imported modules, maybe?
+- bitburner - handle missed await / concurrency errors gracefully?
+   - two space tabs
+
+- fix error from vuln report
+- https://socket.dev/npm/package/rapydscript-ns/alerts/0.8.1?tab=dependencies
+- https://snyk.io/test/github/ficocelliguy/rapydscript-ns
 
-- variables just say (variable) on hover, not their type?
+- omit_function_metadata breaks imports - it needs to be changed to only affect imported modules, maybe?
 
 - vscode plugin based on language service
 
-- export language service to npm module
-- update url links
-- make npm module
+- export .t.ds for language service
 
+- add opt-out for python truthyness
+- add web-repl flag for python truthiness?
+- include python truthiness in compiler call
 
+- update changelist for 8.0
 
 I would like you to add support for [  Python's extended subscript syntax where commas inside [] implicitly form a tuple ] to rapydscript. It should have the same syntax as the Python implementation, and be transpiled into equivalent javascript. Please ensure with unit tests that it transpiles and the output JS runs correctly, and that the language service correctly handles it in parsed code. Please make sure it works in the web-repl too. Please also update the README to mention this support.
 
 
 
 
-# 1. Placeholder body (like pass)
-def todo():
-  ...
-
-class MyProtocol:
-  def method(self) -> int: ...
-
-
-# 3. Sentinel / default marker
-_MISSING = ...
-
-def greet(name=...):                                    
-  if name is ...:                                   
-    name = "World"                                                                                                                                                                           
-  print(f"Hello, {name}!")
-
-greet()           # Hello, World!                                                                                                                                                                
-greet("Alice")    # Hello, Alice!
-
-
-# 4. NumPy-style slice shorthand (all leading dimensions)
-import numpy as np                                                                                                                                                                               
-arr = np.zeros((2, 3, 4))                                                                                                                                                                        
-print(arr[..., 0] )  # shape (2, 3) — first element of last axis                                                                                                                                        
-print(arr[1, ...])   # shape (3, 4) — entire second "sheet"
-
-# 5. Identity check
-print(... is ...)        # True  (singleton)                                                                                                                                                     
-print(... is Ellipsis)   # True                                                                                                                                                                  
-print(type(...).__name__) # ellipsis
-
-
-
-
-
-
-
 Python Feature Gap Report: RapydScript-NS
 
 Summary
@@ -76,7 +44,7 @@ differences.
 ├───────────────────────────────────────────────┼────────────────┼──────────────────────────────────────────────────────────────┤
 │ lambda keyword                                │ all            │ -tested                                                      │
 ├───────────────────────────────────────────────┼────────────────┼──────────────────────────────────────────────────────────────┤
-│ Variable type annotations x: int = 1          │ 3.6+           │ needs testing                                                │
+│ Variable type annotations x: int = 1          │ 3.6+           │ -tested                                                      │
 ├───────────────────────────────────────────────┼────────────────┼──────────────────────────────────────────────────────────────┤
 │ Positional-only parameters (def f(a, /, b):)  │ 3.8+           │ -tested                                                      │
 ├───────────────────────────────────────────────┼────────────────┼──────────────────────────────────────────────────────────────┤
@@ -88,7 +56,7 @@ differences.
 ├───────────────────────────────────────────────┼────────────────┼──────────────────────────────────────────────────────────────┤
 │ Parenthesized with (multi-context)            │ 3.10+          │  - doesn't make sense in a web context                       │
 ├───────────────────────────────────────────────┼────────────────┼──────────────────────────────────────────────────────────────┤
-│ Exception chaining raise X from Y             │ 3.0+           │ Plain raise only                                             │
+│ Exception chaining raise X from Y             │ 3.0+           │ - done                                           │
 ├───────────────────────────────────────────────┼────────────────┼──────────────────────────────────────────────────────────────┤
 │ except* (exception groups)                    │ 3.11+          │ No support                                                   │
 ├───────────────────────────────────────────────┼────────────────┼──────────────────────────────────────────────────────────────┤
@@ -96,7 +64,7 @@ differences.
 ├───────────────────────────────────────────────┼────────────────┼──────────────────────────────────────────────────────────────┤
 │ Complex number literals 3+4j                  │ all            │ No j suffix                                                  │
 ├───────────────────────────────────────────────┼────────────────┼──────────────────────────────────────────────────────────────┤
-│ Ellipsis literal ... as expression            │ all            │ Only valid as slice (a[...])                                 │
+│ Ellipsis literal ... as expression            │ all            │ -tested                                                      │
 ├───────────────────────────────────────────────┼────────────────┼──────────────────────────────────────────────────────────────┤
 │ b'...' bytes literals                         │ all            │ No b prefix; encoding module exists but no native bytes type │
 └───────────────────────────────────────────────┴────────────────┴──────────────────────────────────────────────────────────────┘
@@ -313,7 +281,8 @@ If prioritizing what to implement next, these have the highest user impact:
 
 1. super() — required for idiomatic OOP code - done
 2. Operator overloading (__add__, __lt__, etc.) — blocks numerical/scientific code - done
-3. __bool__ / truthiness fix — silent Python compatibility trap
+3. __bool__ / truthiness fix — silent Python compatibility trap - done
+   → frozenset — first medium-priority missing builtin - done
 4. lambda keyword — commonly expected - done
 5. all() / any() — extremely common builtins - done
 6. functools.reduce / partial — core functional programming tools - done

package/hack_demo.pyj

@@ -0,0 +1,112 @@
+# Over-engineered RapydScript hacking script — Python features on parade
+
+class HackAction:
+    """Enum-like action namespace."""
+    WEAKEN = 'weaken'
+    GROW   = 'grow'
+    HACK   = 'hack'
+
+    @staticmethod
+    def all():
+        return [HackAction.WEAKEN, HackAction.GROW, HackAction.HACK]
+
+
+class ServerConfig:
+    """Data-class-style target config with property + fluent builder."""
+
+    def __init__(self, name, money_factor=1.0, sec_buffer=0.0):
+        self._name        = name
+        self.money_factor = money_factor
+        self.sec_buffer   = sec_buffer
+        self._tags        = {'auto', 'hack'}        # set literal
+
+    @property
+    def name(self):
+        return self._name
+
+    def __repr__(self):
+        return "ServerConfig(name={}, tags={})".format(
+            repr(self._name), sorted(list(self._tags))
+        )
+
+    def add_tags(self, *tags):                      # *args + fluent return
+        for t in tags:
+            self._tags.add(t)
+        return self
+
+
+def decide_action(ns, target, money_thresh, sec_thresh):
+    """next() + generator expression to pick highest-priority action."""
+    checks = [
+        (ns.getServerSecurityLevel(target)  > sec_thresh,   HackAction.WEAKEN),
+        (ns.getServerMoneyAvailable(target) < money_thresh, HackAction.GROW),
+    ]
+    return next((action for cond, action in checks if cond), HackAction.HACK)
+
+
+async def breach(ns, target, exploits):
+    """Apply available exploits via (exe, fn) tuple list, nuke, return summary."""
+    # list of (exe filename, bound ns method) tuples
+    exe_methods = [
+        ('BruteSSH.exe',  ns.brutessh),
+        ('FTPCrack.exe',  ns.ftpcrack),
+        ('relaySMTP.exe', ns.relaysmtp),
+    ]
+    applied = [fn for exe, fn in exe_methods if ns.fileExists(exe, "home")]
+    missing = [exe for exe, fn in exe_methods if not ns.fileExists(exe, "home")]
+
+    if missing:
+        ns.tprint("Missing: {}".format(', '.join(missing)))
+
+    for fn in applied:
+        fn(target)
+    ns.nuke(target)
+
+    return {'applied': len(applied), 'total': len(exploits),
+            'rooted': ns.hasRootAccess(target)}
+
+
+async def main(ns):
+    config = ServerConfig("n00dles").add_tags('target', 'beginner')  # fluent
+    ns.tprint(repr(config))                                           # __repr__
+
+    target       = config.name                                        # @property
+    money_thresh = ns.getServerMaxMoney(target)         * config.money_factor
+    sec_thresh   = ns.getServerMinSecurityLevel(target) + config.sec_buffer
+
+    def by_name_len(p):                             # named key fn (required for
+        return len(p[0])                            # anonymous fns in call args)
+    exploits = sorted([
+        ('brutessh',  'BruteSSH.exe'),
+        ('ftpcrack',  'FTPCrack.exe'),
+        ('relaysmtp', 'relaySMTP.exe'),
+    ], key=by_name_len)
+
+    result = await breach(ns, target, exploits)
+    ns.tprint("Breach: {applied}/{total} applied, rooted={rooted}".format(**result))
+    assert result['rooted'], "Root access denied on {}!".format(target)
+
+    dispatch = {                                    # dict literal
+        'weaken': ns.weaken,
+        'grow':   ns.grow,
+        'hack':   ns.hack,
+    }
+    stats = {a: 0 for a in HackAction.all()}        # dict comprehension
+
+    cycle = 0
+    while True:
+        cycle += 1
+        action = decide_action(ns, target, money_thresh, sec_thresh)
+        stats[action] += 1
+
+        if cycle % 10 is 0:                         # periodic summary
+            counts  = [stats[a] for a in HackAction.all()]
+            summary = ', '.join(["{}: {}".format(a, v)
+                                 for a, v in zip(HackAction.all(), counts)])
+            ns.tprint("Cycle {} | {}  any={} all={}".format(
+                cycle, summary,
+                any([v > 0 for v in counts]),       # any()
+                all([v > 0 for v in counts])        # all()
+            ))
+
+        await dispatch[action](target)

package/package.json

@@ -9,6 +9,10 @@
     "compiler"
   ],
   "main": "tools/compiler.js",
+  "exports": {
+    ".": "./tools/compiler.js",
+    "./language-service": "./web-repl/language-service.js"
+  },
   "scripts": {
     "test": "node bin/rapydscript self --complete --test && npm run test:unit && npm run test:ls",
     "test:unit": "node test/unit/index.js",
@@ -16,9 +20,10 @@
     "start": "node bin/rapydscript",
     "build-self": "node bin/rapydscript self --complete",
     "build:ls": "node tools/build-language-service.js",
-    "build": "rm -rf **/*pyj-cached dev && node bin/rapydscript self --complete && node bin/web-repl-export web-repl && node tools/build-language-service.js"
+    "build": "rm -rf **/*pyj-cached dev && node bin/rapydscript self --complete && node bin/web-repl-export web-repl && node tools/build-language-service.js",
+    "prepublishOnly": "node tools/build-language-service.js"
   },
-  "version": "0.8.0",
+  "version": "0.8.2",
   "license": "BSD-2-Clause",
   "engines": {
     "node": ">=0.12.0"
@@ -37,9 +42,6 @@
     "regenerator": ">= 0.12.1",
     "uglify-js": ">= 3.0.15"
   },
-  "optionalDependencies": {
-    "v8-profiler": ">= 5.2.9"
-  },
   "bin": {
     "rapydscript": "bin/rapydscript"
   }

package/src/ast.pyj

@@ -159,6 +159,7 @@ class AST_Assert(AST_Statement):
     properties = {
         'condition': "[AST_Node] the expression that should be tested",
         'message': "[AST_Node*] the expression that is the error message or None",
+        'python_truthiness': "[bool] Whether to use Python truthiness (from __python__ import truthiness)"
     }
 
     def _walk(self, visitor):
@@ -213,7 +214,8 @@ class AST_StatementWithBody(AST_Statement):
 class AST_DWLoop(AST_StatementWithBody):
     "Base class for do/while statements"
     properties = {
-        'condition': "[AST_Node] the loop condition.  Should not be instanceof AST_Statement"
+        'condition': "[AST_Node] the loop condition.  Should not be instanceof AST_Statement",
+        'python_truthiness': "[bool] Whether to use Python truthiness (from __python__ import truthiness)"
     }
 
     def _walk(self, visitor):
@@ -227,13 +229,25 @@ class AST_Do(AST_DWLoop):
 
 class AST_While(AST_DWLoop):
     "A `while` statement"
+    properties = {
+        'belse': "[AST_Else?] the `else` clause, run when loop exits without `break`"
+    }
+
+    def _walk(self, visitor):
+        return visitor._visit(self, def():
+            self.condition._walk(visitor)
+            self.body._walk(visitor)
+            if self.belse:
+                self.belse._walk(visitor)
+        )
 
 class AST_ForIn(AST_StatementWithBody):
     "A `for ... in` statement"
     properties = {
         'init': "[AST_Node] the `for/in` initialization code",
         'name': "[AST_SymbolRef?] the loop variable, only if `init` is AST_Var",
-        'object': "[AST_Node] the object that we're looping through"
+        'object': "[AST_Node] the object that we're looping through",
+        'belse': "[AST_Else?] the `else` clause, run when no break occurred"
     }
 
     def _walk(self, visitor):
@@ -243,6 +257,8 @@ class AST_ForIn(AST_StatementWithBody):
             self.object._walk(visitor)
             if self.body:
                 self.body._walk(visitor)
+            if self.belse:
+                self.belse._walk(visitor)
         )
 
 class AST_ForJS(AST_StatementWithBody):
@@ -647,6 +663,9 @@ class AST_Await(AST_Node):
 
 class AST_Throw(AST_Exit):
     "A `throw` statement"
+    properties = {
+        'cause': "[AST_Node?] the __cause__ of the exception (from `raise X from Y`); may be None"
+    }
 
 class AST_LoopControl(AST_Jump):
     "Base class for loop control statements (`break` and `continue`)"
@@ -663,7 +682,8 @@ class AST_If(AST_StatementWithBody):
     "A `if` statement"
     properties = {
         'condition': "[AST_Node] the `if` condition",
-        'alternative': "[AST_Statement?] the `else` part, or null if not present"
+        'alternative': "[AST_Statement?] the `else` part, or null if not present",
+        'python_truthiness': "[bool] Whether to use Python truthiness (from __python__ import truthiness)"
     }
 
     def _walk(self, visitor):
@@ -767,7 +787,8 @@ class AST_BaseCall(AST_Node):
 class AST_Call(AST_BaseCall):
     "A function call expression"
     properties = {
-        'expression': "[AST_Node] expression to invoke as function"
+        'expression': "[AST_Node] expression to invoke as function",
+        'python_truthiness': "[bool] Whether to use Python truthiness for __call__ dispatch"
     }
 
     def _walk(self, visitor):
@@ -941,7 +962,8 @@ class AST_Unary(AST_Node):
         'operator': "[string] the operator",
         'expression': "[AST_Node] expression that this unary operator applies to",
         'parenthesized': "[bool] Whether this unary expression was parenthesized",
-        'overloaded': "[bool] Whether to use Python-style operator overloading dispatch"
+        'overloaded': "[bool] Whether to use Python-style operator overloading dispatch",
+        'python_truthiness': "[bool] Whether to use Python truthiness (from __python__ import truthiness)"
     }
 
     def _walk(self, visitor):
@@ -958,7 +980,8 @@ class AST_Binary(AST_Node):
         'left': "[AST_Node] left-hand side expression",
         'operator': "[string] the operator",
         'right': "[AST_Node] right-hand side expression",
-        'overloaded': "[bool] Whether to use Python-style operator overloading dispatch"
+        'overloaded': "[bool] Whether to use Python-style operator overloading dispatch",
+        'python_truthiness': "[bool] Whether to use Python truthiness (from __python__ import truthiness)"
     }
 
     def _walk(self, visitor):
@@ -987,6 +1010,7 @@ class AST_Conditional(AST_Node):
         'condition': "[AST_Node]",
         'consequent': "[AST_Node]",
         'alternative': "[AST_Node]",
+        'python_truthiness': "[bool] Whether to use Python truthiness (from __python__ import truthiness)"
     }
 
     def _walk(self, visitor):

package/src/baselib-builtins.pyj

@@ -5,7 +5,21 @@
 # globals: exports, console, ρσ_iterator_symbol, ρσ_kwargs_symbol, ρσ_arraylike, ρσ_list_contains
 
 def ρσ_bool(val):
-    return v'!!val'
+    # Python truthiness — written entirely with verbatim JS so that the
+    # compiled ρσ_bool function never calls itself (no bootstrap recursion).
+    v'if (val === null || val === undefined) return false'
+    v'var ρσ_bool_t = typeof val'
+    v'if (ρσ_bool_t === "boolean") return val'
+    v'if (ρσ_bool_t === "number") return val !== 0'
+    v'if (ρσ_bool_t === "string") return val.length > 0'
+    v'if (ρσ_bool_t === "function") return true'
+    v'if (val.constructor && val.constructor.prototype === val) return true'
+    v'if (typeof val.__bool__ === "function") return !!val.__bool__()'
+    v'if (Array.isArray(val)) return val.length > 0'
+    v'if (typeof val.__len__ === "function") return val.__len__() > 0'
+    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
 
 def ρσ_print(*args, **kwargs):
     if v'typeof console' is 'object':
@@ -73,7 +87,24 @@ def ρσ_chr(code):
     return String.fromCharCode(0xD800+(code>>10), 0xDC00+(code&0x3FF))
 
 def ρσ_callable(x):
-    return v'typeof x === "function"'
+    return v'typeof x === "function" || (x !== null && x !== undefined && typeof x.__call__ === "function")'
+
+def ρσ_callable_call(fn):
+    # Dispatch fn(args): check __call__ first (callable objects), then direct call.
+    # __call__ is checked first so callable objects (not functions) are dispatched correctly.
+    args = v'Array.prototype.slice.call(arguments, 1)'
+    if v'fn !== null && fn !== undefined && typeof fn.__call__ === "function"':
+        return v'fn.__call__.apply(fn, args)'
+    if v'typeof fn === "function"':
+        return v'fn.apply(undefined, args)'
+    raise TypeError('object is not callable')
+
+
+def ρσ_round(x, ndigits):
+    if ndigits is undefined or ndigits is 0:
+        return Math.round(x)
+    factor = Math.pow(10, ndigits)
+    return Math.round(x * factor) / factor
 
 def ρσ_bin(x):
     if jstype(x) is not 'number' or x % 1 is not 0:
@@ -95,15 +126,17 @@ def ρσ_hex(x):
         ans = '0x' + ans
     return ans
 
-def ρσ_enumerate(iterable):
-    ans = v'{"_i":-1}'
+def ρσ_enumerate(iterable, start):
+    offset = 0 if start is undefined else start
+    ans = {'_i': offset - 1}
     ans[ρσ_iterator_symbol] = def():
         return this
     if ρσ_arraylike(iterable):
         ans['next'] = def():
                 this._i += 1
-                if this._i < iterable.length:
-                    return v"{'done':false, 'value':[this._i, iterable[this._i]]}"
+                idx = this._i - offset
+                if idx < iterable.length:
+                    return {'done': False, 'value': [this._i, iterable[idx]]}
                 return v"{'done':true}"
         return ans
     if jstype(iterable[ρσ_iterator_symbol]) is 'function':
@@ -114,9 +147,9 @@ def ρσ_enumerate(iterable):
             if r.done:
                 return v"{'done':true}"
             this._i += 1
-            return v"{'done':false, 'value':[this._i, r.value]}"
+            return {'done': False, 'value': [this._i, r.value]}
         return ans
-    return ρσ_enumerate(Object.keys(iterable))
+    return ρσ_enumerate(Object.keys(iterable), start)
 
 def ρσ_reversed(iterable):
     if ρσ_arraylike(iterable):
@@ -244,6 +277,67 @@ def ρσ_type(x):
     return x.constructor
 
 
+def ρσ_issubclass(cls, base):
+    if Array.isArray(base):
+        for b in base:
+            if ρσ_issubclass(cls, b):
+                return True
+        return False
+    if jstype(cls) is not 'function':
+        raise TypeError('issubclass() arg 1 must be a class')
+    if jstype(base) is not 'function':
+        raise TypeError('issubclass() arg 2 must be a class')
+    if cls is base:
+        return True
+    v'var proto = cls.prototype; while (proto !== null && proto !== undefined) { if (proto === base.prototype) return true; proto = Object.getPrototypeOf(proto); }'
+    return False
+
+
+v'var ρσ_hash_id_counter = 0'
+
+def ρσ_hash(obj):
+    v'var ρσ_t = typeof obj'
+    v'if (obj === null || obj === undefined) return 0'
+    v'if (ρσ_t === "boolean") return obj ? 1 : 0'
+    v'if (ρσ_t === "number") { return (obj === Math.floor(obj)) ? (obj | 0) : ((obj * 2654435761) | 0); }'
+    v'''if (ρσ_t === "string") {
+        var ρσ_h = 5381;
+        for (var ρσ_i = 0; ρσ_i < obj.length; ρσ_i++) {
+            ρσ_h = (((ρσ_h << 5) + ρσ_h) ^ obj.charCodeAt(ρσ_i)) | 0;
+        }
+        return ρσ_h;
+    }'''
+    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\'")'
+    v'if (typeof Set === "function" && obj instanceof Set) throw new TypeError("unhashable type: \'set\'")'
+    v'if (typeof ρσ_dict === "function" && obj instanceof ρσ_dict) throw new TypeError("unhashable type: \'dict\'")'
+    v'if (typeof Map === "function" && obj instanceof Map) throw new TypeError("unhashable type: \'dict\'")'
+    v'if (!obj.constructor || obj.constructor === Object) throw new TypeError("unhashable type: \'dict\'")'
+    v'if (obj.ρσ_object_id === undefined) obj.ρσ_object_id = ++ρσ_hash_id_counter'
+    v'return obj.ρσ_object_id'
+
+
+def ρσ_next(iterator, defval):
+    if iterator is None or iterator is undefined:
+        raise TypeError('object is not an iterator')
+    if jstype(iterator.next) is 'function':
+        r = iterator.next()
+        if r.done:
+            if arguments.length > 1:
+                return defval
+            raise StopIteration()
+        return r.value
+    if jstype(iterator.__next__) is 'function':
+        try:
+            return iterator.__next__()
+        except StopIteration:
+            if arguments.length > 1:
+                return defval
+            raise
+    raise TypeError("object is not an iterator")
+
+
 def ρσ_divmod(x, y):
     if y is 0:
         raise ZeroDivisionError('integer division or modulo by zero')
@@ -272,8 +366,8 @@ def ρσ_max(*args, **kwargs):
 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 dir = ρσ_dir, ord = ρσ_ord, chr = ρσ_chr, bin = ρσ_bin, hex = ρσ_hex, callable = ρσ_callable'
+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'
+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'