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

wasm_action/cli.py

@@ -1,8 +1,14 @@
+import os
 import sys
 import click
 import importlib.metadata
+import json
 
 from . import lib
+from .warg.crypto import generate_key
+from .wasm import runtime
+from .util import cli_error_handler
+
 
 @click.group()
 def cli():
@@ -19,49 +25,120 @@ 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.
+
+    Either:
+     - generate a new key
+     - read a private key from standard input
+    """
+    if sys.stdin.isatty():
+        data = generate_key()
+    else:
+        # read private key from standard input
+        private_key = sys.stdin.read()
+        data = generate_key(private_key)
+        del data['private']
+    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__":

wasm_action/lib.py

@@ -5,7 +5,6 @@ import os
 import hashlib
 import base64
 import json
-
 import click
 import semver
 import validators

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/warg/actions.py

@@ -60,11 +60,14 @@ def warg_push(registry, warg_url, namespace, name, version, content_bytes, warg_
 
         # state: sourcing -> upload sources
         elif state == 'sourcing':
+            time.sleep(1)
             if 'missingContent' in res:
                 for _, data in res['missingContent'].items():
                     if 'upload' in data:
                         for upload in data['upload']:
-                            requests.put(upload['url'], data=content_bytes)
+                            r = requests.put(upload['url'], data=content_bytes)
+                            if r.status_code not in (200, 201):
+                                print(r.status_code, r.content)
 
         # state: rejected -> error
         elif state == 'rejected':

wasm_action/warg/crypto.py

@@ -38,9 +38,14 @@ class PrivateKey:
         """
         Decode a key in `<algo>:<base64>` format.
         """
-        if ':' not in text:
+        text = (text or '').strip()
+        if not text or ':' not in text:
             raise ValueError('required format: <algo>:<base64>')
 
+        # better interplay with jq, pbcopy, and pbpaste
+        if len(text)>1 and text.startswith('"') and text.endswith('"'):
+            text = text[1:-1]
+
         algo, key_b64 = text.split(':', 1)
 
         curve = cls.CURVES.get(algo)
@@ -48,7 +53,9 @@ class PrivateKey:
             raise ValueError('algorithm not supported: {}'.format(algo))
 
         key_bytes = base64.b64decode(key_b64)
-        # todo: compare bytes length with curve key length
+        # compare bytes length with curve key size
+        if len(key_bytes) * 8 != curve.key_size:
+            raise ValueError('key size mismatch')
 
         key_int = int.from_bytes(key_bytes, byteorder='big')
         key = ec.derive_private_key(key_int, curve=curve)
@@ -134,3 +141,17 @@ class PublicKey:
     def fingerprint(self):
         """Used as Key ID"""
         return "sha256:{}".format(hashlib.sha256(self.canonical().encode('ascii')).hexdigest())
+
+
+def generate_key(private_key:str=None):
+    """Generate key-pair."""
+    if private_key:
+        private = PrivateKey.load(private_key)
+    else:
+        private = PrivateKey.generate()
+    public = private.public_key()
+    return {
+        "private": private.canonical(),
+        "public": public.canonical(),
+        "id": public.fingerprint(),
+    }

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.6.dist-info → wasm_action-0.0.8.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: wasm-action
-Version: 0.0.6
+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
@@ -27,6 +28,10 @@ Description-Content-Type: text/markdown
 * Supported actions: push, pull
 * Supports Python 3.10+ on Linux, MacOS and Windows
 
+#### Planned
+* OCI registry support (a.k.a. Docker registry)
+* Convert between formats (wit/wasm)
+
 ## Usage
 ### Pull from registry
 ```
@@ -37,7 +42,7 @@ Description-Content-Type: text/markdown
           package: component-book:adder
 ```
 
-To pull a private package define your [token](https://wa.dev/account/credentials/new):
+To pull a private package, define your [token](https://wa.dev/account/credentials/new):
 ```
         env:
           WARG_TOKEN: ${{ secrets.WARG_TOKEN }}
@@ -77,8 +82,27 @@ To pull a private package define your [token](https://wa.dev/account/credentials
           WARG_PRIVATE_KEY: ${{ secrets.WARG_PRIVATE_KEY }}
 ```
 
+### 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:
+```
+$ uvx wasm-action key
+{
+    "private": "ecdsa-p256:9y5nigLvFp3KZZQtuvN9DchpGIMUB4bwGAtkIoOCla4=",
+    "public": "ecdsa-p256:AvspSQWBK65ItTou/uVCi5qC4P+HBCi4R34OIPb3ILRl",
+    "id": "sha256:c836bd8a3082f2e8d70bdfa48296e580ab847fcdeadb351f448d03f152d44093"
+}
+```
+```
+# use private key to configure in github or save it elsewhere in a secure manner
+$ uvx wasm-action key | jq .private | pbcopy
+```
+```
+# use corresponding public key for new token registration at wa.dev
+$ pbpaste | uvx wasm-action key | jq .public
+```
+
 ## CLI
-The tool can be run without installing using [uv](https://docs.astral.sh/uv/).
+The tool can be run without installing, using [uv](https://docs.astral.sh/uv/).
 ```
 $ uvx wasm-action --help
 Usage: wasm-action [OPTIONS] COMMAND [ARGS]...
@@ -87,8 +111,10 @@ Options:
   --help  Show this message and exit.
 
 Commands:
-  pull  Pull from a WebAssembly registry
-  push  Push to a WebAssembly registry
+  key      Generate private key or read one from stdin
+  pull     Pull from registry
+  push     Push to registry
+  version  Print version
 ```
 ```
 $ uvx wasm-action pull --help

{wasm_action-0.0.6.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=in720PEYgVbPwGqab8VJJUUcDIA8JzWpzMmQ93A3xVU,1827
-wasm_action/lib.py,sha256=AEomnfa4HObgGxgv29vJ7bsV6scw6cSg6yHPgkUy79I,5367
+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=5Hnqc6ImS3W4K5osagOfXJDjLEj_g9TSceX4r7CwoDU,4500
+wasm_action/warg/actions.py,sha256=RfP3REOJp0bxuJ3FkkXFjrO1zfWrW5v7T_HOb8-g6mE,4658
 wasm_action/warg/client.py,sha256=FKKHcTwqAJotN3ZL2bIHJ0ET05YxRQw9ks8IyxDQ6Mo,6389
-wasm_action/warg/crypto.py,sha256=BKBM9BmOni1sXY2eVXky9kx371JhiMd-RitaDa188uY,4253
+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.6.dist-info/WHEEL,sha256=XjEbIc5-wIORjWaafhI6vBtlxDBp7S9KiujWF1EM7Ak,79
-wasm_action-0.0.6.dist-info/entry_points.txt,sha256=lTdloFNHGTiEbfd1efp0ZQ7p9SpAbzIWYqxk__EAPFE,53
-wasm_action-0.0.6.dist-info/METADATA,sha256=FuDPVFACskSA0_XmFdJ9dVFnNTb9HCdsndd-UpzG7-o,4009
-wasm_action-0.0.6.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.6.dist-info → wasm_action-0.0.8.dist-info}/WHEEL

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