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

faster_eth_utils/network.py

@@ -1,12 +1,26 @@
-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,
+)
 
-from eth_typing import ChainId
+from eth_typing import (
+    ChainId,
+)
 
-from faster_eth_utils import ValidationError
+from faster_eth_utils.exceptions import (
+    ValidationError,
+)
+
+
+FASTER_ETH_UTILS_FOLDER: Final = Path(sys.modules["faster_eth_utils"].__file__).parent  # type: ignore [arg-type]
 
 
 @dataclass
@@ -17,15 +31,14 @@ class Network:
     symbol: ChainId
 
 
-def initialize_network_objects() -> List[Network]:
+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 +53,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

faster_eth_utils/pydantic.py

@@ -0,0 +1,99 @@
+from typing import (
+    Any,
+)
+
+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 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 super().model_json_schema(
+            by_alias=by_alias,
+            ref_template=ref_template,
+            schema_generator=schema_generator,
+            mode=mode,
+        )

faster_eth_utils/toolz.py

@@ -1,154 +1,84 @@
+from typing import Final
+
 try:
-    from cytoolz import (
-        accumulate,
-        assoc,
-        assoc_in,
-        comp,
-        complement,
-        compose,
-        concat,
-        concatv,
-        cons,
-        count,
-        countby,
-        curried,
-        curry,
-        dicttoolz,
-        diff,
-        dissoc,
-        do,
-        drop,
-        excepts,
-        filter,
-        first,
-        flip,
-        frequencies,
-        functoolz,
-        get,
-        get_in,
-        groupby,
-        identity,
-        interleave,
-        interpose,
-        isdistinct,
-        isiterable,
-        itemfilter,
-        itemmap,
-        iterate,
-        itertoolz,
-        join,
-        juxt,
-        keyfilter,
-        keymap,
-        last,
-        map,
-        mapcat,
-        memoize,
-        merge,
-        merge_sorted,
-        merge_with,
-        nth,
-        partial,
-        partition,
-        partition_all,
-        partitionby,
-        peek,
-        pipe,
-        pluck,
-        random_sample,
-        recipes,
-        reduce,
-        reduceby,
-        remove,
-        second,
-        sliding_window,
-        sorted,
-        tail,
-        take,
-        take_nth,
-        thread_first,
-        thread_last,
-        topk,
-        unique,
-        update_in,
-        utils,
-        valfilter,
-        valmap,
-    )
+    import cytoolz
+    cy = True
 except ImportError:
