web3 7.0.0b1__py3-none-any.whl → 7.7.0__py3-none-any.whl

ethpm/backends/ipfs.py

@@ -1,219 +0,0 @@
-from abc import (
-    abstractmethod,
-)
-import os
-from pathlib import (
-    Path,
-)
-from typing import (
-    Dict,
-    List,
-    Type,
-)
-
-from eth_utils import (
-    import_string,
-    to_bytes,
-)
-
-from ethpm import (
-    get_ethpm_spec_dir,
-)
-from ethpm._utils.ipfs import (
-    dummy_ipfs_pin,
-    extract_ipfs_path_from_uri,
-    generate_file_hash,
-    is_ipfs_uri,
-)
-from ethpm.backends.base import (
-    BaseURIBackend,
-)
-from ethpm.constants import (
-    DEFAULT_IPFS_BACKEND,
-    INFURA_GATEWAY_MULTIADDR,
-    IPFS_GATEWAY_PREFIX,
-)
-from ethpm.exceptions import (
-    CannotHandleURI,
-    EthPMValidationError,
-)
-
-try:
-    # `ipfshttpclient` backend is optional. This is only imported if the "web3[ipfs]"
-    # install extra is installed
-    import ipfshttpclient
-except ImportError:
-    pass
-
-
-class BaseIPFSBackend(BaseURIBackend):
-    """
-    Base class for all URIs with an IPFS scheme.
-    """
-
-    def can_resolve_uri(self, uri: str) -> bool:
-        """
-        Return a bool indicating whether or not this backend
-        is capable of serving the content located at the URI.
-        """
-        return is_ipfs_uri(uri)
-
-    def can_translate_uri(self, uri: str) -> bool:
-        """
-        Return False. IPFS URIs cannot be used to point
-        to another content-addressed URI.
-        """
-        return False
-
-    @abstractmethod
-    def pin_assets(self, file_or_dir_path: Path) -> List[Dict[str, str]]:
-        """
-        Pin assets found at `file_or_dir_path` and return a
-        list containing pinned asset data.
-        """
-        pass
-
-
-class IPFSOverHTTPBackend(BaseIPFSBackend):
-    """
-    Base class for all IPFS URIs served over an http connection.
-    All subclasses must implement: base_uri
-    """
-
-    def __init__(self) -> None:
-        self.client = ipfshttpclient.connect(self.base_uri)
-
-    def fetch_uri_contents(self, uri: str) -> bytes:
-        ipfs_hash = extract_ipfs_path_from_uri(uri)
-        contents = self.client.cat(ipfs_hash)
-        # Local validation of hashed contents only works for non-chunked files ~< 256kb
-        # Improved validation WIP @ https://github.com/ethpm/py-ethpm/pull/165
-        if len(contents) <= 262144:
-            validation_hash = generate_file_hash(contents)
-            if validation_hash != ipfs_hash:
-                raise EthPMValidationError(
-                    f"Hashed IPFS contents retrieved from uri: {uri} "
-                    "do not match its content hash."
-                )
-        return contents
-
-    @property
-    @abstractmethod
-    def base_uri(self) -> str:
-        pass
-
-    def pin_assets(self, file_or_dir_path: Path) -> List[Dict[str, str]]:
-        if file_or_dir_path.is_dir():
-            dir_data = self.client.add(str(file_or_dir_path), recursive=True)
-            return dir_data
-        elif file_or_dir_path.is_file():
-            file_data = self.client.add(str(file_or_dir_path), recursive=False)
-            return [file_data]
-        else:
-            raise TypeError(
-                f"{file_or_dir_path} is not a valid file or directory path."
-            )
-
-
-class IPFSGatewayBackend(IPFSOverHTTPBackend):
-    """
-    Backend class for all IPFS URIs served over the IPFS gateway.
-    """
-
-    # todo update this gateway to work r&w
-    # https://discuss.ipfs.io/t/writeable-http-gateways/210
-    @property
-    def base_uri(self) -> str:
-        return IPFS_GATEWAY_PREFIX
-
-    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."
-        )
-
-
-class InfuraIPFSBackend(IPFSOverHTTPBackend):
-    """
-    Backend class for all IPFS URIs served over the Infura IFPS gateway.
-    """
-
-    @property
-    def base_uri(self) -> str:
-        return INFURA_GATEWAY_MULTIADDR
-
-
-class LocalIPFSBackend(IPFSOverHTTPBackend):
-    """
-    Backend class for all IPFS URIs served through a direct connection to an IPFS node.
-    Default IPFS port = 5001
-    """
-
-    @property
-    def base_uri(self) -> str:
-        return "/ip4/127.0.0.1/tcp/5001"
-
-
-MANIFEST_URIS = {
-    "ipfs://QmQNffBrmbB3TuBCtYfYsJWJVLssatWXa3H6CkGeyNUySA": "standard-token",
-    "ipfs://QmWnPsiS3Xb8GvCDEBFnnKs8Yk4HaAX6rCqJAaQXGbCoPk": "safe-math-lib",
-    "ipfs://QmcxvhkJJVpbxEAa6cgW3B6XwPJb79w9GpNUv2P2THUzZR": "owned",
-}
-
-
-class DummyIPFSBackend(BaseIPFSBackend):
-    """
-    Backend class to serve IPFS URIs without having to make an HTTP request.
-    Used primarily for testing purposes, returns a locally stored manifest or contract.
-    ---
-    `ipfs_uri` can either be:
-    - Valid IPFS URI -> safe-math-lib manifest (ALWAYS)
-    - Path to manifest/contract in ethpm_spec_dir -> defined manifest/contract
-    """
-
-    def fetch_uri_contents(self, ipfs_uri: str) -> bytes:
-        pkg_name = MANIFEST_URIS[ipfs_uri]
-        ethpm_spec_dir = get_ethpm_spec_dir()
-        pkg_contents = (ethpm_spec_dir / "examples" / pkg_name / "v3.json").read_text()
-        return to_bytes(text=pkg_contents)
-
-    def can_resolve_uri(self, uri: str) -> bool:
-        return uri in MANIFEST_URIS
-
-    def pin_assets(self, file_or_dir_path: Path) -> List[Dict[str, str]]:
-        """
-        Return a dict containing the IPFS hash, file name, and size of a file.
-        """
-        if file_or_dir_path.is_dir():
-            asset_data = [dummy_ipfs_pin(path) for path in file_or_dir_path.glob("*")]
-        elif file_or_dir_path.is_file():
-            asset_data = [dummy_ipfs_pin(file_or_dir_path)]
-        else:
-            raise FileNotFoundError(
-                f"{file_or_dir_path} is not a valid file or directory path."
-            )
-        return asset_data
-
-
-def get_ipfs_backend(import_path: str = None) -> BaseIPFSBackend:
-    """
-    Return the `BaseIPFSBackend` class specified by import_path,
-    default, or env variable.
-    """
-    backend_class = get_ipfs_backend_class(import_path)
-    return backend_class()
-
-
-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)

