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

faster_eth_utils/pydantic.py

@@ -0,0 +1,101 @@
+from typing import (
+    Any,
+    Dict,
+    Type,
+)
+
+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):
+    """
+    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):
+    """
+    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,68 @@
 import collections.abc
 import numbers
-from typing import Any
+from typing import (
+    Any,
+    Final,
+    List,
+    Literal,
+    Tuple,
+    Union,
+)
 
-bytes_types = (bytes, bytearray)
-integer_types = (int,)
-text_types = (str,)
-string_types = (bytes, str, bytearray)
+from typing_extensions 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[Union[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[Union[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,

faster_eth_utils-5.3.19.dist-info/METADATA

@@ -0,0 +1,193 @@
+Metadata-Version: 2.4
+Name: faster-eth-utils
+Version: 5.3.19
+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/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: 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 :: Implementation :: CPython
+Requires-Python: >=3.8, <4
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: cchecksum==0.3.7.dev0
+Requires-Dist: eth-hash>=0.3.1
+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: bump_my_version>=0.19.0; extra == "dev"
+Requires-Dist: eth-hash[pycryptodome]; extra == "dev"
+Requires-Dist: ipython; extra == "dev"
+Requires-Dist: mypy<1.18.3,>=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"
+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<26,>=24; extra == "dev"
+Requires-Dist: hypothesis>=4.43.0; extra == "dev"
+Requires-Dist: mypy<1.18.3,>=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<26,>=24; extra == "docs"
+Provides-Extra: test
+Requires-Dist: hypothesis>=4.43.0; extra == "test"
+Requires-Dist: mypy<1.18.3,>=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
+Dynamic: description
+Dynamic: description-content-type
+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)
+[![Build Status](https://circleci.com/gh/ethereum/eth-utils.svg?style=shield)](https://circleci.com/gh/ethereum/eth-utils)
+[![PyPI version](https://badge.fury.io/py/eth-utils.svg)](https://badge.fury.io/py/eth-utils)
+[![Python versions](https://img.shields.io/pypi/pyversions/eth-utils.svg)](https://pypi.python.org/pypi/eth-utils)
+[![Docs build](https://readthedocs.org/projects/eth-utils/badge/?version=latest)](https://eth-utils.readthedocs.io/en/latest/?badge=latest)
+
+Common utility functions for python code that interacts with Ethereum
+
+Read the [documentation](https://eth-utils.readthedocs.io/).
+
+View the [change log](https://eth-utils.readthedocs.io/en/latest/release_notes.html).
+
+## Installation
+
+```sh
+python -m pip install eth-utils
+```
+
+## Developer Setup
+
+If you would like to hack on eth-utils, please check out the [Snake Charmers
+Tactical Manual](https://github.com/ethereum/snake-charmers-tactical-manual)
+for information on how we do:
+
+- Testing
+- Pull Requests
+- Documentation
+
+We use [pre-commit](https://pre-commit.com/) to maintain consistent code style. Once
+installed, it will run automatically with every commit. You can also run it manually
+with `make lint`. If you need to make a commit that skips the `pre-commit` checks, you
+can do so with `git commit --no-verify`.
+
+### Development Environment Setup
+
+You can set up your dev environment with:
+
+```sh
+git clone git@github.com:ethereum/eth-utils.git
+cd eth-utils
+virtualenv -p python3 venv
+. venv/bin/activate
+python -m pip install -e ".[dev]"
+pre-commit install
+```
+
+### Update Networks
+
+The list of networks resides in the JSON file under eth_utils/\_\_json/eth_networks.json.
+This file is used to initialize Networks, which can be used to obtain network
+information with a chain ID.
+
+Run the script to update the JSON file with the response from the remote list.
+
+```sh
+python update_networks.py
+```
+
+If there are new networks they will appear in the JSON file. After checking the updates,
+open a PR to make them available in a new release.
+
+### Release setup
+
+To release a new version:
+
+```sh
+make release bump=$$VERSION_PART_TO_BUMP$$
+```
+
+#### How to bumpversion
+
+The version format for this repo is `{major}.{minor}.{patch}` for stable, and
+`{major}.{minor}.{patch}-{stage}.{devnum}` for unstable (`stage` can be alpha or beta).
+
+To issue the next version in line, specify which part to bump,
+like `make release bump=minor` or `make release bump=devnum`. This is typically done from the
+main branch, except when releasing a beta (in which case the beta is released from main,
+and the previous stable branch is released from said branch).
+
+If you are in a beta version, `make release bump=stage` will switch to a stable.
+
+To issue an unstable version when the current version is stable, specify the
+new version explicitly, like `make release bump="--new-version 4.0.0-alpha.1 devnum"`