faster-eth-utils 2.3.1__cp311-cp311-win32.whl → 5.3.19__cp311-cp311-win32.whl

faster_eth_utils/functional.py

@@ -2,7 +2,6 @@ import collections
 import functools
 import itertools
 from typing import (  # noqa: F401
-    Any,
     Callable,
     Dict,
     Iterable,
@@ -14,8 +13,13 @@ from typing import (  # noqa: F401
     Union,
 )
 
-from .toolz import compose as _compose
+from typing_extensions import ParamSpec
 
+from .toolz import (
+    compose as _compose,
+)
+
+P = ParamSpec("P")
 T = TypeVar("T")
 
 
@@ -31,41 +35,53 @@ TFOut = TypeVar("TFOut")
 def combine(
     f: Callable[[TGOut], TFOut], g: Callable[[TGIn], TGOut]
 ) -> Callable[[TGIn], TFOut]:
-    return lambda x: f(g(x))
+    def combined(x: TGIn) -> TFOut:
+        return f(g(x))
+    return combined
+
+
+TCb = TypeVar("TCb")
 
 
 def apply_to_return_value(
-    callback: Callable[..., T]
-) -> Callable[..., Callable[..., T]]:
-    def outer(fn: Callable[..., T]) -> Callable[..., T]:
-        # We would need to type annotate *args and **kwargs but doing so segfaults
-        # the PyPy builds. We ignore instead.
+    callback: Callable[[T], TCb]
+) -> Callable[[Callable[P, T]], Callable[P, TCb]]:
+    def outer(fn: Callable[P, T]) -> Callable[P, TCb]:
         @functools.wraps(fn)
-        def inner(*args, **kwargs) -> T:  # type: ignore
+        def inner(*args: P.args, **kwargs: P.kwargs) -> TCb:
             return callback(fn(*args, **kwargs))
-
         return inner
-
     return outer
 
 
 TVal = TypeVar("TVal")
 TKey = TypeVar("TKey")
