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

faster_eth_utils/exceptions.py

@@ -1,6 +1,11 @@
-class ValidationError(Exception):
+"""
+faster-eth-utils exceptions always inherit from eth-utils exceptions, so porting to faster-eth-utils
+does not require any change to your existing exception handlers. They will continue to work.
+"""
+
+import eth_utils.exceptions
+
+class ValidationError(eth_utils.exceptions.ValidationError):  # type: ignore[misc]
     """
     Raised when something does not pass a validation check.
     """
-
-    pass

faster_eth_utils/functional.py

@@ -1,21 +1,23 @@
 import collections
 import functools
 import itertools
+from collections.abc import Callable, Iterable, Mapping
 from typing import (  # noqa: F401
-    Any,
-    Callable,
     Dict,
-    Iterable,
     List,
-    Mapping,
     Set,
     Tuple,
     TypeVar,
     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 +33,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, 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,42 +2,52 @@
 
 import binascii
 import re
-from typing import Any, AnyStr, Final
+from typing import (
+    Any,
+    Final,
+    TypeGuard,
+)
 
-from eth_typing import HexStr
+from eth_typing import (
+    HexStr,
+)
 
-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)):
+def encode_hex(value: str | bytes | bytearray) -> HexStr:
+    ascii_bytes: 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))
-        )
-    return value.startswith(("0x", "0X"))
+    # 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") or value.startswith("0X")
 
 
 def remove_0x_prefix(value: HexStr) -> HexStr:
@@ -52,17 +62,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,22 +1,36 @@
-from typing import Any, Final, Iterable, Iterator, Tuple, Union
-from urllib import parse
+from collections.abc import (
+    Iterable,
+    Iterator,
+)
+from typing import (
+    Any,
+    Final,
+)
+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:
-    if int(seconds) == 0:
+def humanize_seconds(seconds: float | int) -> str:
+    seconds_int = int(seconds)
+    if seconds_int == 0:
         return "0s"
 
-    unit_values = _consume_leading_zero_units(_humanize_seconds(int(seconds)))
+    unit_values = _consume_leading_zero_units(_humanize_seconds(seconds_int))
 
-    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
@@ -40,8 +54,8 @@ UNITS: Final = (
 
 
 def _consume_leading_zero_units(
-    units_iter: Iterator[Tuple[int, str]]
-) -> Iterator[Tuple[int, str]]:
+    units_iter: Iterator[tuple[int, str]]
+) -> Iterator[tuple[int, str]]:
     for amount, unit in units_iter:
         if amount == 0:
             continue
@@ -52,7 +66,7 @@ def _consume_leading_zero_units(
     yield from units_iter
 
 
-def _humanize_seconds(seconds: int) -> Iterator[Tuple[int, str]]:
+def _humanize_seconds(seconds: int) -> Iterator[tuple[int, str]]:
     remainder = seconds
 
     for duration, unit in UNITS:
@@ -74,7 +88,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 +113,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 +141,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 +151,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,17 +161,17 @@ 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]
 
 
-def _humanize_range(bounds: Tuple[int, int]) -> str:
+def _humanize_range(bounds: tuple[int, int]) -> str:
     left, right = bounds
     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 +187,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:
@@ -169,5 +198,4 @@ def humanize_wei(number: int) -> str:
     else:
         unit = "wei"
     amount = from_wei(number, unit)
-    x = f"{str(amount)} {unit}"
-    return x
+    return f"{str(amount)} {unit}"

faster_eth_utils/logging.py

@@ -1,19 +1,34 @@
-import contextlib
 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 collections.abc import (
+    Iterator,
+)
+from contextlib import (
+    contextmanager,
+)
+from functools import (
+    cached_property,
+)
+from typing import (
+    Any,
+    Final,
+    TypeVar,
+    cast,
+    overload,
+)
+
+from .toolz import (
+    assoc,
+)
 
 DEBUG2_LEVEL_NUM = 8
 
 TLogger = TypeVar("TLogger", bound=logging.Logger)
 
+Logger: Final = logging.Logger
+getLogger: Final = logging.getLogger
+getLoggerClass: Final = logging.getLoggerClass
+setLoggerClass: Final = logging.setLoggerClass
+
 
 class ExtendedDebugLogger(logging.Logger):
     """
@@ -33,7 +48,7 @@ class ExtendedDebugLogger(logging.Logger):
             # lambda to further speed up
             self.__dict__["debug2"] = lambda message, *args, **kwargs: None
 
-    def __reduce__(self) -> Tuple[Any, ...]:
+    def __reduce__(self) -> tuple[Any, ...]:
         # This is needed because our parent's implementation could
         # cause us to become a regular Logger on unpickling.
         return get_extended_debug_logger, (self.name,)
@@ -45,37 +60,38 @@ 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]:
-    original_logger_class = logging.getLoggerClass()
-    logging.setLoggerClass(logger_class)
+@contextmanager
+def _use_logger_class(logger_class: type[logging.Logger]) -> Iterator[None]:
+    original_logger_class = getLoggerClass()
+    setLoggerClass(logger_class)
     try:
         yield
     finally:
-        logging.setLoggerClass(original_logger_class)
+        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: type[TLogger] | None = None) -> TLogger | logging.Logger:
     if logger_class is None:
-        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))
+        return 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 = 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, getLogger(name))
 
 
 def get_extended_debug_logger(name: str) -> ExtendedDebugLogger:
@@ -93,13 +109,13 @@ class HasLoggerMeta(type):
     to use when creating the associated logger for a given class.
     """
 
-    logger_class = logging.Logger
+    logger_class = Logger
 
     def __new__(
-        mcls: Type[THasLoggerMeta],
+        mcls: type[THasLoggerMeta],
         name: str,
-        bases: Tuple[Type[Any]],
-        namespace: Dict[str, Any],
+        bases: tuple[type[Any]],
+        namespace: dict[str, Any],
     ) -> THasLoggerMeta:
         if "logger" in namespace:
             # If a logger was explicitly declared we shouldn't do anything to
@@ -107,45 +123,30 @@ 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))
 
     @classmethod
     def replace_logger_class(
-        mcls: Type[THasLoggerMeta], value: Type[logging.Logger]
-    ) -> Type[THasLoggerMeta]:
+        mcls: type[THasLoggerMeta], value: type[logging.Logger]
+    ) -> type[THasLoggerMeta]:
         return type(mcls.__name__, (mcls,), {"logger_class": value})
 
     @classmethod
     def meta_compat(
-        mcls: Type[THasLoggerMeta], other: Type[type]
-    ) -> Type[THasLoggerMeta]:
+        mcls: type[THasLoggerMeta], other: type[type]
+    ) -> type[THasLoggerMeta]:
         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]
+    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)