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