-to_tuple = apply_to_return_value(
-    tuple
-)  # type: Callable[[Callable[..., Iterable[TVal]]], Callable[..., Tuple[TVal, ...]]]  # noqa: E501
-to_list = apply_to_return_value(
-    list
-)  # type: Callable[[Callable[..., Iterable[TVal]]], Callable[..., List[TVal]]]  # noqa: E501
-to_set = apply_to_return_value(
-    set
-)  # type: Callable[[Callable[..., Iterable[TVal]]], Callable[..., Set[TVal]]]  # noqa: E501
-to_dict = apply_to_return_value(
-    dict
-)  # type: Callable[[Callable[..., Iterable[Union[Mapping[TKey, TVal], Tuple[TKey, TVal]]]]], Callable[..., Dict[TKey, TVal]]]  # noqa: E501
-to_ordered_dict = apply_to_return_value(
+
+def to_tuple(fn: Callable[P, Iterable[TVal]]) -> Callable[P, Tuple[TVal, ...]]:
+    def to_tuple_wrap(*args: P.args, **kwargs: P.kwargs) -> Tuple[TVal, ...]:
+        return tuple(fn(*args, **kwargs))
+    return to_tuple_wrap
+
+def to_list(fn: Callable[P, Iterable[TVal]]) -> Callable[P, List[TVal]]:
+    def to_list_wrap(*args: P.args, **kwargs: P.kwargs) -> List[TVal]:
+        return list(fn(*args, **kwargs))
+    return to_list_wrap
+
+def to_set(fn: Callable[P, Iterable[TVal]]) -> Callable[P, Set[TVal]]:
+    def to_set_wrap(*args: P.args, **kwargs: P.kwargs) -> Set[TVal]:
+        return set(fn(*args, **kwargs))
+    return to_set_wrap
+
+def to_dict(
+    fn: Callable[P, Union[Mapping[TKey, TVal], Iterable[Tuple[TKey, TVal]]]]
+) -> Callable[P, Dict[TKey, TVal]]:
+    def to_dict_wrap(*args: P.args, **kwargs: P.kwargs) -> Dict[TKey, TVal]:
+        return dict(fn(*args, **kwargs))
+    return to_dict_wrap
+
+to_ordered_dict = apply_to_return_value(  # type: ignore [assignment]
     collections.OrderedDict
-)  # type: Callable[[Callable[..., Iterable[Union[Mapping[TKey, TVal], Tuple[TKey, TVal]]]]], Callable[..., collections.OrderedDict[TKey, TVal]]]  # noqa: E501
+)  # type: Callable[[Callable[P, Union[Mapping[TKey, TVal], Iterable[Tuple[TKey, TVal]]]]], Callable[P, collections.OrderedDict[TKey, TVal]]]  # noqa: E501
 sort_return = _compose(to_tuple, apply_to_return_value(sorted))
 flatten_return = _compose(
     to_tuple, apply_to_return_value(itertools.chain.from_iterable)

faster_eth_utils/hexadecimal.py

@@ -2,41 +2,55 @@
 
 import binascii
 import re
-from typing import Any, AnyStr, Final
+from typing import (
+    Any,
+    AnyStr,
+    Final,
+    Union,
+)
 
-from eth_typing import HexStr
+from eth_typing import (
+    HexStr,
+)
+from typing_extensions import (
+    TypeGuard,
+)
 
-from .types import is_string, is_text
+_HEX_REGEXP_MATCH: Final = re.compile("(0[xX])?[0-9a-fA-F]*").fullmatch
+
+hexlify: Final = binascii.hexlify
+unhexlify: Final = binascii.unhexlify
 
-_HEX_REGEXP: Final = re.compile("(0[xX])?[0-9a-fA-F]*")
 
 
 def decode_hex(value: str) -> bytes:
-    if not is_text(value):
+    if not isinstance(value, str):
         raise TypeError("Value must be an instance of str")
     non_prefixed = remove_0x_prefix(HexStr(value))
     # unhexlify will only accept bytes type someday
     ascii_hex = non_prefixed.encode("ascii")
-    return binascii.unhexlify(ascii_hex)
+    return unhexlify(ascii_hex)
 
 
 def encode_hex(value: AnyStr) -> HexStr:
-    if not is_string(value):
-        raise TypeError("Value must be an instance of str or unicode")
-    elif isinstance(value, (bytes, bytearray)):
+    ascii_bytes: Union[bytes, bytearray]
+    if isinstance(value, (bytes, bytearray)):
         ascii_bytes = value
-    else:
+    elif isinstance(value, str):
         ascii_bytes = value.encode("ascii")
+    else:
+        raise TypeError("Value must be an instance of str or unicode")
 
-    binary_hex = binascii.hexlify(ascii_bytes)
+    binary_hex = hexlify(ascii_bytes)
     return add_0x_prefix(HexStr(binary_hex.decode("ascii")))
 
 
 def is_0x_prefixed(value: str) -> bool:
-    if not is_text(value):
-        raise TypeError(
-            "is_0x_prefixed requires text typed arguments. Got: {0}".format(repr(value))
-        )
+    # this check is not needed in the compiled version
+    # if not isinstance(value, str):
+    #     raise TypeError(
+    #         f"is_0x_prefixed requires text typed arguments. Got: {repr(value)}"
+    #     )
     return value.startswith(("0x", "0X"))
 
 
@@ -52,17 +66,15 @@ def add_0x_prefix(value: HexStr) -> HexStr:
     return HexStr("0x" + value)
 
 
-def is_hexstr(value: Any) -> bool:
-    if not is_text(value) or not value:
+def is_hexstr(value: Any) -> TypeGuard[HexStr]:
+    if not isinstance(value, str) or not value:
         return False
-    return _HEX_REGEXP.fullmatch(value) is not None
+    return _HEX_REGEXP_MATCH(value) is not None
 
 
-def is_hex(value: Any) -> bool:
-    if not is_text(value):
-        raise TypeError(
-            "is_hex requires text typed arguments. Got: {0}".format(repr(value))
-        )
+def is_hex(value: Any) -> TypeGuard[HexStr]:
+    if not isinstance(value, str):
+        raise TypeError(f"is_hex requires text typed arguments. Got: {repr(value)}")
     if not value:
         return False
-    return _HEX_REGEXP.fullmatch(value) is not None
+    return _HEX_REGEXP_MATCH(value) is not None

faster_eth_utils/humanize.py

@@ -1,11 +1,26 @@
-from typing import Any, Final, Iterable, Iterator, Tuple, Union
-from urllib import parse
+from typing import (
+    Any,
+    Final,
+    Iterable,
+    Iterator,
+    Tuple,
+    Union,
+)
+from urllib import (
+    parse,
+)
 
-from eth_typing import URI, Hash32
+from eth_typing import (
+    URI,
+    Hash32,
+)
 
-from faster_eth_utils.currency import denoms, from_wei
+from faster_eth_utils.currency import (
+    denoms,
+    from_wei,
+)
 
-from .toolz import sliding_window, take
+from . import toolz
 
 
 def humanize_seconds(seconds: Union[float, int]) -> str:
@@ -14,9 +29,7 @@ def humanize_seconds(seconds: Union[float, int]) -> str:
 
     unit_values = _consume_leading_zero_units(_humanize_seconds(int(seconds)))
 
-    return "".join(
-        ("{0}{1}".format(amount, unit) for amount, unit in take(3, unit_values))
-    )
+    return "".join((f"{amount}{unit}" for amount, unit in toolz.take(3, unit_values)))
 
 
 SECOND: Final = 1
@@ -74,7 +87,22 @@ def humanize_bytes(value: bytes) -> str:
     value_as_hex = value.hex()
     head = value_as_hex[:DISPLAY_HASH_CHARS]
     tail = value_as_hex[-1 * DISPLAY_HASH_CHARS :]
-    return "{0}..{1}".format(head, tail)
+    return f"{head}..{tail}"
+
+
+def humanize_hexstr(value: str) -> str:
+    tail = value[-1 * DISPLAY_HASH_CHARS :]
+
+    if value[:2] == "0x":
+        if len(value[2:]) <= DISPLAY_HASH_CHARS * 2:
+            return value
+        head = value[2 : DISPLAY_HASH_CHARS + 2]
+        return f"0x{head}..{tail}"
+    else:
+        if len(value) <= DISPLAY_HASH_CHARS * 2:
+            return value
+        head = value[:DISPLAY_HASH_CHARS]
+        return f"{head}..{tail}"
 
 
 def humanize_hash(value: Hash32) -> str:
@@ -84,15 +112,15 @@ def humanize_hash(value: Hash32) -> str:
 def humanize_ipfs_uri(uri: URI) -> str:
     if not is_ipfs_uri(uri):
         raise TypeError(
-            "%s does not look like a valid IPFS uri. Currently, "
-            "only CIDv0 hash schemes are supported." % uri
+            f"{uri} does not look like a valid IPFS uri. Currently, "
+            "only CIDv0 hash schemes are supported."
         )
 
     parsed = parse.urlparse(uri)
     ipfs_hash = parsed.netloc
     head = ipfs_hash[:DISPLAY_HASH_CHARS]
     tail = ipfs_hash[-1 * DISPLAY_HASH_CHARS :]
-    return "ipfs://{0}..{1}".format(head, tail)
+    return f"ipfs://{head}..{tail}"
 
 
 def is_ipfs_uri(value: Any) -> bool:
@@ -112,9 +140,9 @@ def _is_CIDv0_ipfs_hash(ipfs_hash: str) -> bool:
     return False
 
 
-def _find_breakpoints(*values: int) -> Iterator[int]:
+def _find_breakpoints(values: Tuple[int, ...]) -> Iterator[int]:
     yield 0
-    for index, (left, right) in enumerate(sliding_window(2, values), 1):
+    for index, (left, right) in enumerate(toolz.sliding_window(2, values), 1):
         if left + 1 == right:
             continue
         else:
@@ -122,7 +150,7 @@ def _find_breakpoints(*values: int) -> Iterator[int]:
     yield len(values)
 
 
-def _extract_integer_ranges(*values: int) -> Iterator[Tuple[int, int]]:
+def _extract_integer_ranges(values: Tuple[int, ...]) -> Iterator[Tuple[int, int]]:
     """
     Return a tuple of consecutive ranges of integers.
 
@@ -132,7 +160,7 @@ def _extract_integer_ranges(*values: int) -> Iterator[Tuple[int, int]]:
     - fn(1, 2, 3, 7, 8, 9) -> ((1, 3), (7, 9))
     - fn(1, 7, 8, 9) -> ((1, 1), (7, 9))
     """
-    for left, right in sliding_window(2, _find_breakpoints(*values)):
+    for left, right in toolz.sliding_window(2, _find_breakpoints(values)):
         chunk = values[left:right]
         yield chunk[0], chunk[-1]
 
@@ -142,7 +170,7 @@ def _humanize_range(bounds: Tuple[int, int]) -> str:
     if left == right:
         return str(left)
     else:
-        return "{left}-{right}".format(left=left, right=right)
+        return f"{left}-{right}"
 
 
 def humanize_integer_sequence(values_iter: Iterable[int]) -> str:
@@ -158,7 +186,7 @@ def humanize_integer_sequence(values_iter: Iterable[int]) -> str:
     if not values:
         return "(empty)"
     else:
-        return "|".join(map(_humanize_range, _extract_integer_ranges(*values)))
+        return "|".join(_humanize_range(range) for range in _extract_integer_ranges(values))
 
 
 def humanize_wei(number: int) -> str:

faster_eth_utils/logging.py

@@ -1,14 +1,23 @@
 import contextlib
+from functools import (
+    cached_property,
+)
 import logging
-import sys
-from typing import Any, Dict, Iterator, Tuple, Type, TypeVar, cast
-
-from .toolz import assoc
-
-if sys.version_info < (3, 8):
-    from cached_property import cached_property
-else:
-    from functools import cached_property
+from typing import (
+    Any,
+    Dict,
+    Iterator,
+    Tuple,
+    Type,
+    TypeVar,
+    Union,
+    cast,
+    overload,
+)
+
+from .toolz import (
+    assoc,
+)
 
 DEBUG2_LEVEL_NUM = 8
 
@@ -45,8 +54,7 @@ def setup_DEBUG2_logging() -> None:
     """
     if not hasattr(logging, "DEBUG2"):
         logging.addLevelName(DEBUG2_LEVEL_NUM, "DEBUG2")
-        setattr(logging, "DEBUG2", DEBUG2_LEVEL_NUM)  # typing: ignore
-
+        logging.DEBUG2 = DEBUG2_LEVEL_NUM  # type: ignore [attr-defined]
 
 @contextlib.contextmanager
 def _use_logger_class(logger_class: Type[logging.Logger]) -> Iterator[None]:
@@ -58,24 +66,26 @@ def _use_logger_class(logger_class: Type[logging.Logger]) -> Iterator[None]:
         logging.setLoggerClass(original_logger_class)
 
 
-def get_logger(name: str, logger_class: Type[TLogger] = None) -> TLogger:
+@overload
+def get_logger(name: str, logger_class: Type[TLogger]) -> TLogger: ...
+@overload
+def get_logger(name: str, logger_class: None = None) -> logging.Logger: ...
+def get_logger(name: str, logger_class: Union[Type[TLogger], None] = None) -> Union[TLogger, logging.Logger]:
     if logger_class is None:
+        return logging.getLogger(name)
+
+    with _use_logger_class(logger_class):
+        # The logging module caches logger instances. The following code
+        # ensures that if there is a cached instance that we don't
+        # accidentally return the incorrect logger type because the logging
+        # module does not *update* the cached instance in the event that
+        # the global logging class changes.
+        manager = logging.Logger.manager
+        logger_dict = manager.loggerDict
+        cached_logger = logger_dict.get(name)
+        if cached_logger is not None and type(cached_logger) is not logger_class:
+            del logger_dict[name]
         return cast(TLogger, logging.getLogger(name))
-    else:
-        with _use_logger_class(logger_class):
-            # The logging module caches logger instances.  The following code
-            # ensures that if there is a cached instance that we don't
-            # accidentally return the incorrect logger type because the logging
-            # module does not *update* the cached instance in the event that
-            # the global logging class changes.
-            #
-            # types ignored b/c mypy doesn't identify presence of
-            # manager on logging.Logger
-            manager = logging.Logger.manager
-            if name in manager.loggerDict:
-                if type(manager.loggerDict[name]) is not logger_class:
-                    del manager.loggerDict[name]
-            return cast(TLogger, logging.getLogger(name))
 
 
 def get_extended_debug_logger(name: str) -> ExtendedDebugLogger:
@@ -107,9 +117,8 @@ class HasLoggerMeta(type):
             return super().__new__(mcls, name, bases, namespace)
         if "__qualname__" not in namespace:
             raise AttributeError("Missing __qualname__")
-
-        with _use_logger_class(mcls.logger_class):
-            logger = logging.getLogger(namespace["__qualname__"])
+    
+        logger = get_logger(namespace["__qualname__"], mcls.logger_class)
 
         return super().__new__(mcls, name, bases, assoc(namespace, "logger", logger))
 
@@ -126,26 +135,12 @@ class HasLoggerMeta(type):
         return type(mcls.__name__, (mcls, other), {})
 
 
-class _BaseHasLogger(metaclass=HasLoggerMeta):
-    # This class exists to a allow us to define the type of the logger.  Once
-    # python3.5 is deprecated this can be removed in favor of a simple type
-    # annotation on the main class.
-    logger = logging.Logger("")  # type: logging.Logger
-
-
-class HasLogger(_BaseHasLogger):
-    pass
+class HasLogger(metaclass=HasLoggerMeta):
+    logger: logging.Logger
 
 
 HasExtendedDebugLoggerMeta = HasLoggerMeta.replace_logger_class(ExtendedDebugLogger)
 
 
-class _BaseHasExtendedDebugLogger(metaclass=HasExtendedDebugLoggerMeta):  # type: ignore
-    # This class exists to a allow us to define the type of the logger.  Once
-    # python3.5 is deprecated this can be removed in favor of a simple type
-    # annotation on the main class.
-    logger = ExtendedDebugLogger("")  # type: ExtendedDebugLogger
-
-
-class HasExtendedDebugLogger(_BaseHasExtendedDebugLogger):
-    pass
+class HasExtendedDebugLogger(metaclass=HasExtendedDebugLoggerMeta):  # type: ignore [metaclass,misc]
+    logger: ExtendedDebugLogger

faster_eth_utils/module_loading.py

@@ -1,5 +1,9 @@
-from importlib import import_module
-from typing import Any
+from importlib import (
+    import_module,
+)
+from typing import (
+    Any,
+)
 
 
 def import_string(dotted_path: str) -> Any:
@@ -15,7 +19,7 @@ def import_string(dotted_path: str) -> Any:
     try:
         module_path, class_name = dotted_path.rsplit(".", 1)
     except ValueError:
-        msg = "%s doesn't look like a module path" % dotted_path
+        msg = f"{dotted_path} doesn't look like a module path"
         raise ImportError(msg)
 
     module = import_module(module_path)
@@ -23,8 +27,5 @@ def import_string(dotted_path: str) -> Any:
     try:
         return getattr(module, class_name)
     except AttributeError:
-        msg = 'Module "%s" does not define a "%s" attribute/class' % (
-            module_path,
-            class_name,
-        )
+        msg = f'Module "{module_path}" does not define a "{class_name}" attribute/class'
         raise ImportError(msg)

faster_eth_utils/network.py

@@ -1,12 +1,27 @@
-from dataclasses import dataclass
+from dataclasses import (
+    dataclass,
+)
 import json
 import os
-from typing import List
-import warnings
+import sys
+from pathlib import (
+    Path,
+)
+from typing import (
+    Final,
+    List,
+)
 
-from eth_typing import ChainId
+from eth_typing import (
+    ChainId,
+)
 
-from faster_eth_utils import ValidationError
+from faster_eth_utils import (
+    ValidationError,
+)
+
+
+FASTER_ETH_UTILS_FOLDER: Final = Path(sys.modules["faster_eth_utils"].__file__).parent  # type: ignore [arg-type]
 
 
 @dataclass
@@ -21,11 +36,10 @@ def initialize_network_objects() -> List[Network]:
     networks_obj = []
 
     networks_json_path = os.path.abspath(
-        os.path.join(os.path.dirname(__file__), "__json")
+        os.path.join(str(FASTER_ETH_UTILS_FOLDER), "__json")
     )
     with open(
         os.path.join(networks_json_path, "eth_networks.json"),
-        "r",
         encoding="UTF-8",
     ) as open_file:
         network_data = json.load(open_file)
@@ -40,13 +54,11 @@ def initialize_network_objects() -> List[Network]:
             )
             networks_obj.append(network)
         except ValueError:
-            # Entry does not have a valid ChainId constant in eth-typing
-            warnings.warn(
-                f"Network {entry['chainId']} with name '{entry['name']}' does not have "
-                f"a valid ChainId. eth-typing should be updated with the latest "
-                f"networks."
-            )
+            # Chain does not have a valid ChainId, network files in eth-utils and
+            # eth-typing should to be updated. Run `python update_networks.py` in the
+            # project root.
             pass
+
     return networks_obj
 
 

faster_eth_utils/numeric.py

@@ -1,7 +1,14 @@
-from abc import ABC, abstractmethod
+from abc import (
+    ABC,
+    abstractmethod,
+)
 import decimal
 import numbers
-from typing import Any, TypeVar, Union
+from typing import (
+    Any,
+    TypeVar,
+    Union,
+)
 
 
 class Comparable(ABC):
@@ -22,11 +29,11 @@ TValue = TypeVar("TValue", bound=TComparable)
 
 def clamp(lower_bound: TValue, upper_bound: TValue, value: TValue) -> TValue:
     # The `mypy` ignore statements here are due to doing a comparison of
-    # `Union` types which isn't allowed. (per cburgdorf).  This approach was
+    # `Union` types which isn't allowed. (per cburgdorf). This approach was
     # chosen over using `typing.overload` to define multiple signatures for
     # each comparison type here since the added value of "proper" typing
     # doesn't seem to justify the complexity of having a bunch of different
-    # signatures defined.  The external library perspective on this function
+    # signatures defined. The external library perspective on this function
     # should still be adequate under this approach
     if value < lower_bound:  # type: ignore
         return lower_bound