wasm-action 0.0.7__py3-none-any.whl → 0.0.8__py3-none-any.whl

wasm_action/cli.py

@@ -1,3 +1,4 @@
+import os
 import sys
 import click
 import importlib.metadata
@@ -5,6 +6,8 @@ import json
 
 from . import lib
 from .warg.crypto import generate_key
+from .wasm import runtime
+from .util import cli_error_handler
 
 
 @click.group()
@@ -22,52 +25,41 @@ def version():
 
 
 @cli.command(help="Push to registry")
-@click.option('--registry', required=True, help="registry domain name")
-@click.option('--package', required=True, help="package spec")
+@click.option('-r', '--registry', required=True, help="registry domain name")
+@click.option('-p', '--package', required=True, help="package spec")
 @click.option('--path', required=True, help="filename")
 @click.option('--warg-token', required=False, envvar='WARG_TOKEN', help="warg token (or $WARG_TOKEN)")
 @click.option('--warg-private-key', required=False, envvar='WARG_PRIVATE_KEY', help="warg private key (or $WARG_PRIVATE_KEY)")
+@cli_error_handler
 def push(registry, package, path, warg_token, warg_private_key):
-
-    try:
-
-        lib.push_file(
-            registry=registry,
-            package=package,
-            path=path,
-            warg_token=warg_token,
-            warg_private_key=warg_private_key,
-            cli=True,
-        )
-
-    except Exception as e:
-        print(e)
-        sys.exit(1)
+    lib.push_file(
+        registry=registry,
+        package=package,
+        path=path,
+        warg_token=warg_token,
+        warg_private_key=warg_private_key,
+        cli=True,
+    )
 
 
 @cli.command(help="Pull from registry")
-@click.option('--registry', required=True, help="registry domain name")
-@click.option('--package', required=True, help="package spec")
+@click.option('-r', '--registry', required=True, help="registry domain name")
+@click.option('-p', '--package', required=True, help="package spec")
 @click.option('--path', required=False, help="filename")
 @click.option('--warg-token', required=False, envvar='WARG_TOKEN', help="warg token (or $WARG_TOKEN)")
+@cli_error_handler
 def pull(registry, package, path=None, warg_token=None):
-
-    try:
-
-        lib.pull_file(
-            registry=registry,
-            package=package,
-            path=path,
-            warg_token=warg_token,
-            cli=True,
-        )
-
-    except Exception as e:
-        print(e)
-        sys.exit(1)
+    lib.pull_file(
+        registry=registry,
+        package=package,
+        path=path,
+        warg_token=warg_token,
+        cli=True,
+    )
 
 
 @cli.command(help="Generate private key or read one from stdin")
