rapydscript-ns 0.8.1 → 0.8.3

package/TODO.md

@@ -1,327 +1,15 @@
 
 ### 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?
+- 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
-
-
-
-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
-
-RapydScript-NS covers the vast majority of Python 2/3 core syntax well. The gaps fall into four categories: modern Python syntax, OOP/protocol features, standard library modules, and semantic  
-differences.
-
-  ---
-1. Modern Python Syntax (Not Supported)
-
-┌───────────────────────────────────────────────┬────────────────┬──────────────────────────────────────────────────────────────┐
-│                    Feature                    │ Python Version │                            Notes                             │
-├───────────────────────────────────────────────┼────────────────┼──────────────────────────────────────────────────────────────┤
-│ match/case (structural pattern matching)      │ 3.10+          │ -tested                                                      │
-├───────────────────────────────────────────────┼────────────────┼──────────────────────────────────────────────────────────────┤
-│ Walrus operator :=                            │ 3.8+           │ -tested                                                      │
-├───────────────────────────────────────────────┼────────────────┼──────────────────────────────────────────────────────────────┤
-│ lambda keyword                                │ all            │ -tested                                                      │
-├───────────────────────────────────────────────┼────────────────┼──────────────────────────────────────────────────────────────┤
-│ Variable type annotations x: int = 1          │ 3.6+           │ needs testing                                                │
-├───────────────────────────────────────────────┼────────────────┼──────────────────────────────────────────────────────────────┤
-│ Positional-only parameters (def f(a, /, b):)  │ 3.8+           │ -tested                                                      │
-├───────────────────────────────────────────────┼────────────────┼──────────────────────────────────────────────────────────────┤
-│ Keyword-only parameters (def f(a, *, b):)     │ 3.0+           │ -tested                                                      │
-├───────────────────────────────────────────────┼────────────────┼──────────────────────────────────────────────────────────────┤
-│ Starred assignment a, *b, c = [1,2,3,4,5]     │ 3.0+           │ -tested                                                      │
-├───────────────────────────────────────────────┼────────────────┼──────────────────────────────────────────────────────────────┤
-│ Dict merge literal {**d1, **d2}               │ 3.5+           │ -tested                                                      │
-├───────────────────────────────────────────────┼────────────────┼──────────────────────────────────────────────────────────────┤
-│ 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                                             │
-├───────────────────────────────────────────────┼────────────────┼──────────────────────────────────────────────────────────────┤
-│ except* (exception groups)                    │ 3.11+          │ No support                                                   │
-├───────────────────────────────────────────────┼────────────────┼──────────────────────────────────────────────────────────────┤
-│ Nested comprehensions (for a in b for c in d) │ all            │ -tested                                                      │
-├───────────────────────────────────────────────┼────────────────┼──────────────────────────────────────────────────────────────┤
-│ Complex number literals 3+4j                  │ all            │ No j suffix                                                  │
-├───────────────────────────────────────────────┼────────────────┼──────────────────────────────────────────────────────────────┤
-│ Ellipsis literal ... as expression            │ all            │ Only valid as slice (a[...])                                 │
-├───────────────────────────────────────────────┼────────────────┼──────────────────────────────────────────────────────────────┤
-│ b'...' bytes literals                         │ all            │ No b prefix; encoding module exists but no native bytes type │
-└───────────────────────────────────────────────┴────────────────┴──────────────────────────────────────────────────────────────┘
-
-  ---
-2. OOP and Dunder Protocol Gaps
-
-Not Supported at All
-
-┌─────────────────────────────────────────┬─────────────────────────────────────────────────────────────────┐
-│                 Feature                 │                              Notes                              │
-├─────────────────────────────────────────┼─────────────────────────────────────────────────────────────────┤
-│ super()                                 │ -tested                                                         │
-├─────────────────────────────────────────┼─────────────────────────────────────────────────────────────────┤
-│ __new__                                 │ No alternative constructor support                              │
-├─────────────────────────────────────────┼─────────────────────────────────────────────────────────────────┤
-│ __del__                                 │ No destructor/finalizer                                         │
-├─────────────────────────────────────────┼─────────────────────────────────────────────────────────────────┤
-│ __hash__                                │ Explicitly noted as not implemented; set/dict uses === identity │
-├─────────────────────────────────────────┼─────────────────────────────────────────────────────────────────┤
-│ __bool__                                │ Empty [] and {} are truthy in JS (differs from Python)          │
-├─────────────────────────────────────────┼─────────────────────────────────────────────────────────────────┤
-│ __call__                                │ Objects cannot be made callable via dunder                      │
-├─────────────────────────────────────────┼─────────────────────────────────────────────────────────────────┤
-│ __getattr__ / __setattr__ / __delattr__ │ No attribute access interception                                │
-├─────────────────────────────────────────┼─────────────────────────────────────────────────────────────────┤
-│ __getattribute__                        │ No attribute lookup overriding                                  │
-├─────────────────────────────────────────┼─────────────────────────────────────────────────────────────────┤
-│ __format__                              │ No custom format() behavior                                     │
-├─────────────────────────────────────────┼─────────────────────────────────────────────────────────────────┤
-│ __slots__                               │ No slot declarations                                            │
-├─────────────────────────────────────────┼─────────────────────────────────────────────────────────────────┤
-│ __class_getitem__                       │ No MyClass[T] generic syntax support                            │
-├─────────────────────────────────────────┼─────────────────────────────────────────────────────────────────┤
-│ __init_subclass__                       │ No subclass hooks                                               │
-├─────────────────────────────────────────┼─────────────────────────────────────────────────────────────────┤
-│ classmethod decorator                   │ Not tested/documented (may partially work via @staticmethod)    │
-└─────────────────────────────────────────┴─────────────────────────────────────────────────────────────────┘
-
-Arithmetic/Comparison Operator Overloading
-
-All of these dunder methods are not dispatched — operators always use JS native semantics:
-
-__add__, __radd__, __sub__, __mul__, __truediv__, __floordiv__, __mod__, __pow__, __lt__, __le__, __gt__, __ge__, __ne__, __neg__, __pos__, __abs__, __invert__, __lshift__, __rshift__, __and__,
-__or__, __xor__
-
-(Only __eq__, __contains__, __iter__, __len__, __enter__, __exit__, __repr__, __str__ are dispatched)
-
-Nested Classes
-
-Noted in test file (test/classes.pyj) as "not yet fully implemented."
-
-Abstract Base Classes (ABCs)
-
-No abc module, no @abstractmethod, no Protocol support.
-
-  ---
-3. Built-in Functions Missing
-
-┌──────────────────────────┬────────────────────────────────────────────────┐
-│         Function         │                     Notes                      │
-├──────────────────────────┼────────────────────────────────────────────────┤
-│ super()                  │ tested                                         │
-├──────────────────────────┼────────────────────────────────────────────────┤
-│ issubclass()             │ Not implemented                                │
-├──────────────────────────┼────────────────────────────────────────────────┤
-│ hash()                   │ Not implemented                                │
-├──────────────────────────┼────────────────────────────────────────────────┤
-│ format(value, spec)      │ Not listed; str.format() works                 │
-├──────────────────────────┼────────────────────────────────────────────────┤
-│ vars()                   │ Not listed                                     │
-├──────────────────────────┼────────────────────────────────────────────────┤
-│ locals()                 │ Not listed                                     │
-├──────────────────────────┼────────────────────────────────────────────────┤
-│ globals()                │ Not listed                                     │
-├──────────────────────────┼────────────────────────────────────────────────┤
-│ exec()                   │ Not listed (JS eval works directly via v'...') │
-├──────────────────────────┼────────────────────────────────────────────────┤
-│ eval()                   │ Not listed                                     │
-├──────────────────────────┼────────────────────────────────────────────────┤
-│ compile()                │ N/A                                            │
-├──────────────────────────┼────────────────────────────────────────────────┤
-│ __import__()             │ Not supported                                  │
-├──────────────────────────┼────────────────────────────────────────────────┤
-│ input()                  │ Not built in                                   │
-├──────────────────────────┼────────────────────────────────────────────────┤
-│ open()                   │ Not built in                                   │
-├──────────────────────────┼────────────────────────────────────────────────┤
-│ bytes() / bytearray()    │ Not built in                                   │
-├──────────────────────────┼────────────────────────────────────────────────┤
-│ memoryview()             │ N/A (browser context)                          │
-├──────────────────────────┼────────────────────────────────────────────────┤
-│ zip(..., strict=True)    │ strict kwarg not supported                     │
-├──────────────────────────┼────────────────────────────────────────────────┤
-│ enumerate(x, start=N)    │ start parameter may not be supported           │
-├──────────────────────────┼────────────────────────────────────────────────┤
-│ all() / any()            │ tested                                         │
-├──────────────────────────┼────────────────────────────────────────────────┤
-│ next(iter, default?)     │ Not listed                                     │
-├──────────────────────────┼────────────────────────────────────────────────┤
-│ iter(callable, sentinel) │ Two-arg form likely not supported              │
-├──────────────────────────┼────────────────────────────────────────────────┤
-│ round(x, ndigits?)       │ Not listed                                     │
-├──────────────────────────┼────────────────────────────────────────────────┤
-│ slice()                  │ Not listed as builtin object                   │
-├──────────────────────────┼────────────────────────────────────────────────┤
-│ frozenset()              │ Not listed                                     │
-├──────────────────────────┼────────────────────────────────────────────────┤
-│ complex()                │ Not listed                                     │
-├──────────────────────────┼────────────────────────────────────────────────┤
-│ object()                 │ Not listed                                     │
-└──────────────────────────┴────────────────────────────────────────────────┘
-
-  ---
-4. Standard Library Modules Missing
-
-These are Python stdlib modules with no equivalent in src/lib/:
-
-┌─────────────┬─────────────────────────────────────────────────────────────────────────────────┐
-│   Module    │                                 What's Missing                                  │
-├─────────────┼─────────────────────────────────────────────────────────────────────────────────┤
-│ collections │ tested                                                                          │
-├─────────────┼─────────────────────────────────────────────────────────────────────────────────┤
-│ functools   │ tested                                                                          │
-├─────────────┼─────────────────────────────────────────────────────────────────────────────────┤
-│ itertools   │ tested                                                                          │
-├─────────────┼─────────────────────────────────────────────────────────────────────────────────┤
-│ typing      │ List, Dict, Optional, Union, Tuple, Generic, TypeVar, etc.                      │
-├─────────────┼─────────────────────────────────────────────────────────────────────────────────┤
-│ dataclasses │ @dataclass, field(), asdict(), astuple()                                        │
-├─────────────┼─────────────────────────────────────────────────────────────────────────────────┤
-│ contextlib  │ contextmanager, suppress, ExitStack, asynccontextmanager                        │
-├─────────────┼─────────────────────────────────────────────────────────────────────────────────┤
-│ copy        │ copy(), deepcopy()                                                              │
-├─────────────┼─────────────────────────────────────────────────────────────────────────────────┤
-│ string      │ Character constants, Template, Formatter                                        │
-├─────────────┼─────────────────────────────────────────────────────────────────────────────────┤
-│ json        │ dumps, loads (JS JSON works directly, but no Python wrapper)                    │
-├─────────────┼─────────────────────────────────────────────────────────────────────────────────┤
-│ datetime    │ date, time, datetime, timedelta                                                 │
-├─────────────┼─────────────────────────────────────────────────────────────────────────────────┤
-│ inspect     │ signature, getmembers, isfunction, etc.                                         │
-├─────────────┼─────────────────────────────────────────────────────────────────────────────────┤
-│ asyncio     │ Event loop, gather, sleep, Queue, Task wrappers                                 │
-├─────────────┼─────────────────────────────────────────────────────────────────────────────────┤
-│ enum        │ Enum, IntEnum, Flag                                                             │
-├─────────────┼─────────────────────────────────────────────────────────────────────────────────┤
-│ abc         │ ABC, abstractmethod                                                             │
-├─────────────┼─────────────────────────────────────────────────────────────────────────────────┤
-│ io          │ StringIO, BytesIO                                                               │
-├─────────────┼─────────────────────────────────────────────────────────────────────────────────┤
-│ struct      │ Binary packing/unpacking                                                        │
-├─────────────┼─────────────────────────────────────────────────────────────────────────────────┤
-│ hashlib     │ MD5, SHA-256, etc.                                                              │
-├─────────────┼─────────────────────────────────────────────────────────────────────────────────┤
-│ hmac        │ Keyed hashing                                                                   │
-├─────────────┼─────────────────────────────────────────────────────────────────────────────────┤
-│ base64      │ (partial — encodings module exists)                                             │
-├─────────────┼─────────────────────────────────────────────────────────────────────────────────┤
-│ urllib      │ URL parsing/encoding (no urllib.parse)                                          │
-├─────────────┼─────────────────────────────────────────────────────────────────────────────────┤
-│ html        │ escape, unescape                                                                │
-├─────────────┼─────────────────────────────────────────────────────────────────────────────────┤
-│ csv         │ CSV parsing                                                                     │
-├─────────────┼─────────────────────────────────────────────────────────────────────────────────┤
-│ textwrap    │ wrap, fill, dedent, indent                                                      │
-├─────────────┼─────────────────────────────────────────────────────────────────────────────────┤
-│ pprint      │ Pretty-printing                                                                 │
-├─────────────┼─────────────────────────────────────────────────────────────────────────────────┤
-│ logging     │ Logging framework                                                               │
-├─────────────┼─────────────────────────────────────────────────────────────────────────────────┤
-│ unittest    │ Test framework (custom runner used instead)                                     │
-└─────────────┴─────────────────────────────────────────────────────────────────────────────────┘
-
-  ---
-5. Semantic Differences (Traps)
-
-These features exist but behave differently from Python:
-
-┌─────────────────────────┬────────────────────────────────────────────┬─────────────────────────────────────────────────────────────────────────────────┐
-│         Feature         │              Python Behavior               │                              RapydScript Behavior                               │
-├─────────────────────────┼────────────────────────────────────────────┼─────────────────────────────────────────────────────────────────────────────────┤
-│ Truthiness of []        │ False                                      │ True (JS semantics)                                                             │
-├─────────────────────────┼────────────────────────────────────────────┼─────────────────────────────────────────────────────────────────────────────────┤
-│ Truthiness of {}        │ False                                      │ True (JS semantics)                                                             │
-├─────────────────────────┼────────────────────────────────────────────┼─────────────────────────────────────────────────────────────────────────────────┤
-│ is / is not             │ Object identity                            │ Strict equality === / !==                                                       │
-├─────────────────────────┼────────────────────────────────────────────┼─────────────────────────────────────────────────────────────────────────────────┤
-│ // on floats            │ math.floor(a/b)                            │ Correct for integers; JS Math.floor used                                        │
-├─────────────────────────┼────────────────────────────────────────────┼─────────────────────────────────────────────────────────────────────────────────┤
-│ % on negative numbers   │ Python modulo (always positive)            │ JS remainder (can be negative)                                                  │
-├─────────────────────────┼────────────────────────────────────────────┼─────────────────────────────────────────────────────────────────────────────────┤
-│ int / float distinction │ Separate types                             │ Both are JS number                                                              │
-├─────────────────────────┼────────────────────────────────────────────┼─────────────────────────────────────────────────────────────────────────────────┤
-│ String * repetition     │ 'a' * 3 == 'aaa'                           │ Requires pythonize module or JS-side workaround                                 │
-├─────────────────────────┼────────────────────────────────────────────┼─────────────────────────────────────────────────────────────────────────────────┤
-│ sort() / pop()          │ Standard list methods                      │ Renamed to pysort() / pypop()                                                   │
-├─────────────────────────┼────────────────────────────────────────────┼─────────────────────────────────────────────────────────────────────────────────┤
-│ Method binding          │ Unbound by default, self passed explicitly │ Same — but differs if you store methods in variables without bound_methods flag │
-├─────────────────────────┼────────────────────────────────────────────┼─────────────────────────────────────────────────────────────────────────────────┤
-│ dict key ordering       │ Insertion order (3.7+)                     │ Depends on JS engine (V8: insertion order)                                      │
-├─────────────────────────┼────────────────────────────────────────────┼─────────────────────────────────────────────────────────────────────────────────┤
-│ global scoping          │ Full cross-scope declaration               │ Partial — interactions with nonlocal can be confusing                           │
-├─────────────────────────┼────────────────────────────────────────────┼─────────────────────────────────────────────────────────────────────────────────┤
-│ Exception .message      │ Not standard (Python uses .args[0])        │ .message is standard (JS style)                                                 │
-├─────────────────────────┼────────────────────────────────────────────┼─────────────────────────────────────────────────────────────────────────────────┤
-│ re module               │ Full PCRE features                         │ No lookbehind, limited unicode, no (?(1)...)                                    │
-└─────────────────────────┴────────────────────────────────────────────┴─────────────────────────────────────────────────────────────────────────────────┘
-
-  ---
-Priority Gaps (Most Impactful)
-
-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
-4. lambda keyword — commonly expected - done
-5. all() / any() — extremely common builtins - done
-6. functools.reduce / partial — core functional programming tools - done
-7. collections.defaultdict / Counter — frequently used - done
-8. Nested comprehensions — common Python pattern - done
-9. Walrus operator := — increasingly common in modern Python - done
-10. classmethod decorator — standard OOP pattern - done
-
+- examples of using js libraries in rapydscript in readme
 
 
-       
+I would like you to add support for [ [List Concatenation (+) Without overload_operators]() ] 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 if it has any outdated info about this, and the PYTHON_FEATURE_COVERAGE report.

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)