faster-eth-utils 4.1.7__cp314-cp314t-win_amd64.whl → 5.3.22__cp314-cp314t-win_amd64.whl

faster_eth_utils/humanize.py

@@ -1,10 +1,10 @@
+from collections.abc import (
+    Iterable,
+    Iterator,
+)
 from typing import (
     Any,
     Final,
-    Iterable,
-    Iterator,
-    Tuple,
-    Union,
 )
 from urllib import (
     parse,
@@ -20,19 +20,17 @@ from faster_eth_utils.currency import (
     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((f"{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
@@ -56,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
@@ -68,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:
@@ -93,6 +91,21 @@ def humanize_bytes(value: bytes) -> str:
     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:
     return humanize_bytes(value)
 
@@ -128,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:
@@ -138,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.
 
@@ -148,12 +161,12 @@ 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)
@@ -174,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:
@@ -185,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,17 +1,19 @@
-import contextlib
+import logging
+from collections.abc import (
+    Iterator,
+)
+from contextlib import (
+    contextmanager,
+)
 from functools import (
     cached_property,
 )
-import logging
 from typing import (
     Any,
-    Dict,
-    Iterator,
-    Tuple,
-    Type,
+    Final,
     TypeVar,
-    Union,
     cast,
+    overload,
 )
 
 from .toolz import (
@@ -22,6 +24,11 @@ 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):
     """
@@ -41,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,)
@@ -53,37 +60,38 @@ def setup_DEBUG2_logging() -> None:
     """
     if not hasattr(logging, "DEBUG2"):
         logging.addLevelName(DEBUG2_LEVEL_NUM, "DEBUG2")
-        logging.DEBUG2 = DEBUG2_LEVEL_NUM  # type: 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: Union[Type[TLogger], None] = 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:
@@ -101,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
@@ -115,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/network.py

@@ -9,14 +9,13 @@ from pathlib import (
 )
 from typing import (
     Final,
-    List,
 )
 
 from eth_typing import (
     ChainId,
 )
 
-from faster_eth_utils import (
+from faster_eth_utils.exceptions import (
     ValidationError,
 )
 
@@ -32,7 +31,7 @@ class Network:
     symbol: ChainId
 
 
-def initialize_network_objects() -> List[Network]:
+def initialize_network_objects() -> list[Network]:
     networks_obj = []
 
     networks_json_path = os.path.abspath(

faster_eth_utils/pydantic.py

@@ -0,0 +1,103 @@
+from typing import (
+    Any,
+    cast,
+)
+
+from pydantic import (
+    BaseModel,
+    ConfigDict,
+)
+from pydantic._internal._core_utils import (
+    CoreSchemaField,
+)
+from pydantic.alias_generators import (
+    to_camel,
+)
+from pydantic.json_schema import (
+    DEFAULT_REF_TEMPLATE,
+    GenerateJsonSchema,
+    JsonSchemaMode,
+)
+
+
+class OmitJsonSchema(GenerateJsonSchema):  # type: ignore[misc]
+    """
+    Custom JSON schema generator that omits the schema generation for fields that are
+    invalid. Excluded fields (``Field(exclude=True)``) are generally useful as
+    properties of the model but are not meant to be serialized to JSON.
+    """
+
+    def field_is_present(self, field: CoreSchemaField) -> bool:
+        # override ``field_is_present`` and omit excluded fields from the schema
+        if field.get("serialization_exclude", False):
+            return False
+        return cast(bool, super().field_is_present(field))
+
+
+class CamelModel(BaseModel):  # type: ignore[misc]
+    """
+    Camel-case pydantic model. This model is used to ensure serialization in a
+    consistent manner, aliasing as camelCase serialization. This is useful for models
+    that are used in JSON-RPC requests and responses, marking useful fields for the
+    model, but that are not part of the JSON-RPC object, with ``Field(exclude=True)``.
+    To serialize a model to the expected JSON-RPC format, or camelCase, use
+    ``model_dump(by_alias=True)``.
+
+    .. code-block:: python
+
+        >>> from eth_utils.pydantic import CamelModel
+        >>> from pydantic import Field
+
+        >>> class SignedSetCodeAuthorization(CamelModel):
+        ...     chain_id: int
+        ...     address: bytes
+        ...     nonce: int
+        ...
+        ...     # useful fields for the object but excluded from serialization
+        ...     # (not part of the JSON-RPC object)
+        ...     authorization_hash: bytes = Field(exclude=True)
+        ...     signature: bytes = Field(exclude=True)
+
+        >>> auth = SignedSetCodeAuthorization(
+        ...     chain_id=1,
+        ...     address=b"0x0000000000000000000000000000000000000000",
+        ...     nonce=0,
+        ...     authorization_hash=generated_hash,
+        ...     signature=generated_signature,
+        ... )
+        >>> auth.model_dump(by_alias=True)
+        {'chainId': 1, 'address': '0x000000000000000000000000000000000000', 'nonce': 0}
+    """
+
+    model_config = ConfigDict(
+        arbitrary_types_allowed=True,
+        # populate by snake_case (python) args
+        populate_by_name=True,
+        # serialize by camelCase (json-rpc) keys
+        alias_generator=to_camel,
+        # validate default values
+        validate_default=True,
+    )
+
+    @classmethod
+    def model_json_schema(  # type: ignore [override]
+        cls,
+        by_alias: bool = True,
+        ref_template: str = DEFAULT_REF_TEMPLATE,
+        # default to ``OmitJsonSchema`` to prevent errors from excluded fields
+        schema_generator: type[GenerateJsonSchema] = OmitJsonSchema,
+        mode: JsonSchemaMode = "validation",
+    ) -> dict[str, Any]:
+        """
+        Omits excluded fields from the JSON schema, preventing errors that would
+        otherwise be raised by the default schema generator.
+        """
+        return cast(
+            dict[str, Any],
+            super().model_json_schema(
+                by_alias=by_alias,
+                ref_template=ref_template,
+                schema_generator=schema_generator,
+                mode=mode,
+            ),
+        )

faster_eth_utils/types.py

@@ -2,35 +2,38 @@ import collections.abc
 import numbers
 from typing import (
     Any,
-    List,
+    Final,
     Literal,
-    Tuple,
-    Union,
 )
 
-from typing_extensions import (
+from typing import (
     TypeGuard,
 )
 
-bytes_types = (bytes, bytearray)
-integer_types = (int,)
-text_types = (str,)
-string_types = (bytes, str, bytearray)
+Mapping: Final = collections.abc.Mapping
+Sequence: Final = collections.abc.Sequence
+
+Number: Final = numbers.Number
+
+bytes_types: Final = (bytes, bytearray)
+integer_types: Final = (int,)
+text_types: Final = (str,)
+string_types: Final = (bytes, str, bytearray)
 
 
 def is_integer(value: Any) -> TypeGuard[int]:
-    return isinstance(value, integer_types) and not isinstance(value, bool)
+    return isinstance(value, int) and not isinstance(value, bool)
 
 
-def is_bytes(value: Any) -> TypeGuard[Union[bytes, bytearray]]:
+def is_bytes(value: Any) -> TypeGuard[bytes | bytearray]:
     return isinstance(value, bytes_types)
 
 
 def is_text(value: Any) -> TypeGuard[str]:
-    return isinstance(value, text_types)
+    return isinstance(value, str)
 
 
-def is_string(value: Any) -> TypeGuard[Union[bytes, str, bytearray]]:
+def is_string(value: Any) -> TypeGuard[bytes | str | bytearray]:
     return isinstance(value, string_types)
 
 
@@ -39,18 +42,18 @@ def is_boolean(value: Any) -> TypeGuard[bool]:
 
 
 def is_dict(obj: Any) -> TypeGuard[collections.abc.Mapping[Any, Any]]:
-    return isinstance(obj, collections.abc.Mapping)
+    return isinstance(obj, dict) or isinstance(obj, Mapping)
 
 
 def is_list_like(obj: Any) -> TypeGuard[collections.abc.Sequence[Any]]:
-    return not is_string(obj) and isinstance(obj, collections.abc.Sequence)
+    return isinstance(obj, (list, tuple)) or not is_string(obj) and isinstance(obj, Sequence)
 
 
-def is_list(obj: Any) -> TypeGuard[List[Any]]:
+def is_list(obj: Any) -> TypeGuard[list[Any]]:
     return isinstance(obj, list)
 
 
-def is_tuple(obj: Any) -> TypeGuard[Tuple[Any, ...]]:
+def is_tuple(obj: Any) -> TypeGuard[tuple[Any, ...]]:
     return isinstance(obj, tuple)
 
 
@@ -59,4 +62,4 @@ def is_null(obj: Any) -> TypeGuard[Literal[None]]:
 
 
 def is_number(obj: Any) -> TypeGuard[numbers.Number]:
-    return isinstance(obj, numbers.Number)
+    return isinstance(obj, Number)

{faster_eth_utils-4.1.7.dist-info → faster_eth_utils-5.3.22.dist-info}/METADATA

@@ -1,34 +1,45 @@
 Metadata-Version: 2.4
 Name: faster-eth-utils
-Version: 4.1.7
-Summary: A fork of eth-utils: Common utility functions for python code that interacts with Ethereum, implemented in C
-Home-page: https://github.com/BobTheBuidler/eth-utils
+Version: 5.3.22
+Summary: A faster fork of eth-utils: Common utility functions for python code that interacts with Ethereum. Implemented in C
+Home-page: https://github.com/BobTheBuidler/faster-eth-utils
 Author: The Ethereum Foundation
 Author-email: snakecharmers@ethereum.org
 License: MIT
+Project-URL: Documentation, https://eth-utils.readthedocs.io/en/stable/
+Project-URL: Release Notes, https://github.com/BobTheBuidler/faster-eth-utils/releases
+Project-URL: Issues, https://github.com/BobTheBuidler/faster-eth-utils/issues
+Project-URL: Source - Precompiled (.py), https://github.com/BobTheBuidler/faster-eth-utils/tree/master/faster_eth_utils
+Project-URL: Source - Compiled (.c), https://github.com/BobTheBuidler/faster-eth-utils/tree/master/build
+Project-URL: Benchmarks, https://github.com/BobTheBuidler/faster-eth-utils/tree/master/benchmarks
+Project-URL: Benchmarks - Results, https://github.com/BobTheBuidler/faster-eth-utils/tree/master/benchmarks/results
+Project-URL: Original, https://github.com/ethereum/eth-utils
 Keywords: ethereum
 Classifier: Intended Audience :: Developers
-Classifier: License :: OSI Approved :: MIT License
 Classifier: Natural Language :: English
 Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.8
-Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
 Classifier: Programming Language :: Python :: Implementation :: CPython
-Requires-Python: >=3.8, <4
+Requires-Python: >=3.10, <4
 Description-Content-Type: text/markdown
 License-File: LICENSE
+Requires-Dist: cchecksum==0.3.9
 Requires-Dist: eth-hash>=0.3.1
-Requires-Dist: eth-typing>=3.0.0
+Requires-Dist: eth-typing==5.2.1
+Requires-Dist: eth-utils==5.3.1
 Requires-Dist: toolz>0.8.2; implementation_name == "pypy"
 Requires-Dist: cytoolz>=0.10.1; implementation_name == "cpython"
+Requires-Dist: pydantic<3,>=2.0.0
 Provides-Extra: dev
 Requires-Dist: build>=0.9.0; extra == "dev"
-Requires-Dist: bumpversion>=0.5.3; extra == "dev"
+Requires-Dist: bump_my_version>=0.19.0; extra == "dev"
 Requires-Dist: eth-hash[pycryptodome]; extra == "dev"
 Requires-Dist: ipython; extra == "dev"
+Requires-Dist: mypy[mypyc]<1.20,>=1.14.1; extra == "dev"
 Requires-Dist: pre-commit>=3.4.0; extra == "dev"
 Requires-Dist: tox>=4.0.0; extra == "dev"
 Requires-Dist: twine; extra == "dev"
@@ -36,21 +47,31 @@ Requires-Dist: wheel; extra == "dev"
 Requires-Dist: sphinx>=6.0.0; extra == "dev"
 Requires-Dist: sphinx-autobuild>=2021.3.14; extra == "dev"
 Requires-Dist: sphinx_rtd_theme>=1.0.0; extra == "dev"
-Requires-Dist: towncrier<22,>=21; extra == "dev"
+Requires-Dist: towncrier<26,>=24; extra == "dev"
 Requires-Dist: hypothesis>=4.43.0; extra == "dev"
-Requires-Dist: mypy==1.5.1; extra == "dev"
-Requires-Dist: pytest>=7.0.0; extra == "dev"
+Requires-Dist: mypy[mypyc]<1.20,>=1.14.1; extra == "dev"
 Requires-Dist: pytest-xdist>=2.4.0; extra == "dev"
+Requires-Dist: pytest>=7.0.0; extra == "dev"
 Provides-Extra: docs
 Requires-Dist: sphinx>=6.0.0; extra == "docs"
 Requires-Dist: sphinx-autobuild>=2021.3.14; extra == "docs"
 Requires-Dist: sphinx_rtd_theme>=1.0.0; extra == "docs"
-Requires-Dist: towncrier<22,>=21; extra == "docs"
+Requires-Dist: towncrier<26,>=24; extra == "docs"
 Provides-Extra: test
 Requires-Dist: hypothesis>=4.43.0; extra == "test"
-Requires-Dist: mypy==1.5.1; extra == "test"
-Requires-Dist: pytest>=7.0.0; extra == "test"
+Requires-Dist: mypy[mypyc]<1.20,>=1.14.1; extra == "test"
 Requires-Dist: pytest-xdist>=2.4.0; extra == "test"
+Requires-Dist: pytest>=7.0.0; extra == "test"
+Provides-Extra: codspeed
+Requires-Dist: pytest-codspeed<4.3,>=4.2; extra == "codspeed"
+Requires-Dist: pytest-test-groups; extra == "codspeed"
+Requires-Dist: pytest>=7.0.0; extra == "codspeed"
+Provides-Extra: benchmark
+Requires-Dist: eth-utils==5.3.1; extra == "benchmark"
+Requires-Dist: pytest-benchmark<5.3,>=5.2; extra == "benchmark"
+Requires-Dist: pytest-codspeed<4.3,>=4.2; extra == "benchmark"
+Requires-Dist: pytest-test-groups; extra == "benchmark"
+Requires-Dist: pytest>=7.0.0; extra == "benchmark"
 Dynamic: author
 Dynamic: author-email
 Dynamic: classifier
@@ -60,11 +81,30 @@ Dynamic: home-page
 Dynamic: keywords
 Dynamic: license
 Dynamic: license-file
+Dynamic: project-url
 Dynamic: provides-extra
 Dynamic: requires-dist
 Dynamic: requires-python
 Dynamic: summary
 
+### I forked eth-utils and compiled it to C. It does the same stuff, now faster
+
+[![PyPI](https://img.shields.io/pypi/v/faster-eth-utils.svg?logo=Python&logoColor=white)](https://pypi.org/project/faster-eth-utils)
+[![Monthly Downloads](https://img.shields.io/pypi/dm/faster-eth-utils)](https://pypistats.org/packages/faster-eth-utils)
+[![Codspeed.io Status](https://img.shields.io/endpoint?url=https://codspeed.io/badge.json)](https://codspeed.io/BobTheBuidler/faster-eth-utils)
+
+##### This fork will be kept up-to-date with [eth-utils](https://github.com/ethereum/eth-utils). I will pull updates as they are released and push new [faster-eth-utils](https://github.com/BobTheBuidler/faster-eth-utils) releases to [PyPI](https://pypi.org/project/faster-eth-utils/).
+
+##### Starting in [v5.3.11](https://github.com/BobTheBuidler/faster-eth-utils/releases/tag/v5.3.11), all `faster-eth-utils` Exception classes inherit from the matching Exception class in `eth-utils`, so porting to `faster-eth-utils` does not require any change to your existing exception handlers. All existing exception handling in your codebase will continue to work as it did when originaly implemented.
+
+##### We benchmark `faster-eth-utils` against the original `eth-utils` for your convenience. [See results](https://github.com/BobTheBuidler/faster-eth-utils/tree/master/benchmarks/results).
+
+##### You can find the compiled C code and header files in the [build](https://github.com/BobTheBuidler/eth-utils/tree/master/build) directory.
+
+###### You may also be interested in: [faster-web3.py](https://github.com/BobTheBuidler/faster-web3.py/), [faster-eth-abi](https://github.com/BobTheBuidler/faster-eth-abi/), and [faster-hexbytes](https://github.com/BobTheBuidler/faster-hexbytes/)
+
+##### The original eth-utils readme is below:
+
 # Ethereum Utilities
 
 [![Join the conversation on Discord](https://img.shields.io/discord/809793915578089484?color=blue&label=chat&logo=discord&logoColor=white)](https://discord.gg/GHryRvPB84)
@@ -75,9 +115,11 @@ Dynamic: summary
 
 Common utility functions for python code that interacts with Ethereum
 
-Read more in the [documentation on ReadTheDocs](https://eth-utils.readthedocs.io/). [View the change log](https://eth-utils.readthedocs.io/en/latest/release_notes.html).
+Read the [documentation](https://eth-utils.readthedocs.io/).
+
+View the [change log](https://eth-utils.readthedocs.io/en/latest/release_notes.html).
 
-## Quickstart
+## Installation
 
 ```sh
 python -m pip install eth-utils