+@cli_error_handler
 def key():
     """Generate key in json format.
 
@@ -85,5 +77,69 @@ def key():
     print(json.dumps(data, indent=4))
 
 
+@cli.command('x', help="Run a WebAssembly file")
+@click.argument('filename', required=True)
+@click.argument('func', required=False)
+@click.argument('args', nargs=-1)
+@cli_error_handler
+def run(filename, func, args):
+    """Run a WebAssembly file"""
+
+    print(runtime
+        .module_file(filename)
+        .instance()
+        .function(func)
+        .call(*args)
+    )
+
+
+@cli.command('eval', help="""Expression evaluator
+
+Expression(s) specified in EXPRESSION or STDIN will be evaluated against the specified WebAssembly module.
+The input must conform to a subset of Python's syntax that includes literals, tuples and function calls.
+The latter are resolved to a valid function present in the exports of the WebAssembly module.
+Example:
+If calc.wasm exports `add` and `mul`, then the following is a valid expression in such context:
+"mul(2, 3), add(mul(4, 5), 3)"
+""")
+@click.argument('filename', required=True)
+@click.argument('expression', required=False)
+@cli_error_handler
+def evaluate(filename, expression):
+    """Evaluates an expression against a wasm module instance.
+
+    Any function calls are intercepted and resolved to a valid function
+    from the exports of the wasm module.
+
+    Expression syntax follows a subset of Python syntax.
+
+    """
+    instance = (runtime
+        .module_file(filename)
+        .instance()
+    )
+
+    expression = sys.stdin.read() if not sys.stdin.isatty() else expression
+
+    if expression:
+        for result in instance.evaluate(expression):
+            print(result)
+        return
+
+    if not sys.stdin.isatty():
+        return
+
+    # repl mode
+    import readline
+    prompt = "{} >>> ".format(os.path.basename(filename))
+    while True:
+        expression = input(prompt)
+        try:
+            for result in instance.evaluate(expression):
+                print(result)
+        except Exception as e:
+            print(e)
+
+
 if __name__ == "__main__":
     cli()

wasm_action/util.py

@@ -2,6 +2,8 @@
 import os
 import re
 import sys
+import datetime
+import functools
 import requests
 import semver
 
@@ -73,6 +75,52 @@ def parse_package(package):
     if not re.match(r"[\w-]+", name):
         raise ValueError("invalid package name")
     if version:
+        # evaluate any calver specifiers
+        version = CalVer(version).version()
         # throws on failed validation
         semver.Version.parse(version)
     return namespace, name, version
+
+
+class CalVer:
+    """Calendar Versioning according to https://calver.org (zero-padded formats excluded)"""
+
+    SPEC = {
+        'YYYY': lambda d: str(d.year),
+        'YY': lambda d: str(d.year % 100),
+        'MM': lambda d: str(d.month),
+        'WW': lambda d: str(d.isocalendar().week),
+        'DD': lambda d: str(d.day),
+    }
+
+    def __init__(self, pattern):
+        self.pattern = pattern
+
+    def now(self) -> datetime.datetime:
+        if not hasattr(datetime, 'UTC'):
+            # 3.10
+            return datetime.datetime.utcnow()
+        return datetime.datetime.now(datetime.UTC)
+
+    def version(self, at: datetime.datetime=None):
+        when = at or self.now()
+        return ".".join([
+            self.SPEC[part.upper()](when)
+            if part.upper() in self.SPEC else part
+            for part in self.pattern.split('.')
+        ])
+
+
+class cli_error_handler(object):
+    """Decorator for CLI error handling"""
+
+    def __init__(self, func):
+        self.func = func
+        functools.update_wrapper(self, func)
+
+    def __call__(self, *args, **kwargs):
+        try:
+            return self.func(*args, **kwargs)
+        except Exception as e:
+            # print error and return 1
+            sys.exit(e)

wasm_action/wasm/expression.py

@@ -0,0 +1,96 @@
+"""
+Expression evaluator.
+
+Expressions are evaluated against a WebAssembly module instance.
+Expressions allow to combine zero or more function invocations into one go.
+An expression may consist of the following constituents:
+ * Literals
+    Simple types that can be represented in WA types.
+    1, 0x23, true, false, 3.14
+ * Function invocations
+    Refer to functions that must be present in the exports section (what about allowing to call imports?).
+    sum(2, 3)
+ * Tuples for structure and multiple instructions.
+    Tuples - allow multiple invocations in one.
+
+
+Example:
+Suppose the file calculator.wasm provides the following exports:
+ - sum, mul
+Then the following expressions can be constructed:
+sum(2, 3)
+sum(2, mul(3, 5))
+sum(1, sum(2, sum(3, sum(4, 5))))
+(1, sum(2, 3))  -> (1, 5)
+
+Implementation takes a shortcut by using Python's ast module.
+"""
+
+import ast
+
+ALLOWED_SYNTAX = {
+    ast.Module,
+    ast.Expr,
+    ast.Constant,
+    ast.Tuple,
+    ast.Call,
+    ast.Name,
+}
+
+
+def parse(value: str) -> ast.AST:
+    """Parse an expression into an ast syntax tree."""
+    node = ast.parse(value)
+    for x in ast.walk(node):
+        if isinstance(x, ast.Load):
+            # ignored
+            continue
+        if x.__class__ not in ALLOWED_SYNTAX:
+            raise SyntaxError("{} not allowed in expression".format(x.__class__.__name__))
+    return node
+
+
+def evaluate(expression, obj):
+    node = parse(expression)
+    return Evaluator(obj).evaluate(node)
+
+
+class Evaluator:
+
+    def __init__(self, obj):
+        self.obj= obj
+
+    def evaluate(self, node: ast.AST) -> object:
+        if isinstance(node, ast.Module):
+            for sub in node.body:
+                yield from self.evaluate(sub)
+
+        elif isinstance(node, ast.Expr):
+            yield self.compute(node)
+
+        else:
+            raise Exception("value not allowed: {}".format(node))
+
+    def compute(self, node):
+        """Evaluate a single expression"""
+        if isinstance(node, ast.Expr):
+            return self.compute(node.value)
+
+        elif isinstance(node, ast.Tuple):
+            return tuple(self.compute(x) for x in node.elts)
+
+        elif isinstance(node, ast.Constant):
+            return node.value
+
+        elif isinstance(node, ast.Call):
+            assert isinstance(node.func, ast.Name)
+            name = node.func.id
+            func = getattr(self.obj, name)
+            args = [self.compute(x) for x in node.args]
+            return func(*args)
+
+        elif isinstance(node, ast.Name):
+            return getattr(self.obj, node.id)
+
+        else:
+            raise Exception("value not allowed: {}".format(node))

