def fetch_uri_contents(self, uri: URI) -> bytes: if not self.can_resolve_uri(uri): raise CannotHandleURI( f"GithubOverHTTPSBackend cannot resolve {uri}.") response = requests.get(uri) response.raise_for_status() contents = json.loads(response.content) if contents["encoding"] != "base64": raise CannotHandleURI( "Expected contents returned from Github to be base64 encoded, " f"instead received {contents['encoding']}.") decoded_contents = base64.b64decode(contents["content"]) validate_blob_uri_contents(decoded_contents, uri) return decoded_contents
def parse_registry_uri(uri: str) -> RegistryURI: """ Validate and return (authority, chain_id, pkg_name, version) from a valid registry URI. """ from web3.auto.infura import w3 validate_registry_uri(uri) parsed_uri = parse.urlparse(uri) if ":" in parsed_uri.netloc: address_or_ens, chain_id = parsed_uri.netloc.split(":") else: address_or_ens, chain_id = parsed_uri.netloc, "1" ns = ENS.fromWeb3(w3) if is_address(address_or_ens): address = address_or_ens ens = None elif ns.address(address_or_ens): address = ns.address(address_or_ens) ens = address_or_ens else: raise CannotHandleURI( f"Invalid address or ENS domain found in uri: {uri}.") pkg_name, pkg_version, namespaced_asset = _process_pkg_path( parsed_uri.path) return RegistryURI(address, chain_id, pkg_name, pkg_version, namespaced_asset, ens)
def create_content_addressed_github_uri(uri: URI) -> URI: """ Returns a content-addressed Github "git_url" that conforms to this scheme. https://api.github.com/repos/:owner/:repo/git/blobs/:file_sha Accepts Github-defined "url" that conforms to this scheme https://api.github.com/repos/:owner/:repo/contents/:path/:to/manifest.json """ if not is_valid_api_github_uri(uri): raise CannotHandleURI(f"{uri} does not conform to Github's API 'url' scheme.") response = requests.get(uri) response.raise_for_status() contents = json.loads(response.content) if contents["type"] != "file": raise CannotHandleURI( f"Expected url to point to a 'file' type, instead received {contents['type']}." ) return contents["git_url"]
def get_ipfs_backend_class(import_path: str = None) -> Type[BaseIPFSBackend]: if import_path is None: import_path = os.environ.get("ETHPM_IPFS_BACKEND_CLASS", DEFAULT_IPFS_BACKEND) if not import_path: raise CannotHandleURI( "Please provide an import class or set " "`ETHPM_IPFS_BACKEND_CLASS` environment variable.") return import_string(import_path)
def resolve_uri_contents(uri: URI, fingerprint: bool = None) -> bytes: resolvable_backends = get_resolvable_backends_for_uri(uri) if resolvable_backends: for backend in resolvable_backends: try: contents = backend().fetch_uri_contents(uri) except CannotHandleURI: continue return contents translatable_backends = get_translatable_backends_for_uri(uri) if translatable_backends: if fingerprint: raise CannotHandleURI( "Registry URIs must point to a resolvable content-addressed URI." ) package_id = RegistryURIBackend().fetch_uri_contents(uri) return resolve_uri_contents(package_id, True) # type: ignore raise CannotHandleURI( f"URI: {uri} cannot be resolved by any of the available backends.")
def fetch_uri_contents(self, uri: str) -> URI: """ Return content-addressed URI stored at registry URI. """ address, chain_id, pkg_name, pkg_version = parse_registry_uri(uri) if chain_id != '1': # todo: support all testnets raise CannotHandleURI( "Currently only mainnet registry uris are supported.") self.w3.enable_unstable_package_management_api() self.w3.pm.set_registry(address) _, _, manifest_uri = self.w3.pm.get_release_data(pkg_name, pkg_version) return manifest_uri
def parse_registry_uri(uri: str) -> RegistryURI: """ Validate and return (authority, pkg name, version) from a valid registry URI """ from web3.auto.infura import w3 validate_registry_uri(uri) parsed_uri = parse.urlparse(uri) address_or_ens, chain_id = parsed_uri.netloc.split(":") ns = ENS.fromWeb3(w3) if is_address(address_or_ens): address = address_or_ens ens = None elif ns.address(address_or_ens): address = ns.address(address_or_ens) ens = address_or_ens else: raise CannotHandleURI( f"Invalid address or ENS domain found in uri: {uri}.") parsed_name = parsed_uri.path.strip("/") parsed_version = parsed_uri.query.lstrip("version=").strip("/") pkg_name = parsed_name if parsed_name else None pkg_version = parsed_version if parsed_version else None return RegistryURI(address, chain_id, pkg_name, pkg_version, ens)
def pin_assets(self, file_or_dir_path: Path) -> List[Dict[str, str]]: raise CannotHandleURI( "IPFS gateway is currently disabled, please use a different IPFS backend." )
def fetch_uri_contents(self, uri: str) -> bytes: raise CannotHandleURI( "IPFS gateway is currently disabled, please use a different IPFS backend." )