wasm-action 0.0.2__tar.gz → 0.0.4__tar.gz

{wasm_action-0.0.2 → wasm_action-0.0.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: wasm-action
-Version: 0.0.2
+Version: 0.0.4
 Summary: Interact with WebAssembly registries.
 Requires-Dist: click>=8.2.1
 Requires-Dist: cryptography>=45.0.6
@@ -13,6 +13,7 @@ Requires-Dist: semver>=3.0.4
 Requires-Dist: urllib3>=1.25.3
 Requires-Dist: validators>=0.35.0
 Requires-Python: >=3.10
+Project-URL: Repository, https://github.com/xelato/wasm-action
 Description-Content-Type: text/markdown
 
 # wasm-action
@@ -20,10 +21,10 @@ Description-Content-Type: text/markdown
 **Interact with WebAssembly registries.**
 
 ## Features
-* Versatile use as a GitHub [action](https://github.com/marketplace/actions/wasm-action), CLI or Python [library](https://pypi.org/project/wasm-action/).
+* Versatile use as GitHub [action](https://github.com/marketplace/actions/wasm-action), CLI or Python [library](https://pypi.org/project/wasm-action/).
 * Supported registry types: warg (wa.dev)
 * Supported artifact types: wasm
-* Supported actions: pull (public and private packages)
+* Supported actions: push, pull
 * Supports Python 3.10+ on Linux, MacOS and Windows
 
 ## Usage
@@ -63,6 +64,19 @@ To pull a private package define your [token](https://wa.dev/account/credentials
 |filename|Download location|foo-bar_1.2.3.wasm|
 |digest|File hash|sha256:2afffac0...|
 
+### Push to registry
+```
+      - uses: xelato/wasm-action
+        with:
+          action: push
+          registry: wa.dev
+          package: foo:bar@1.2.3
+          path: files/foo_bar_1.2.3.wasm
+        env:
+          WARG_TOKEN: ${{ secrets.WARG_TOKEN }}
+          WARG_PRIVATE_KEY: ${{ secrets.WARG_PRIVATE_KEY }}
+```
+
 ## CLI
 The tool can be run without installing using [uv](https://docs.astral.sh/uv/).
 ```
@@ -112,6 +126,8 @@ The package is [published](http://pypi.org/project/wasm-action/) to the Python P
 $ pip install wasm-action
 ```
 ```
-> import wasm_action as wa
+>>> import wasm_action as wa
+>>> wa.pull('wa.dev', 'wasi:io')
+PackageDownload(namespace='wasi', name='io', version='0.2.0', content='...', digest='sha256:c33b1dbf050f64229ff4decbf9a3d3420e0643a86f5f0cea29f81054820020a6')
 ```
 However, the library interface is not yet standardised and may (and will!) change.

{wasm_action-0.0.2 → wasm_action-0.0.4}/README.md

@@ -3,10 +3,10 @@
 **Interact with WebAssembly registries.**
 
 ## Features
-* Versatile use as a GitHub [action](https://github.com/marketplace/actions/wasm-action), CLI or Python [library](https://pypi.org/project/wasm-action/).
+* Versatile use as GitHub [action](https://github.com/marketplace/actions/wasm-action), CLI or Python [library](https://pypi.org/project/wasm-action/).
 * Supported registry types: warg (wa.dev)
 * Supported artifact types: wasm
-* Supported actions: pull (public and private packages)
+* Supported actions: push, pull
 * Supports Python 3.10+ on Linux, MacOS and Windows
 
 ## Usage
@@ -46,6 +46,19 @@ To pull a private package define your [token](https://wa.dev/account/credentials
 |filename|Download location|foo-bar_1.2.3.wasm|
 |digest|File hash|sha256:2afffac0...|
 
+### Push to registry
+```
+      - uses: xelato/wasm-action
+        with:
+          action: push
+          registry: wa.dev
+          package: foo:bar@1.2.3
+          path: files/foo_bar_1.2.3.wasm
+        env:
+          WARG_TOKEN: ${{ secrets.WARG_TOKEN }}
+          WARG_PRIVATE_KEY: ${{ secrets.WARG_PRIVATE_KEY }}
+```
+
 ## CLI
 The tool can be run without installing using [uv](https://docs.astral.sh/uv/).
 ```
@@ -95,6 +108,8 @@ The package is [published](http://pypi.org/project/wasm-action/) to the Python P
 $ pip install wasm-action
 ```
 ```
-> import wasm_action as wa
+>>> import wasm_action as wa
+>>> wa.pull('wa.dev', 'wasi:io')
+PackageDownload(namespace='wasi', name='io', version='0.2.0', content='...', digest='sha256:c33b1dbf050f64229ff4decbf9a3d3420e0643a86f5f0cea29f81054820020a6')
 ```
 However, the library interface is not yet standardised and may (and will!) change.

{wasm_action-0.0.2 → wasm_action-0.0.4}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "wasm-action"
-version = "0.0.2"
+version = "0.0.4"
 description = "Interact with WebAssembly registries."
 readme = "README.md"
 requires-python = ">=3.10"
@@ -17,8 +17,11 @@ dependencies = [
     "validators>=0.35.0",
 ]
 
+[project.urls]
+Repository = "https://github.com/xelato/wasm-action"
+
 [project.scripts]
-wasm-action = "wasm_action.action:main"
+wasm-action = "wasm_action.cli:cli"
 
 [build-system]
 requires = ["uv_build>=0.9.3,<0.10.0"]
@@ -26,3 +29,9 @@ build-backend = "uv_build"
 
 [tool.uv.build-backend]
 module-name = ["wasm_action", "warg_openapi"]
+
+[dependency-groups]
+dev = [
+    "pytest>=9.0.2",
+    "vcrpy>=8.1.0",
+]

wasm_action-0.0.4/src/warg_openapi/models/package_record.py

@@ -0,0 +1,217 @@
+# coding: utf-8
+
+"""
+    Warg Registry API
+
+    [warg](https://warg.io/) is an open source protocol for WebAssembly component registries. 
+
+    The version of the OpenAPI document: 1.0.0
+    Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+    Do not edit the class manually.
+"""  # noqa: E501
+
+
+from __future__ import annotations
+from inspect import getfullargspec
+import json
+import pprint
+import re  # noqa: F401
+
+from typing import Any, List, Optional
+from pydantic import BaseModel, Field, StrictStr, ValidationError, validator
+from warg_openapi.models.processing_record import ProcessingRecord
+from warg_openapi.models.published_record import PublishedRecord
+from warg_openapi.models.rejected_record import RejectedRecord
+from warg_openapi.models.sourcing_record import SourcingRecord
+from typing import Union, Any, List, TYPE_CHECKING
+from pydantic import StrictStr, Field
+
+PACKAGERECORD_ONE_OF_SCHEMAS = ["ProcessingRecord", "PublishedRecord", "RejectedRecord", "SourcingRecord"]
+
+class PackageRecord(BaseModel):
+    """
+    A package log record.
+    """
+    # data type: SourcingRecord
+    oneof_schema_1_validator: Optional[SourcingRecord] = None
+    # data type: ProcessingRecord
+    oneof_schema_2_validator: Optional[ProcessingRecord] = None
+    # data type: RejectedRecord
+    oneof_schema_3_validator: Optional[RejectedRecord] = None
+    # data type: PublishedRecord
+    oneof_schema_4_validator: Optional[PublishedRecord] = None
+    if TYPE_CHECKING:
+        actual_instance: Union[ProcessingRecord, PublishedRecord, RejectedRecord, SourcingRecord]
+    else:
+        actual_instance: Any
+    one_of_schemas: List[str] = Field(PACKAGERECORD_ONE_OF_SCHEMAS, const=True)
+
+    class Config:
+        validate_assignment = True
+
+    discriminator_value_class_map = {
+    }
+
+    def __init__(self, *args, **kwargs) -> None:
+        if args:
+            if len(args) > 1:
+                raise ValueError("If a position argument is used, only 1 is allowed to set `actual_instance`")
+            if kwargs:
+                raise ValueError("If a position argument is used, keyword arguments cannot be used.")
+            super().__init__(actual_instance=args[0])
+        else:
+            super().__init__(**kwargs)
+
+    @validator('actual_instance')
+    def actual_instance_must_validate_oneof(cls, v):
+        instance = PackageRecord.construct()
+        error_messages = []
+        match = 0
+        # validate data type: SourcingRecord
+        if not isinstance(v, SourcingRecord):
+            error_messages.append(f"Error! Input type `{type(v)}` is not `SourcingRecord`")
+        else:
+            match += 1
+        # validate data type: ProcessingRecord
+        if not isinstance(v, ProcessingRecord):
+            error_messages.append(f"Error! Input type `{type(v)}` is not `ProcessingRecord`")
+        else:
+            match += 1
+        # validate data type: RejectedRecord
+        if not isinstance(v, RejectedRecord):
+            error_messages.append(f"Error! Input type `{type(v)}` is not `RejectedRecord`")
+        else:
+            match += 1
+        # validate data type: PublishedRecord
+        if not isinstance(v, PublishedRecord):
+            error_messages.append(f"Error! Input type `{type(v)}` is not `PublishedRecord`")
+        else:
+            match += 1
+        if match > 1:
+            # more than 1 match
+            raise ValueError("Multiple matches found when setting `actual_instance` in PackageRecord with oneOf schemas: ProcessingRecord, PublishedRecord, RejectedRecord, SourcingRecord. Details: " + ", ".join(error_messages))
+        elif match == 0:
+            # no match
+            raise ValueError("No match found when setting `actual_instance` in PackageRecord with oneOf schemas: ProcessingRecord, PublishedRecord, RejectedRecord, SourcingRecord. Details: " + ", ".join(error_messages))
+        else:
+            return v
+
+    @classmethod
+    def from_dict(cls, obj: dict) -> PackageRecord:
+        return cls.from_json(json.dumps(obj))
+
+    @classmethod
+    def from_json(cls, json_str: str) -> PackageRecord:
+        """Returns the object represented by the json string"""
+        instance = PackageRecord.construct()
+        error_messages = []
+        match = 0
+
+        # use oneOf discriminator to lookup the data type
+        _data_type = json.loads(json_str).get("state")
+        if not _data_type:
+            raise ValueError("Failed to lookup data type from the field `state` in the input.")
+
+        # check if data type is `ProcessingRecord`
+        if _data_type == "processing":
+            instance.actual_instance = ProcessingRecord.from_json(json_str)
+            return instance
+
+        # check if data type is `PublishedRecord`
+        if _data_type == "published":
+            instance.actual_instance = PublishedRecord.from_json(json_str)
+            return instance
+
+        # check if data type is `RejectedRecord`
+        if _data_type == "rejected":
+            instance.actual_instance = RejectedRecord.from_json(json_str)
+            return instance
+
+        # check if data type is `SourcingRecord`
+        if _data_type == "sourcing":
+            instance.actual_instance = SourcingRecord.from_json(json_str)
+            return instance
+
+        # check if data type is `ProcessingRecord`
+        if _data_type == "ProcessingRecord":
+            instance.actual_instance = ProcessingRecord.from_json(json_str)
+            return instance
+
+        # check if data type is `PublishedRecord`
+        if _data_type == "PublishedRecord":
+            instance.actual_instance = PublishedRecord.from_json(json_str)
+            return instance
+
+        # check if data type is `RejectedRecord`
+        if _data_type == "RejectedRecord":
+            instance.actual_instance = RejectedRecord.from_json(json_str)
+            return instance
+
+        # check if data type is `SourcingRecord`
+        if _data_type == "SourcingRecord":
+            instance.actual_instance = SourcingRecord.from_json(json_str)
+            return instance
+
+        # deserialize data into SourcingRecord
+        try:
+            instance.actual_instance = SourcingRecord.from_json(json_str)
+            match += 1
+        except (ValidationError, ValueError) as e:
+            error_messages.append(str(e))
+        # deserialize data into ProcessingRecord
+        try:
+            instance.actual_instance = ProcessingRecord.from_json(json_str)
+            match += 1
+        except (ValidationError, ValueError) as e:
+            error_messages.append(str(e))
+        # deserialize data into RejectedRecord
+        try:
+            instance.actual_instance = RejectedRecord.from_json(json_str)
+            match += 1
+        except (ValidationError, ValueError) as e:
+            error_messages.append(str(e))
+        # deserialize data into PublishedRecord
+        try:
+            instance.actual_instance = PublishedRecord.from_json(json_str)
+            match += 1
+        except (ValidationError, ValueError) as e:
+            error_messages.append(str(e))
+
+        if match > 1:
+            # more than 1 match
+            raise ValueError("Multiple matches found when deserializing the JSON string into PackageRecord with oneOf schemas: ProcessingRecord, PublishedRecord, RejectedRecord, SourcingRecord. Details: " + ", ".join(error_messages))
+        elif match == 0:
+            # no match
+            raise ValueError("No match found when deserializing the JSON string into PackageRecord with oneOf schemas: ProcessingRecord, PublishedRecord, RejectedRecord, SourcingRecord. Details: " + ", ".join(error_messages))
+        else:
+            return instance
+
+    def to_json(self) -> str:
+        """Returns the JSON representation of the actual instance"""
+        if self.actual_instance is None:
+            return "null"
+
+        to_json = getattr(self.actual_instance, "to_json", None)
+        if callable(to_json):
+            return self.actual_instance.to_json()
+        else:
+            return json.dumps(self.actual_instance)
+
+    def to_dict(self) -> dict:
+        """Returns the dict representation of the actual instance"""
+        if self.actual_instance is None:
+            return None
+
+        to_dict = getattr(self.actual_instance, "to_dict", None)
+        if callable(to_dict):
+            return self.actual_instance.to_dict()
+        else:
+            # primitive type
+            return self.actual_instance
+
+    def to_str(self) -> str:
+        """Returns the string representation of the actual instance"""
+        return pprint.pformat(self.dict())
+
+

{wasm_action-0.0.2 → wasm_action-0.0.4}/src/warg_openapi/models/processing_record.py

@@ -19,14 +19,22 @@ import json
 
 
 
-from pydantic import BaseModel, Field, StrictStr, validator
+from pydantic import BaseModel, Field, StrictStr, constr, validator
 
 class ProcessingRecord(BaseModel):
     """
     A record that is being processed.  # noqa: E501
     """
+    record_id: constr(strict=True) = Field(default=..., alias="recordId", description="Represents a supported hash.")
     state: StrictStr = Field(default=..., description="The state of the package record.")
-    __properties = ["state"]
+    __properties = ["recordId", "state"]
+
+    @validator('record_id')
+    def record_id_validate_regular_expression(cls, value):
+        """Validates the regular expression"""
+        if not re.match(r"^[a-z0-9-]+:[a-f0-9]+$", value):
+            raise ValueError(r"must validate the regular expression /^[a-z0-9-]+:[a-f0-9]+$/")
+        return value
 
     @validator('state')
     def state_validate_enum(cls, value):
@@ -71,6 +79,7 @@ class ProcessingRecord(BaseModel):
             return ProcessingRecord.parse_obj(obj)
 
         _obj = ProcessingRecord.parse_obj({
+            "record_id": obj.get("recordId"),
             "state": obj.get("state")
         })
         return _obj

{wasm_action-0.0.2 → wasm_action-0.0.4}/src/warg_openapi/models/prove_inclusion422_response.py

@@ -100,6 +100,41 @@ class ProveInclusion422Response(BaseModel):
         error_messages = []
         match = 0
 
+        # use oneOf discriminator to lookup the data type
+        _data_type = json.loads(json_str).get("reason")
+        if not _data_type:
+            raise ValueError("Failed to lookup data type from the field `reason` in the input.")
+
+        # check if data type is `BundleFailureError`
+        if _data_type == "failure":
+            instance.actual_instance = BundleFailureError.from_json(json_str)
+            return instance
+
+        # check if data type is `IncorrectProofError`
+        if _data_type == "incorrectProof":
+            instance.actual_instance = IncorrectProofError.from_json(json_str)
+            return instance
+
+        # check if data type is `PackageNotIncludedError`
+        if _data_type == "packageNotIncluded":
+            instance.actual_instance = PackageNotIncludedError.from_json(json_str)
+            return instance
+
+        # check if data type is `BundleFailureError`
+        if _data_type == "BundleFailureError":
+            instance.actual_instance = BundleFailureError.from_json(json_str)
+            return instance
+
+        # check if data type is `IncorrectProofError`
+        if _data_type == "IncorrectProofError":
+            instance.actual_instance = IncorrectProofError.from_json(json_str)
+            return instance
+
+        # check if data type is `PackageNotIncludedError`
+        if _data_type == "PackageNotIncludedError":
+            instance.actual_instance = PackageNotIncludedError.from_json(json_str)
+            return instance
+
         # deserialize data into PackageNotIncludedError
         try:
             instance.actual_instance = PackageNotIncludedError.from_json(json_str)

{wasm_action-0.0.2 → wasm_action-0.0.4}/src/warg_openapi/models/published_record.py

@@ -19,15 +19,23 @@ import json
 
 
 
-from pydantic import BaseModel, Field, StrictInt, StrictStr, validator
+from pydantic import BaseModel, Field, StrictInt, StrictStr, constr, validator
 
 class PublishedRecord(BaseModel):
     """
     A record that has been published to the log.  # noqa: E501
     """
+    record_id: constr(strict=True) = Field(default=..., alias="recordId", description="Represents a supported hash.")
     state: StrictStr = Field(default=..., description="The state of the package record.")
     registry_index: StrictInt = Field(default=..., alias="registryIndex", description="The index of the record in the registry log.")
-    __properties = ["state", "registryIndex"]
+    __properties = ["recordId", "state", "registryIndex"]
+
+    @validator('record_id')
+    def record_id_validate_regular_expression(cls, value):
+        """Validates the regular expression"""
+        if not re.match(r"^[a-z0-9-]+:[a-f0-9]+$", value):
+            raise ValueError(r"must validate the regular expression /^[a-z0-9-]+:[a-f0-9]+$/")
+        return value
 
     @validator('state')
     def state_validate_enum(cls, value):
@@ -72,6 +80,7 @@ class PublishedRecord(BaseModel):
             return PublishedRecord.parse_obj(obj)
 
         _obj = PublishedRecord.parse_obj({
+            "record_id": obj.get("recordId"),
             "state": obj.get("state"),
             "registry_index": obj.get("registryIndex")
         })

{wasm_action-0.0.2 → wasm_action-0.0.4}/src/warg_openapi/models/rejected_record.py

@@ -19,15 +19,23 @@ import json
 
 
 
-from pydantic import BaseModel, Field, StrictStr, validator
+from pydantic import BaseModel, Field, StrictStr, constr, validator
 
 class RejectedRecord(BaseModel):
     """
     A rejected package record.  # noqa: E501
     """
+    record_id: constr(strict=True) = Field(default=..., alias="recordId", description="Represents a supported hash.")
     state: StrictStr = Field(default=..., description="The state of the package record.")
     reason: StrictStr = Field(default=..., description="The reason the package record was rejected.")
-    __properties = ["state", "reason"]
+    __properties = ["recordId", "state", "reason"]
+
+    @validator('record_id')
+    def record_id_validate_regular_expression(cls, value):
+        """Validates the regular expression"""
+        if not re.match(r"^[a-z0-9-]+:[a-f0-9]+$", value):
+            raise ValueError(r"must validate the regular expression /^[a-z0-9-]+:[a-f0-9]+$/")
+        return value
 
     @validator('state')
     def state_validate_enum(cls, value):
@@ -72,6 +80,7 @@ class RejectedRecord(BaseModel):
             return RejectedRecord.parse_obj(obj)
 
         _obj = RejectedRecord.parse_obj({
+            "record_id": obj.get("recordId"),
             "state": obj.get("state"),
             "reason": obj.get("reason")
         })

{wasm_action-0.0.2 → wasm_action-0.0.4}/src/warg_openapi/models/sourcing_record.py

@@ -19,15 +19,23 @@ import json
 
 
 from typing import Any, Dict
-from pydantic import BaseModel, Field, StrictStr, validator
+from pydantic import BaseModel, Field, StrictStr, constr, validator
 
 class SourcingRecord(BaseModel):
     """
     The package record is sourcing content.  # noqa: E501
     """
+    record_id: constr(strict=True) = Field(default=..., alias="recordId", description="Represents a supported hash.")
     state: StrictStr = Field(default=..., description="The state of the package record.")
     missing_content: Dict[str, Any] = Field(default=..., alias="missingContent", description="The map of content digest to missing content info.")
-    __properties = ["state", "missingContent"]
+    __properties = ["recordId", "state", "missingContent"]
+
+    @validator('record_id')
+    def record_id_validate_regular_expression(cls, value):
+        """Validates the regular expression"""
+        if not re.match(r"^[a-z0-9-]+:[a-f0-9]+$", value):
+            raise ValueError(r"must validate the regular expression /^[a-z0-9-]+:[a-f0-9]+$/")
+        return value
 
     @validator('state')
     def state_validate_enum(cls, value):
@@ -72,6 +80,7 @@ class SourcingRecord(BaseModel):
             return SourcingRecord.parse_obj(obj)
 
         _obj = SourcingRecord.parse_obj({
+            "record_id": obj.get("recordId"),
             "state": obj.get("state"),
             "missing_content": obj.get("missingContent")
         })

wasm_action-0.0.4/src/wasm_action/__init__.py

@@ -0,0 +1,9 @@
+
+import importlib.metadata
+
+try:
+	__version__ = importlib.metadata.version("wasm-action")
+except importlib.metadata.PackageNotFoundError:
+	__version__ = "0.0.0"
+
+from .lib import push, pull

wasm_action-0.0.4/src/wasm_action/cli.py

@@ -0,0 +1,68 @@
+import sys
+import click
+import importlib.metadata
+
+from . import lib
+
+@click.group()
+def cli():
+    pass
+
+
+@cli.command(help="Print version")
+def version():
+    try:
+        version = importlib.metadata.version("wasm-action")
+    except importlib.metadata.PackageNotFoundError:
+        version = "0.0.0"
+    print(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('--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)")
+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)
+
+
+@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('--path', required=False, help="filename")
+@click.option('--warg-token', required=False, envvar='WARG_TOKEN', help="warg token (or $WARG_TOKEN)")
+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)
+
+
+if __name__ == "__main__":
+    cli()