ethpm/backends/registry.py

@@ -1,154 +0,0 @@
-from collections import (
-    namedtuple,
-)
-from typing import (
-    Optional,
-    Tuple,
-)
-from urllib import (
-    parse,
-)
-
-from eth_typing import (
-    URI,
-)
-from eth_utils import (
-    is_address,
-)
-
-from ens import (
-    ENS,
-)
-from ethpm._utils.registry import (
-    fetch_standard_registry_abi,
-)
-from ethpm.backends.base import (
-    BaseURIBackend,
-)
-from ethpm.exceptions import (
-    CannotHandleURI,
-    EthPMValidationError,
-)
-from ethpm.validation.uri import (
-    validate_registry_uri,
-)
-
-# TODO: Update registry ABI once ERC is finalized.
-REGISTRY_ABI = fetch_standard_registry_abi()
-RegistryURI = namedtuple(
-    "RegistryURI", ["address", "chain_id", "name", "version", "namespaced_asset", "ens"]
-)
-
-
-class RegistryURIBackend(BaseURIBackend):
-    """
-    Backend class to handle Registry URIs.
-
-    A Registry URI must resolve to a resolvable content-addressed URI.
-    """
-
-    def __init__(self) -> None:
-        from web3 import (
-            LegacyWebSocketProvider,
-            Web3,
-        )
-
-        w3 = Web3(LegacyWebSocketProvider())
-
-        self.w3 = w3
-
-    def can_translate_uri(self, uri: str) -> bool:
-        return is_valid_registry_uri(uri)
-
-    def can_resolve_uri(self, uri: str) -> bool:
-        return False
-
-    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 URI(manifest_uri)
-
-
-def is_valid_registry_uri(uri: str) -> bool:
-    """
-    Return a boolean indicating whether `uri` argument
-    conforms to the Registry URI scheme.
-    """
-    try:
-        validate_registry_uri(uri)
-    except EthPMValidationError:
-        return False
-    else:
-        return True
-
-
-def parse_registry_uri(uri: str) -> RegistryURI:
-    """
-    Validate and return (authority, chain_id, pkg_name, version)
-    from a valid registry URI.
-    """
-    from web3 import (
-        LegacyWebSocketProvider,
-        Web3,
-    )
-
-    w3 = Web3(LegacyWebSocketProvider())
-
-    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.from_web3(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 _process_pkg_path(
-    raw_pkg_path: str,
-) -> Tuple[Optional[str], Optional[str], Optional[str]]:
-    pkg_path = raw_pkg_path.strip("/")
-    if not pkg_path:
-        return None, None, None
-
-    pkg_id, namespaced_asset = _parse_pkg_path(pkg_path)
-    pkg_name, pkg_version = _parse_pkg_id(pkg_id)
-    if not pkg_version and namespaced_asset:
-        raise EthPMValidationError(
-            "Invalid registry URI, missing package version."
-            "Version is required if namespaced assets are defined."
-        )
-    return pkg_name, pkg_version, namespaced_asset
-
-
-def _parse_pkg_path(pkg_path: str) -> Tuple[str, Optional[str]]:
-    if "/" in pkg_path:
-        pkg_id, _, namespaced_asset = pkg_path.partition("/")
-        return pkg_id, namespaced_asset
-    else:
-        return pkg_path, None
-
-
-def _parse_pkg_id(pkg_id: str) -> Tuple[str, Optional[str]]:
-    if "@" not in pkg_id:
-        return pkg_id, None
-    pkg_name, _, safe_pkg_version = pkg_id.partition("@")
-    pkg_version = parse.unquote(safe_pkg_version)
-    return pkg_name, pkg_version

ethpm/constants.py

@@ -1,17 +0,0 @@
-REGISTRY_URI_SCHEMES = ("erc1319", "ethpm")
-
-PACKAGE_NAME_REGEX = "^[a-zA-Z][-_a-zA-Z0-9]{0,255}$"
-
-DEFAULT_IPFS_BACKEND = "ethpm.backends.ipfs.InfuraIPFSBackend"
-
-IPFS_GATEWAY_PREFIX = "https://ipfs.io/ipfs/"
-
-INFURA_GATEWAY_MULTIADDR = "/dns4/ipfs.infura.io/tcp/5001/https/"
-
-GITHUB_API_AUTHORITY = "api.github.com"
-
-SUPPORTED_CHAIN_IDS = {
-    1: "mainnet",
-    5: "goerli",
-    11155111: "sepolia",
-}

ethpm/contract.py

@@ -1,187 +0,0 @@
-from typing import (
-    TYPE_CHECKING,
-    Any,
-    Dict,
-    List,
-    Optional,
-    Tuple,
-    Type,
-)
-
-from eth_utils import (
-    combomethod,
-    is_canonical_address,
-    to_bytes,
-    to_canonical_address,
-)
-from eth_utils.toolz import (
-    assoc,
-    curry,
-    pipe,
-)
-
-from ethpm.exceptions import (
-    BytecodeLinkingError,
-    EthPMValidationError,
-)
-from ethpm.validation.misc import (
-    validate_empty_bytes,
-)
-from web3._utils.compat import (
-    Self,
-)
-from web3._utils.validation import (
-    validate_address,
-)
-from web3.contract import (
-    Contract,
-    ContractConstructor,
-)
-
-if TYPE_CHECKING:
-    from web3 import Web3  # noqa: F401
-
-
-class LinkableContract(Contract):
-    """
-    A subclass of web3.contract.Contract that is capable of handling
-    contract factories with link references in their package's manifest.
-    """
-
-    unlinked_references: Optional[Tuple[Dict[str, Any]]] = None
-    linked_references: Optional[Tuple[Dict[str, Any]]] = None
-    needs_bytecode_linking = None
-
-    def __init__(self, address: bytes, **kwargs: Any) -> None:
-        if self.needs_bytecode_linking:
-            raise BytecodeLinkingError(
-                "Contract cannot be instantiated until its bytecode is linked."
-            )
-        validate_address(address)
-        # type ignored to allow for undefined **kwargs on `Contract` base class __init__
-        super().__init__(address=address, **kwargs)  # type: ignore
-
-    @classmethod
-    def factory(cls, w3: "Web3", class_name: str = None, **kwargs: Any) -> Type[Self]:
-        dep_link_refs = kwargs.get("unlinked_references")
-        bytecode = kwargs.get("bytecode")
-        needs_bytecode_linking = False
-        if dep_link_refs and bytecode:
-            if not is_prelinked_bytecode(to_bytes(hexstr=bytecode), dep_link_refs):
-                needs_bytecode_linking = True
-        kwargs = assoc(kwargs, "needs_bytecode_linking", needs_bytecode_linking)
-        return super().factory(w3, class_name, **kwargs)
-
-    @classmethod
-    def constructor(cls, *args: Any, **kwargs: Any) -> ContractConstructor:
-        if cls.needs_bytecode_linking:
-            raise BytecodeLinkingError(
-                "Contract cannot be deployed until its bytecode is linked."
-            )
-        return super().constructor(*args, **kwargs)
-
-    @classmethod
-    def link_bytecode(cls, attr_dict: Dict[str, str]) -> Type["LinkableContract"]:
-        """
-        Return a cloned contract factory with the deployment / runtime bytecode linked.
-
-        :attr_dict: Dict[`ContractType`: `Address`] for all deployment and runtime
-        link references.
-        """
-        if not cls.unlinked_references and not cls.linked_references:
-            raise BytecodeLinkingError("Contract factory has no linkable bytecode.")
-        if not cls.needs_bytecode_linking:
-            raise BytecodeLinkingError(
-                "Bytecode for this contract factory does not require bytecode linking."
-            )
-        cls.validate_attr_dict(attr_dict)
-        bytecode = apply_all_link_refs(cls.bytecode, cls.unlinked_references, attr_dict)
-        runtime = apply_all_link_refs(
-            cls.bytecode_runtime, cls.linked_references, attr_dict
-        )
-        linked_class = cls.factory(cls.w3, bytecode_runtime=runtime, bytecode=bytecode)
-        if linked_class.needs_bytecode_linking:
-            raise BytecodeLinkingError(
-                "Expected class to be fully linked, but class "
-                "still needs bytecode linking."
-            )
-        return linked_class
-
-    @combomethod
-    def validate_attr_dict(self, attr_dict: Dict[str, str]) -> None:
-        """
-        Validates that ContractType keys in attr_dict reference existing
-        manifest ContractTypes.
-        """
-        attr_dict_names = attr_dict.keys()
-
-        if not self.unlinked_references and not self.linked_references:
-            raise BytecodeLinkingError(
-                "Unable to validate attr dict, this contract has no "
-                "linked/unlinked references."
-            )
-
-        unlinked_refs = self.unlinked_references or ({},)
-        linked_refs = self.linked_references or ({},)
-        all_link_refs = unlinked_refs + linked_refs
-
-        all_link_names = {ref["name"] for ref in all_link_refs if ref}
-        if attr_dict_names != all_link_names:
-            raise BytecodeLinkingError(
-                "All link references must be defined when calling "
-                "`link_bytecode` on a contract factory."
-            )
-        for address in attr_dict.values():
-            validate_address(address)
-
-
-def is_prelinked_bytecode(bytecode: bytes, link_refs: List[Dict[str, Any]]) -> bool:
-    """
-    Returns False if all expected link_refs are unlinked, otherwise returns True.
-    todo support partially pre-linked bytecode (currently all or nothing)
-    """
-    for link_ref in link_refs:
-        for offset in link_ref["offsets"]:
-            try:
-                validate_empty_bytes(offset, link_ref["length"], bytecode)
-            except EthPMValidationError:
-                return True
-    return False
-
-
-def apply_all_link_refs(
-    bytecode: bytes, link_refs: List[Dict[str, Any]], attr_dict: Dict[str, str]
-) -> bytes:
-    """
-    Applies all link references corresponding to a valid attr_dict to the bytecode.
-    """
-    if link_refs is None:
-        return bytecode
-    link_fns = (
-        apply_link_ref(offset, ref["length"], attr_dict[ref["name"]])
-        for ref in link_refs
-        for offset in ref["offsets"]
-    )
-    linked_bytecode = pipe(bytecode, *link_fns)
-    return linked_bytecode
-
-
-@curry
-def apply_link_ref(offset: int, length: int, value: bytes, bytecode: bytes) -> bytes:
-    """
-    Returns the new bytecode with `value` put into the location indicated by
-    `offset` and `length`.
-    """
-    try:
-        validate_empty_bytes(offset, length, bytecode)
-    except EthPMValidationError:
-        raise BytecodeLinkingError("Link references cannot be applied to bytecode")
-
-    address = value if is_canonical_address(value) else to_canonical_address(value)
-    new_bytes = (
-        # Ignore linting error b/c conflict b/w black & flake8
-        bytecode[:offset]
-        + address
-        + bytecode[offset + length :]  # noqa: E201, E203
-    )
-    return new_bytes

ethpm/dependencies.py

@@ -1,58 +0,0 @@
-from typing import (
-    Dict,
-    List,
-    Tuple,
-)
-
-from ethpm.validation.package import (
-    validate_package_name,
-)
-
-
-class Dependencies:
-    """
-    Class to manage the `Package` instances of a Package's `buildDependencies`.
-    """
-
-    # ignoring Package type here and below to avoid a circular dependency
-    def __init__(
-        self, build_dependencies: Dict[str, "Package"]  # type: ignore  # noqa: F821
-    ) -> None:
-        self.build_dependencies = build_dependencies
-
-    def __getitem__(self, key: str) -> "Package":  # type: ignore  # noqa: F821
-        return self.build_dependencies.get(key)
-
-    def __contains__(self, key: str) -> bool:
-        return key in self.build_dependencies
-
-    def _validate_name(self, name: str) -> None:
-        validate_package_name(name)
-        if name not in self.build_dependencies:
-            raise KeyError(f"Package name: {name} not found in build dependencies.")
-
-    def items(self) -> Tuple[Tuple[str, "Package"], ...]:  # type: ignore  # noqa: F821
-        """
-        Return an iterable containing package name and
-        corresponding `Package` instance that are available.
-        """
-        item_dict = {
-            name: self.build_dependencies.get(name) for name in self.build_dependencies
-        }
-        return tuple(item_dict.items())
-
-    def values(self) -> List["Package"]:  # type: ignore  # noqa: F821
-        """
-        Return an iterable of the available `Package` instances.
-        """
-        values = [self.build_dependencies.get(name) for name in self.build_dependencies]
-        return values
-
-    def get_dependency_package(
-        self, package_name: str
-    ) -> "Package":  # type: ignore # noqa: F821
-        """
-        Return the dependency Package for a given package name.
-        """
-        self._validate_name(package_name)
-        return self.build_dependencies.get(package_name)