wasm-action 0.0.2__py3-none-any.whl → 0.0.3__py3-none-any.whl

warg_openapi/models/package_record.py

@@ -13,81 +13,205 @@
 
 
 from __future__ import annotations
+from inspect import getfullargspec
+import json
 import pprint
 import re  # noqa: F401
-import json
 
+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
 
-from typing import Any, Dict
-from pydantic import BaseModel, Field, StrictInt, StrictStr, constr, validator
+PACKAGERECORD_ONE_OF_SCHEMAS = ["ProcessingRecord", "PublishedRecord", "RejectedRecord", "SourcingRecord"]
 
 class PackageRecord(BaseModel):
     """
-    A package log record.  # noqa: E501
+    A package log record.
     """
-    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.")
-    reason: StrictStr = Field(default=..., description="The reason the package record was rejected.")
-    registry_index: StrictInt = Field(default=..., alias="registryIndex", description="The index of the record in the registry log.")
-    __properties = ["recordId", "state", "missingContent", "reason", "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):
-        """Validates the enum"""
-        if value not in ('published',):
-            raise ValueError("must be one of enum values ('published')")
-        return value
+    # 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:
-        """Pydantic configuration"""
-        allow_population_by_field_name = True
         validate_assignment = True
 
-    def to_str(self) -> str:
-        """Returns the string representation of the model using alias"""
-        return pprint.pformat(self.dict(by_alias=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
 
-    def to_json(self) -> str:
-        """Returns the JSON representation of the model using alias"""
-        return json.dumps(self.to_dict())
+    @classmethod
+    def from_dict(cls, obj: dict) -> PackageRecord:
+        return cls.from_json(json.dumps(obj))
 
     @classmethod
     def from_json(cls, json_str: str) -> PackageRecord:
-        """Create an instance of PackageRecord from a JSON string"""
-        return cls.from_dict(json.loads(json_str))
+        """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_dict(self):
-        """Returns the dictionary representation of the model using alias"""
-        _dict = self.dict(by_alias=True,
-                          exclude={
-                          },
-                          exclude_none=True)
-        return _dict
-
-    @classmethod
-    def from_dict(cls, obj: dict) -> PackageRecord:
-        """Create an instance of PackageRecord from a dict"""
-        if obj is None:
+    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
 
-        if not isinstance(obj, dict):
-            return PackageRecord.parse_obj(obj)
-
-        _obj = PackageRecord.parse_obj({
-            "record_id": obj.get("recordId"),
-            "state": obj.get("state"),
-            "missing_content": obj.get("missingContent"),
-            "reason": obj.get("reason"),
-            "registry_index": obj.get("registryIndex")
-        })
-        return _obj
+        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())
 
 

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

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)

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")
         })

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")
         })

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/__init__.py

@@ -0,0 +1,2 @@
+
+from .lib import push, pull

wasm_action/cli.py

@@ -0,0 +1,58 @@
+import sys
+import click
+
+from . import lib
+
+@click.group()
+def cli():
+    pass
+
+
+@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")
+@click.option('--warg-private-key', required=False, envvar='WARG_PRIVATE_KEY', help="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")
+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()

wasm_action/lib.py

@@ -0,0 +1,170 @@
+import sys
+import enum
+import glob
+import os
+import hashlib
+import base64
+import json
+
+import click
+import semver
+import validators
+import requests
+
+from .registry import RegistryType, detect_registry_settings
+from .util import add_github_output, format_package, parse_package, extract_version
+from .warg.crypto import PrivateKey
+from .warg.client import WargClient
+from .warg.actions import warg_pull, warg_push
+
+
+def error(text):
+    return ValueError(text)
+
+
+def push_file(registry, package, path, warg_token, warg_private_key, cli=False):
+    """Push file to registry"""
+
+    # path
+    if not path:
+        raise error('path is required')
+
+    # glob pattern support: (ex.: package-*.wasm)
+    # expand path pattern into filename, ensure only a single file
+    files = glob.glob(path)
+    if not files:
+        raise error('file not found: {}'.format(path))
+    if len(files) > 1:
+        raise error('more than one file found: {}'.format(path))
+    filename = files[0]
+
+    # extract version from filename if not provided
+    namespace, name, version = parse_package(package)
+    if not version:
+        version = extract_version(filename)
+        package = format_package(namespace, name, version)
+
+    with open(filename, 'rb') as f:
+        content_bytes = f.read()
+
+    return push(registry, package, content_bytes, warg_token, warg_private_key, cli=cli)
+
+
+def push(registry, package, content_bytes, warg_token, warg_private_key, cli=False):
+    """Push to registry"""
+
+    # package
+    if not package:
+        raise error("package is required")
+
+    namespace, name, version = parse_package(package)
+    if not version:
+        raise error("version is required")
+
+    # validate version as semver
+    semver.Version.parse(version)
+
+    settings = validate_registry(registry, cli=cli)
+    if settings.get('registry-type') != RegistryType.WARG:
+        raise error("Registry type not supported: {}".format(settings.get('registry-type')))
+
+    # validate private key
+    if not warg_private_key:
+        raise error('no private key provided')
+
+    try:
+        private_key = PrivateKey.load(warg_private_key)
+    except:
+        raise error("Error loading private key")
+    else:
+        if cli:
+            add_github_output('key-id', private_key.public_key().fingerprint())
+            add_github_output('public-key', private_key.public_key().canonical())
+
+    if warg_token and '/' in warg_token:
+        v = warg_token.split('/', 1)[1]
+        if cli:
+            add_github_output('token-id', "sha256:{}".format(hashlib.sha256(v.encode('utf8')).hexdigest()))
+
+    # push
+    try:
+
+        record = warg_push(
+            registry, settings['warg-url'],
+            namespace, name, version, content_bytes,
+            warg_token, warg_private_key)
+
+    except Exception as e:
+        message = str(e)
+        if hasattr(e, 'body'):
+            message = str(e.body)
+            try:
+                message = json.loads(e.body)['message']
+            except:
+                pass
+        if cli:
+            add_github_output('error', message)
+        raise
+
+    if cli:
+        add_github_output('state', record['state'])
+        add_github_output('package', format_package(namespace=record['namespace'], name=record['name'], version=record['version']))
+        add_github_output('package-namespace', record['namespace'])
+        add_github_output('package-name', record['name'])
+        add_github_output('package-version', record['version'])
+        add_github_output('package-record-id', record['record_id'])
+
+    return record
+
+
+def pull(registry, package, warg_token=None, cli=False):
+    """Pull from registry"""
+
+    if not package:
+        raise error("package is required")
+
+    namespace, name, version = parse_package(package)
+
+    settings = validate_registry(registry, cli=cli)
+
+    if settings.get('registry-type') != RegistryType.WARG:
+        raise error("Registry type not supported: {}".format(settings.get('registry-type')))
+
+    download = warg_pull(registry, settings['warg-url'], namespace, name, version, warg_token=warg_token)
+
+    return download
+
+
+def pull_file(registry, package, path=None, warg_token=None, cli=False):
+    """Pull from registry, write to file"""
+
+    download = pull(registry, package, warg_token, cli=cli)
+
+    filename = path or "{}:{}@{}.wasm".format(download.namespace, download.name, download.version)
+    with open(filename, 'wb') as f:
+        f.write(download.content)
+
+    if cli:
+        add_github_output('package', format_package(
+            namespace=download.namespace, name=download.name, version=download.version))
+        add_github_output('package-namespace', download.namespace)
+        add_github_output('package-name', download.name)
+        add_github_output('package-version', download.version)
+        add_github_output('digest', download.digest)
+        add_github_output('filename', filename)
+
+
+def validate_registry(registry, cli=False):
+    if not registry:
+        raise error('registry is required')
+
+    if not validators.domain(registry, consider_tld=True):
+        raise error('registry is not a valid domain name: "{}"'.format(registry))
+
+    if cli:
+        add_github_output('registry', registry)
+    settings = detect_registry_settings(registry)
+    if cli:
+        for key, value in settings.items():
+            add_github_output(key, str(value))
+    return settings