-    from toolz import (  # noqa: F401
-        accumulate,
-        assoc,
-        assoc_in,
-        comp,
-        complement,
-        compose,
-        concat,
-        concatv,
-        cons,
-        count,
-        countby,
-        curried,
-        curry,
-        dicttoolz,
-        diff,
-        dissoc,
-        do,
-        drop,
-        excepts,
-        filter,
-        first,
-        flip,
-        frequencies,
-        functoolz,
-        get,
-        get_in,
-        groupby,
-        identity,
-        interleave,
-        interpose,
-        isdistinct,
-        isiterable,
-        itemfilter,
-        itemmap,
-        iterate,
-        itertoolz,
-        join,
-        juxt,
-        keyfilter,
-        keymap,
-        last,
-        map,
-        mapcat,
-        memoize,
-        merge,
-        merge_sorted,
-        merge_with,
-        nth,
-        partial,
-        partition,
-        partition_all,
-        partitionby,
-        peek,
-        pipe,
-        pluck,
-        random_sample,
-        recipes,
-        reduce,
-        reduceby,
-        remove,
-        second,
-        sliding_window,
-        sorted,
-        tail,
-        take,
-        take_nth,
-        thread_first,
-        thread_last,
-        topk,
-        unique,
-        update_in,
-        utils,
-        valfilter,
-        valmap,
-    )
+    import toolz
+    cy = False
+
+
+accumulate: Final = cytoolz.accumulate if cy else toolz.accumulate
+assoc: Final = cytoolz.assoc if cy else toolz.assoc
+assoc_in: Final = cytoolz.assoc_in if cy else toolz.assoc_in
+comp: Final = cytoolz.comp if cy else toolz.comp
+complement: Final = cytoolz.complement if cy else toolz.complement
+compose: Final = cytoolz.compose if cy else toolz.compose
+concat: Final = cytoolz.concat if cy else toolz.concat
+concatv: Final = cytoolz.concatv if cy else toolz.concatv
+cons: Final = cytoolz.cons if cy else toolz.cons
+count: Final = cytoolz.count if cy else toolz.count
+countby: Final = cytoolz.countby if cy else toolz.countby
+curried: Final = cytoolz.curried if cy else toolz.curried
+curry: Final = cytoolz.curry if cy else toolz.curry
+dicttoolz: Final = cytoolz.dicttoolz if cy else toolz.dicttoolz
+diff: Final = cytoolz.diff if cy else toolz.diff
+dissoc: Final = cytoolz.dissoc if cy else toolz.dissoc
+do: Final = cytoolz.do if cy else toolz.do
+drop: Final = cytoolz.drop if cy else toolz.drop
+excepts: Final = cytoolz.excepts if cy else toolz.excepts
+filter: Final = cytoolz.filter if cy else toolz.filter
+first: Final = cytoolz.first if cy else toolz.first
+flip: Final = cytoolz.flip if cy else toolz.flip
+frequencies: Final = cytoolz.frequencies if cy else toolz.frequencies
+functoolz: Final = cytoolz.functoolz if cy else toolz.functoolz
+get: Final = cytoolz.get if cy else toolz.get
+get_in: Final = cytoolz.get_in if cy else toolz.get_in
+groupby: Final = cytoolz.groupby if cy else toolz.groupby
+identity: Final = cytoolz.identity if cy else toolz.identity
+interleave: Final = cytoolz.interleave if cy else toolz.interleave
+interpose: Final = cytoolz.interpose if cy else toolz.interpose
+isdistinct: Final = cytoolz.isdistinct if cy else toolz.isdistinct
+isiterable: Final = cytoolz.isiterable if cy else toolz.isiterable
+itemfilter: Final = cytoolz.itemfilter if cy else toolz.itemfilter
+itemmap: Final = cytoolz.itemmap if cy else toolz.itemmap
+iterate: Final = cytoolz.iterate if cy else toolz.iterate
+itertoolz: Final = cytoolz.itertoolz if cy else toolz.itertoolz
+join: Final = cytoolz.join if cy else toolz.join
+juxt: Final = cytoolz.juxt if cy else toolz.juxt
+keyfilter: Final = cytoolz.keyfilter if cy else toolz.keyfilter
+keymap: Final = cytoolz.keymap if cy else toolz.keymap
+last: Final = cytoolz.last if cy else toolz.last
+map: Final = cytoolz.map if cy else toolz.map
+mapcat: Final = cytoolz.mapcat if cy else toolz.mapcat
+memoize: Final = cytoolz.memoize if cy else toolz.memoize
+merge: Final = cytoolz.merge if cy else toolz.merge
+merge_sorted: Final = cytoolz.merge_sorted if cy else toolz.merge_sorted
+merge_with: Final = cytoolz.merge_with if cy else toolz.merge_with
+nth: Final = cytoolz.nth if cy else toolz.nth
+partial: Final = cytoolz.partial if cy else toolz.partial
+partition: Final = cytoolz.partition if cy else toolz.partition
+partition_all: Final = cytoolz.partition_all if cy else toolz.partition_all
+partitionby: Final = cytoolz.partitionby if cy else toolz.partitionby
+peek: Final = cytoolz.peek if cy else toolz.peek
+pipe: Final = cytoolz.pipe if cy else toolz.pipe
+pluck: Final = cytoolz.pluck if cy else toolz.pluck
+random_sample: Final = cytoolz.random_sample if cy else toolz.random_sample
+recipes: Final = cytoolz.recipes if cy else toolz.recipes
+reduce: Final = cytoolz.reduce if cy else toolz.reduce
+reduceby: Final = cytoolz.reduceby if cy else toolz.reduceby
+remove: Final = cytoolz.remove if cy else toolz.remove
+second: Final = cytoolz.second if cy else toolz.second
+sliding_window: Final = cytoolz.sliding_window if cy else toolz.sliding_window
+sorted: Final = cytoolz.sorted if cy else toolz.sorted
+tail: Final = cytoolz.tail if cy else toolz.tail
+take: Final = cytoolz.take if cy else toolz.take
+take_nth: Final = cytoolz.take_nth if cy else toolz.take_nth
+thread_first: Final = cytoolz.thread_first if cy else toolz.thread_first
+thread_last: Final = cytoolz.thread_last if cy else toolz.thread_last
+topk: Final = cytoolz.topk if cy else toolz.topk
+unique: Final = cytoolz.unique if cy else toolz.unique
+update_in: Final = cytoolz.update_in if cy else toolz.update_in
+utils: Final = cytoolz.utils if cy else toolz.utils
+valfilter: Final = cytoolz.valfilter if cy else toolz.valfilter
+valmap: Final = cytoolz.valmap if cy else toolz.valmap