wasm_action/wasm/runtime.py

@@ -0,0 +1,96 @@
+
+import os
+import wasmtime
+
+from . import expression
+
+
+def module_file(filename):
+    if not os.path.exists(filename) or not os.path.isfile(filename):
+        raise Exception('file not found: {}'.format(filename))
+
+    with open(filename, 'rb') as f:
+        module_bytes = f.read()
+    return module(module_bytes)
+
+
+def module(module_bytes):
+    return Module(module_bytes)
+
+
+class Module:
+
+    def __init__(self, module_bytes):
+        self._store = wasmtime.Store()
+        self._module = wasmtime.Module(self._store.engine, module_bytes)
+
+    def instance(self):
+        return Instance(store=self._store, module=self._module)
+
+
+class Instance:
+
+    def __init__(self, store, module):
+        self._store = store
+        self._module = module
+        self._instance = None
+        self._imports = []
+
+    def __getattr__(self, name):
+        """Ususally called by the evaluator to resolve function names."""
+        return self.function(name)
+
+    def function(self, name):
+        if not self._instance:
+            self._instance = wasmtime.Instance(self._store, self._module, self._imports)
+        exports = self._instance.exports(self._store)
+        if name not in exports.keys():
+            print('defined functions:', list(exports.keys()))
+            assert False, "function not found: {}".format(name)
+        return Function(store=self._store, func=exports[name], name=name)
+
+    def evaluate(self, text):
+        """Evaluate an expression against functions exported in the instance."""
+        return expression.evaluate(text or '', obj=self)
+
+
+class Function:
+
+    _types = {
+        "i32": int,
+        "i64": int,
+        "f32": float,
+        "f64": float,
+    }
+
+    def __init__(self, store, func, name):
+        self._store = store
+        self._func = func
+        self._func_type = self._func.type(self._store)
+        self.name = name
+
+    def call(self, *args):
+        return self(*args)
+
+    def __call__(self, *args):
+        # convert to expected types before function call
+        typed_args = []
+        for param, arg in zip(self._func_type.params, args):
+            type = self._types.get(str(param))
+            arg = type(arg) if type else arg
+            typed_args.append(arg)
+        try:
+            result = self._func(self._store, *typed_args)
+        except Exception as e:
+            message = "Error calling {}({}): {}".format(
+                self.name,
+                ", ".join([str(x) for x in typed_args]),
+                str(e),
+            )
+            raise Exception(message)
+        return result
+
+    def __str__(self):
+        return "{}({})".format(self.name, ", ".join([
+            str(p) for p in self._func_type.params
+        ]))