faster_eth_utils/types.py

@@ -1,52 +1,65 @@
 import collections.abc
 import numbers
-from typing import Any
+from typing import (
+    Any,
+    Final,
+    Literal,
+)
 
-bytes_types = (bytes, bytearray)
-integer_types = (int,)
-text_types = (str,)
-string_types = (bytes, str, bytearray)
+from typing import (
+    TypeGuard,
+)
 
+Mapping: Final = collections.abc.Mapping
+Sequence: Final = collections.abc.Sequence
 
-def is_integer(value: Any) -> bool:
-    return isinstance(value, integer_types) and not isinstance(value, bool)
+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_bytes(value: Any) -> bool:
+
+def is_integer(value: Any) -> TypeGuard[int]:
+    return isinstance(value, int) and not isinstance(value, bool)
+
+
+def is_bytes(value: Any) -> TypeGuard[bytes | bytearray]:
     return isinstance(value, bytes_types)
 
 
-def is_text(value: Any) -> bool:
-    return isinstance(value, text_types)
+def is_text(value: Any) -> TypeGuard[str]:
+    return isinstance(value, str)
 
 
-def is_string(value: Any) -> bool:
+def is_string(value: Any) -> TypeGuard[bytes | str | bytearray]:
     return isinstance(value, string_types)
 
 
-def is_boolean(value: Any) -> bool:
+def is_boolean(value: Any) -> TypeGuard[bool]:
     return isinstance(value, bool)
 
 
-def is_dict(obj: Any) -> bool:
-    return isinstance(obj, collections.abc.Mapping)
+def is_dict(obj: Any) -> TypeGuard[collections.abc.Mapping[Any, Any]]:
+    return isinstance(obj, dict) or isinstance(obj, Mapping)
 
 
-def is_list_like(obj: Any) -> bool:
-    return not is_string(obj) and isinstance(obj, collections.abc.Sequence)
+def is_list_like(obj: Any) -> TypeGuard[collections.abc.Sequence[Any]]:
+    return isinstance(obj, (list, tuple)) or not is_string(obj) and isinstance(obj, Sequence)
 
 
-def is_list(obj: Any) -> bool:
+def is_list(obj: Any) -> TypeGuard[list[Any]]:
     return isinstance(obj, list)
 
 
-def is_tuple(obj: Any) -> bool:
+def is_tuple(obj: Any) -> TypeGuard[tuple[Any, ...]]:
     return isinstance(obj, tuple)
 
 
-def is_null(obj: Any) -> bool:
+def is_null(obj: Any) -> TypeGuard[Literal[None]]:
     return obj is None
 
 
-def is_number(obj: Any) -> bool:
-    return isinstance(obj, numbers.Number)
+def is_number(obj: Any) -> TypeGuard[numbers.Number]:
+    return isinstance(obj, Number)

faster_eth_utils/typing/misc.py

@@ -1,4 +1,6 @@
-from typing import TypeVar
+from typing import (
+    TypeVar,
+)
 
 from eth_typing import (  # noqa: F401
     Address,