{wasm_action-0.0.7.dist-info → wasm_action-0.0.8.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: wasm-action
-Version: 0.0.7
+Version: 0.0.8
 Summary: Interact with WebAssembly registries.
 Requires-Dist: click>=8.2.1
 Requires-Dist: cryptography>=45.0.6
@@ -12,6 +12,7 @@ Requires-Dist: requests>=2.32.4
 Requires-Dist: semver>=3.0.4
 Requires-Dist: urllib3>=1.25.3
 Requires-Dist: validators>=0.35.0
+Requires-Dist: wasmtime>=40.0.0
 Requires-Python: >=3.10
 Project-URL: Repository, https://github.com/xelato/wasm-action
 Description-Content-Type: text/markdown
@@ -84,7 +85,7 @@ To pull a private package, define your [token](https://wa.dev/account/credential
 ### Key generation
 New [token](https://wa.dev/account/credentials/new) registration and push to wa.dev require generation and configuration of a private/public key pair which can be facilitated with:
 ```
-$ uv run wasm-action key
+$ uvx wasm-action key
 {
     "private": "ecdsa-p256:9y5nigLvFp3KZZQtuvN9DchpGIMUB4bwGAtkIoOCla4=",
     "public": "ecdsa-p256:AvspSQWBK65ItTou/uVCi5qC4P+HBCi4R34OIPb3ILRl",

{wasm_action-0.0.7.dist-info → wasm_action-0.0.8.dist-info}/RECORD

@@ -58,16 +58,19 @@ warg_openapi/models/timestamped_checkpoint.py,sha256=HvpqFUAzxb4AlhFOd1FHi8gKYAv
 warg_openapi/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 warg_openapi/rest.py,sha256=esTaIvd-RN8XURlnK_ALzgEyd5n1853hJRoAdCe7C3k,14044
 wasm_action/__init__.py,sha256=77Mz6_mfveQMO90YlCumicDwhzSa0Xvi3xpJ_10EYZ8,190
-wasm_action/cli.py,sha256=Hwn7hIxfBom_h4RaNc3_o73KZMX5ZbLl52sfgoXeL2E,2345
+wasm_action/cli.py,sha256=skrL0WgJhKzsNUUckwh95nl0bSWTFAOQLMDFjm0_zao,4163
 wasm_action/lib.py,sha256=xX66hhbxyxI5GP_k4DfDdViWj0FonqFXBwq8ssAuZo4,5366
 wasm_action/registry.py,sha256=JfsYJbzysbcgMAG9wf-8bPU-fmSm7wan_aReRXGGaMM,1497
-wasm_action/util.py,sha256=TqIMicfNDqtjhTuLLBujpw77Z2ktY9uXmddsztg-Y8E,2247
+wasm_action/util.py,sha256=yxklrEViwjMn4k3f6_ckkqWD1il9R0hJj6qBsP7CrF4,3600
 wasm_action/warg/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 wasm_action/warg/actions.py,sha256=RfP3REOJp0bxuJ3FkkXFjrO1zfWrW5v7T_HOb8-g6mE,4658
 wasm_action/warg/client.py,sha256=FKKHcTwqAJotN3ZL2bIHJ0ET05YxRQw9ks8IyxDQ6Mo,6389
 wasm_action/warg/crypto.py,sha256=eK2Vw1mLFg2wmL6_3jmLHKzo2JK3KpnOz4PRUFZowZY,4906
 wasm_action/warg/proto.py,sha256=ui6rPfC_5IQQheOAwCxOL--r_tmvN-hc50NlLC5bgn4,6226
-wasm_action-0.0.7.dist-info/WHEEL,sha256=XV0cjMrO7zXhVAIyyc8aFf1VjZ33Fen4IiJk5zFlC3g,80
-wasm_action-0.0.7.dist-info/entry_points.txt,sha256=lTdloFNHGTiEbfd1efp0ZQ7p9SpAbzIWYqxk__EAPFE,53
-wasm_action-0.0.7.dist-info/METADATA,sha256=4v6xz5MeK7IvMje08VegVoofZqQ-jkkSm3oDxqzLfXk,4892
-wasm_action-0.0.7.dist-info/RECORD,,
+wasm_action/wasm/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+wasm_action/wasm/expression.py,sha256=0DWJbHKe50oIFkL11VTdkyCiIruQH7pXpG2SsI_Jr3g,2630
+wasm_action/wasm/runtime.py,sha256=vwJjHwGs6Nt8qpNEEHrzeY2gmG8RbZ3VHSXrkzSQOrk,2699
+wasm_action-0.0.8.dist-info/WHEEL,sha256=e_m4S054HL0hyR3CpOk-b7Q7fDX6BuFkgL5OjAExXas,80
+wasm_action-0.0.8.dist-info/entry_points.txt,sha256=lTdloFNHGTiEbfd1efp0ZQ7p9SpAbzIWYqxk__EAPFE,53
+wasm_action-0.0.8.dist-info/METADATA,sha256=_gSivhQlZQp5swDU6MfB80g-zgt7BBMV1zL8BAWfUXI,4921
+wasm_action-0.0.8.dist-info/RECORD,,

{wasm_action-0.0.7.dist-info → wasm_action-0.0.8.dist-info}/WHEEL

@@ -1,4 +1,4 @@
 Wheel-Version: 1.0
-Generator: uv 0.9.26
+Generator: uv 0.9.27
 Root-Is-Purelib: true
 Tag: py3-none-any