ethspecify 0.1.0__py3-none-any.whl

ethspecify/cli.py

@@ -0,0 +1,34 @@
+import argparse
+import os
+
+from .core import grep, replace_spec_tags  # if you split functionality into core.py
+
+def main():
+    parser = argparse.ArgumentParser(
+        description="Process files containing <spec> tags."
+    )
+    parser.add_argument(
+        "--path",
+        type=str,
+        help="Directory to search for files containing <spec> tags",
+        default=".",
+    )
+    parser.add_argument(
+        "--exclude",
+        action="append",
+        help="Exclude paths matching this regex",
+        default=[],
+    )
+    args = parser.parse_args()
+
+    project_dir = os.path.abspath(os.path.expanduser(args.path))
+    if not os.path.isdir(project_dir):
+        print(f"Error: The directory '{project_dir}' does not exist.")
+        exit(1)
+
+    for f in grep(project_dir, r"<spec\b.*?>", args.exclude):
+        print(f"Processing file: {f}")
+        replace_spec_tags(f)
+
+if __name__ == "__main__":
+    main()

ethspecify/core.py

@@ -0,0 +1,325 @@
+import difflib
+import functools
+import hashlib
+import io
+import os
+import re
+import requests
+import textwrap
+import tokenize
+
+
+def strip_comments(code):
+    # Split the original code into lines so we can decide which to keep or skip
+    code_lines = code.splitlines(True)  # Keep line endings in each element
+
+    # Dictionary: line_index -> list of (column, token_string)
+    non_comment_tokens = {}
+
+    # Tokenize the entire code
+    tokens = tokenize.generate_tokens(io.StringIO(code).readline)
+    for ttype, tstring, (srow, scol), _, _ in tokens:
+        # Skip comments and pure newlines
+        if ttype == tokenize.COMMENT:
+            continue
+        if ttype in (tokenize.NEWLINE, tokenize.NL):
+            continue
+        # Store all other tokens, adjusting line index to be zero-based
+        non_comment_tokens.setdefault(srow - 1, []).append((scol, tstring))
+
+    final_lines = []
+    # Reconstruct or skip lines
+    for i, original_line in enumerate(code_lines):
+        # If the line has no non-comment tokens
+        if i not in non_comment_tokens:
+            # Check whether the original line is truly blank (just whitespace)
+            if original_line.strip():
+                # The line wasn't empty => it was a comment-only line, so skip it
+                continue
+            else:
+                # A truly empty/blank line => keep it
+                final_lines.append("")
+        else:
+            # Reconstruct this line from the stored tokens (preserving indentation/spaces)
+            tokens_for_line = sorted(non_comment_tokens[i], key=lambda x: x[0])
+            line_str = ""
+            last_col = 0
+            for col, token_str in tokens_for_line:
+                # Insert spaces if there's a gap
+                if col > last_col:
+                    line_str += " " * (col - last_col)
+                line_str += token_str
+                last_col = col + len(token_str)
+            # Strip trailing whitespace at the end of the line
+            final_lines.append(line_str.rstrip())
+
+    return "\n".join(final_lines)
+
+
+def grep(root_directory, search_pattern, excludes=[]):
+    matched_files = []
+    regex = re.compile(search_pattern)
+    exclude_patterns = [re.compile(pattern) for pattern in excludes]
+    for dirpath, _, filenames in os.walk(root_directory):
+        for filename in filenames:
+            file_path = os.path.join(dirpath, filename)
+            if any(pattern.search(file_path) for pattern in exclude_patterns):
+                continue
+            try:
+                with open(file_path, "r", encoding="utf-8") as file:
+                    if any(regex.search(line) for line in file):
+                        matched_files.append(file_path)
+            except (UnicodeDecodeError, IOError):
+                continue
+    return matched_files
+
+
+def diff(a_name, a_content, b_name, b_content):
+    diff = difflib.unified_diff(
+        a_content.splitlines(), b_content.splitlines(),
+        fromfile=a_name, tofile=b_name, lineterm=""
+    )
+    return "\n".join(diff)
+
+
+@functools.lru_cache()
+def get_links():
+    url = f"https://raw.githubusercontent.com/jtraglia/ethspecify/main/links.json"
+    response = requests.get(url)
+    response.raise_for_status()
+    return response.json()
+
+
+@functools.lru_cache()
+def get_pyspec():
+    url = f"https://raw.githubusercontent.com/jtraglia/ethspecify/main/pyspec.json"
+    response = requests.get(url)
+    response.raise_for_status()
+    return response.json()
+
+
+def get_previous_forks(fork):
+    pyspec = get_pyspec()
+    config_vars = pyspec["mainnet"][fork]["config_vars"]
+    previous_forks = ["phase0"]
+    for key in config_vars.keys():
+        if key.endswith("_FORK_VERSION"):
+            if key != f"{fork.upper()}_FORK_VERSION":
+                if key != "GENESIS_FORK_VERSION":
+                    f = key.split("_")[0].lower()
+                    previous_forks.append(f)
+    return list(reversed(previous_forks))
+
+
+def get_spec(attributes, preset, fork):
+    pyspec = get_pyspec()
+    spec = None
+    if "function" in attributes or "fn" in attributes:
+        if "function" in attributes and "fn" in attributes:
+            raise Exception(f"cannot contain 'function' and 'fn'")
+        if "function" in attributes:
+            function_name = attributes["function"]
+        else:
+            function_name = attributes["fn"]
+
+        spec = pyspec[preset][fork]["functions"][function_name]
+        spec_lines = spec.split("\n")
+        start, end = None, None
+
+        try:
+            vars = attributes["lines"].split("-")
+            if len(vars) == 1:
+                start = min(len(spec_lines), max(1, int(vars[0])))
+                end = start
+            elif len(vars) == 2:
+                start = min(len(spec_lines), max(1, int(vars[0])))
+                end = max(1, min(len(spec_lines), int(vars[1])))
+            else:
+                raise Exception(f"Invalid lines range for {function_name}: {attributes['lines']}")
+        except KeyError:
+            pass
+
+        if start or end:
+            start = start or 1
+            if start > end:
+                raise Exception(f"Invalid lines range for {function_name}: ({start}, {end})")
+            # Subtract one because line numbers are one-indexed
+            spec = "\n".join(spec_lines[start-1:end])
+            spec = textwrap.dedent(spec)
+
+    elif "constant_var" in attributes:
+        if spec is not None:
+            raise Exception(f"Tag can only specify one spec item")
+        info = pyspec[preset][fork]["constant_vars"][attributes["constant_var"]]
+        spec = (
+            attributes["constant_var"]
+            + (": " + info[0] if info[0] is not None else "")
+            + " = "
+            + info[1]
+        )
+    elif "preset_var" in attributes:
+        if spec is not None:
+            raise Exception(f"Tag can only specify one spec item")
+        info = pyspec[preset][fork]["preset_vars"][attributes["preset_var"]]
+        spec = (
+            attributes["preset_var"]
+            + (": " + info[0] if info[0] is not None else "")
+            + " = "
+            + info[1]
+        )
+    elif "config_var" in attributes:
+        if spec is not None:
+            raise Exception(f"Tag can only specify one spec item")
+        info = pyspec[preset][fork]["config_vars"][attributes["config_var"]]
+        spec = (
+            attributes["config_var"]
+            + (": " + info[0] if info[0] is not None else "")
+            + " = "
+            + info[1]
+        )
+    elif "custom_type" in attributes:
+        if spec is not None:
+            raise Exception(f"Tag can only specify one spec item")
+        spec = (
+            attributes["custom_type"]
+            + " = "
+            + pyspec[preset][fork]["custom_types"][attributes["custom_type"]]
+        )
+    elif "ssz_object" in attributes:
+        if spec is not None:
+            raise Exception(f"Tag can only specify one spec item")
+        spec = pyspec[preset][fork]["ssz_objects"][attributes["ssz_object"]]
+    elif "dataclass" in attributes:
+        if spec is not None:
+            raise Exception(f"Tag can only specify one spec item")
+        spec = pyspec[preset][fork]["dataclasses"][attributes["dataclass"]].replace("@dataclass\n", "")
+    else:
+        raise Exception("invalid spec tag")
+    return spec
+
+
+def parse_common_attributes(attributes):
+    try:
+        preset = attributes["preset"]
+    except KeyError:
+        preset = "mainnet"
+
+    try:
+        fork = attributes["fork"]
+    except KeyError:
+        raise Exception(f"Missing fork attribute")
+
+    try:
+        style = attributes["style"]
+    except KeyError:
+        style = "hash"
+
+    return preset, fork, style
+
+def get_spec_item(attributes):
+    preset, fork, style = parse_common_attributes(attributes)
+    spec = get_spec(attributes, preset, fork)
+
+    if style == "full" or style == "hash":
+        return spec
+    elif style == "diff":
+        previous_forks = get_previous_forks(fork)
+
+        previous_fork = None
+        previous_spec = None
+        for i, _ in enumerate(previous_forks):
+            previous_fork = previous_forks[i]
+            previous_spec = get_spec(attributes, preset, previous_fork)
+            if previous_spec != "phase0":
+                try:
+                    previous_previous_fork = previous_forks[i+1]
+                    previous_previous_spec = get_spec(attributes, preset, previous_previous_fork)
+                    if previous_previous_spec == previous_spec:
+                        continue
+                except KeyError:
+                    pass
+                except IndexError:
+                    pass
+            if previous_spec != spec:
+                break
+            if previous_spec == "phase0":
+                raise Exception("there is no previous spec for this")
+        return diff(previous_fork, strip_comments(previous_spec), fork, strip_comments(spec))
+    if style == "link":
+        if "function" in attributes or "fn" in attributes:
+            if "function" in attributes and "fn" in attributes:
+                raise Exception(f"cannot contain 'function' and 'fn'")
+            if "function" in attributes:
+                function_name = attributes["function"]
+            else:
+                function_name = attributes["fn"]
+            for key, value in get_links().items():
+                if fork in key and key.endswith(function_name):
+                    return value
+            return "Could not find link"
+        else:
+            return "Not available for this type of spec"
+    else:
+        raise Exception("invalid style type")
+
+
+def extract_attributes(tag):
+    attr_pattern = re.compile(r'(\w+)="(.*?)"')
+    return dict(attr_pattern.findall(tag))
+
+
+def replace_spec_tags(file_path):
+    with open(file_path, 'r') as file:
+        content = file.read()
+
+    # Define regex to match both long and self-closing <spec> tags
+    pattern = re.compile(r'(<spec\b[^>]*)(/?>)(?:([\s\S]*?)(</spec>))?', re.DOTALL)
+
+    def replacer(match):
+        # Extract the tag parts:
+        opening_tag_base = match.group(1)
+        tag_end = match.group(2)  # either ">" or "/>"
+
+        # Reconstruct the full opening tag for attribute extraction
+        opening_tag_full = opening_tag_base + tag_end
+
+        # Extract attributes from the full opening tag
+        attributes = extract_attributes(opening_tag_full)
+        print(f"spec tag: {attributes}")
+
+        # Parse common attributes to get preset, fork, style, etc.
+        preset, fork, style = parse_common_attributes(attributes)
+        spec = get_spec(attributes, preset, fork)
+
+        # Compute the first 8 characters of the SHA256 hash of the spec content.
+        hash_value = hashlib.sha256(spec.encode('utf-8')).hexdigest()[:8]
+
+        # Update the full opening tag (opening_tag_full) to include the hash attribute.
+        if 'hash="' in opening_tag_full:
+            updated_opening = re.sub(
+                r'(hash=")[^"]*(")',
+                lambda m: f'{m.group(1)}{hash_value}{m.group(2)}',
+                opening_tag_full
+            )
+        else:
+            updated_opening = opening_tag_full[:-1] + f' hash="{hash_value}">'
+
+        if style == "hash":
+            # For hash style, output a short self-closing tag with normalized spacing.
+            updated_tag = re.sub(r'\s*/?>\s*$', '', updated_opening) + " />"
+        else:
+            # For full/diff styles, output the long form with content.
+            spec_content = get_spec_item(attributes)
+            prefix = content[:match.start()].splitlines()[-1]
+            prefixed_spec = "\n".join(f"{prefix}{line}" if line.rstrip() else prefix.rstrip() for line in spec_content.rstrip().split("\n"))
+            long_opening = updated_opening.rstrip(">/") + ">"
+            updated_tag = f"{long_opening}\n{prefixed_spec}\n{prefix}</spec>"
+
+        return updated_tag
+
+    # Replace all matches in the content
+    updated_content = pattern.sub(replacer, content)
+
+    # Write the updated content back to the file
+    with open(file_path, 'w') as file:
+        file.write(updated_content)

ethspecify-0.1.0.dist-info/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Justin Traglia
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

ethspecify-0.1.0.dist-info/METADATA

@@ -0,0 +1,369 @@
+Metadata-Version: 2.2
+Name: ethspecify
+Version: 0.1.0
+Summary: A utility for processing Ethereum specification tags.
+Home-page: https://github.com/jtraglia/ethspecify
+Author: Justin Traglia
+Author-email: jtraglia@pm.me
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.6
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: requests==2.32.3
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
+
+# ethspecify
+
+A tool for referencing the Ethereum specifications in clients.
+
+The idea is that ethspecify will help developers keep track of when the specification changes. It
+will also help auditors verify that the client implementations match the specifications. Ideally,
+this is configured as a CI check which notifies client developers when the specification changes.
+When that happens, they can update the implementations appropriately.
+
+## Getting Started
+
+### Adding Spec Tags
+
+In your client, add an HTML tag like this:
+
+```
+/*
+ * <spec fn="is_fully_withdrawable_validator" fork="deneb">
+ */
+```
+
+This supports all languages and comment styles. It preserves indentation, so something like this
+would also work:
+
+```
+/// <spec fn="is_fully_withdrawable_validator" fork="deneb">
+```
+
+After the script is finished executing, a new `hash` field will exist in the tag. This tag is used
+to tell if the specification changed, without having to include the specification content.
+
+```
+/// <spec fn="is_fully_withdrawable_validator" fork="deneb" hash="e936da25" />
+```
+
+> [!NOTE]
+> Closing tags will be added automatically. For `style="hash"` tags, a self-closing tag is used for
+> conciseness. For `style="full"` and `style="diff"` tags, a paired closing tag must be used.
+
+### Installation
+
+#### Install with Pip
+
+```
+python3 -mpip install ethspecify
+```
+
+#### Manual Install
+
+First, clone the repository. You only need the latest commit.
+
+```
+git clone https://github.com/jtraglia/ethspecify.git --depth=1
+cd ethspecify
+```
+
+Next, build and install the utility.
+
+```
+python3 -mpip install .
+```
+
+Then, change directory to the source source directory and run `ethspecify`.
+
+```
+Projects/client$ ethspecify
+Processing file: /Users/user/Projects/client/src/file.ext
+spec tag: {'custom_type': 'Blob', 'fork': 'electra'}
+spec tag: {'dataclass': 'PayloadAttributes', 'fork': 'electra'}
+spec tag: {'ssz_object': 'ConsolidationRequest', 'fork': 'electra'}
+```
+
+### Specification Options
+
+#### Fork
+
+This attribute can be any of the [executable
+specifications](https://github.com/ethereum/consensus-specs/blob/e6bddd966214a19d2b97199bbe3c02577a22a8b4/Makefile#L3-L15)
+in the consensus-specs. At the time of writing, these are: phase0, altair, bellatrix, capella,
+deneb, electra, fulu, whisk, eip6800, and eip7732.
+
+#### Style
+
+This attribute can be used to change how the specification content is shown.
+
+##### `hash` (default)
+
+This style adds a hash of the specification content to the spec tag, without showing the content.
+
+```
+/*
+ * <spec fn="apply_deposit" fork="electra" hash="c723ce7b" />
+ */
+```
+
+> [!NOTE]
+> The hash is the first 8 characters of the specification content's SHA256 digest.
+
+##### `full`
+
+This style displays the whole content of this specification item, including comments.
+
+```
+/*
+ * <spec fn="is_fully_withdrawable_validator" fork="deneb" style="full">
+ * def is_fully_withdrawable_validator(validator: Validator, balance: Gwei, epoch: Epoch) -> bool:
+ *     """
+ *     Check if ``validator`` is fully withdrawable.
+ *     """
+ *     return (
+ *         has_eth1_withdrawal_credential(validator)
+ *         and validator.withdrawable_epoch <= epoch
+ *         and balance > 0
+ *     )
+ * </spec>
+ */
+```
+
+##### `link`
+
+> [!WARNING]
+> This feature is a work-in-progress.
+
+This style displays a GitHub link to the specification item.
+
+```
+/*
+ * <spec fn="apply_pending_deposit" fork="electra" style="link" hash="83ee9126">
+ * https://github.com/ethereum/consensus-specs/blob/dev/specs/electra/beacon-chain.md#new-apply_pending_deposit
+ * </spec>
+ */
+```
+
+##### `diff`
+
+This style displays a diff with the previous fork's version of the specification.
+
+```
+/*
+ * <spec ssz_object="BeaconState" fork="electra" style="diff">
+ * --- deneb
+ * +++ electra
+ * @@ -27,3 +27,12 @@
+ *      next_withdrawal_index: WithdrawalIndex
+ *      next_withdrawal_validator_index: ValidatorIndex
+ *      historical_summaries: List[HistoricalSummary, HISTORICAL_ROOTS_LIMIT]
+ * +    deposit_requests_start_index: uint64
+ * +    deposit_balance_to_consume: Gwei
+ * +    exit_balance_to_consume: Gwei
+ * +    earliest_exit_epoch: Epoch
+ * +    consolidation_balance_to_consume: Gwei
+ * +    earliest_consolidation_epoch: Epoch
+ * +    pending_deposits: List[PendingDeposit, PENDING_DEPOSITS_LIMIT]
+ * +    pending_partial_withdrawals: List[PendingPartialWithdrawal, PENDING_PARTIAL_WITHDRAWALS_LIMIT]
+ * +    pending_consolidations: List[PendingConsolidation, PENDING_CONSOLIDATIONS_LIMIT]
+ * </spec>
+ */
+```
+
+> [!NOTE]
+> Comments are stripped from the specifications when the `diff` style is used. We do this because
+> these complicate the diff; the "[Modified in Fork]" comments aren't valuable here.
+
+This can be used with any specification item, like functions too:
+
+```
+/*
+ * <spec fn="is_eligible_for_activation_queue" fork="electra" style="diff">
+ * --- phase0
+ * +++ electra
+ * @@ -4,5 +4,5 @@
+ *      """
+ *      return (
+ *          validator.activation_eligibility_epoch == FAR_FUTURE_EPOCH
+ * -        and validator.effective_balance == MAX_EFFECTIVE_BALANCE
+ * +        and validator.effective_balance >= MIN_ACTIVATION_BALANCE
+ *      )
+ * </spec>
+ */
+```
+
+### Supported Specification Items
+
+#### Constants
+
+These are items found in the `Constants` section of the specifications.
+
+```
+/*
+ * <spec constant_var="COMPOUNDING_WITHDRAWAL_PREFIX" fork="electra" style="full">
+ * COMPOUNDING_WITHDRAWAL_PREFIX: Bytes1 = '0x02'
+ * </spec>
+ */
+```
+
+#### Custom Types
+
+These are items found in the `Custom types` section of the specifications.
+
+```
+/*
+ * <spec custom_type="Blob" fork="electra" style="full">
+ * Blob = ByteVector[BYTES_PER_FIELD_ELEMENT * FIELD_ELEMENTS_PER_BLOB]
+ * </spec>
+ */
+```
+
+#### Preset Variables
+
+These are items found in the
+[`presets`](https://github.com/ethereum/consensus-specs/tree/dev/presets) directory.
+
+For preset variables, in addition to the `preset_var` attribute, you can specify a `preset`
+attribute: minimal or mainnet.
+
+```
+/*
+ * <spec preset="minimal" preset_var="PENDING_CONSOLIDATIONS_LIMIT" fork="electra" style="full">
+ * PENDING_CONSOLIDATIONS_LIMIT: uint64 = 64
+ * </spec>
+ *
+ * <spec preset="mainnet" preset_var="PENDING_CONSOLIDATIONS_LIMIT" fork="electra" style="full">
+ * PENDING_CONSOLIDATIONS_LIMIT: uint64 = 262144
+ * </spec>
+ */
+```
+
+It's not strictly necessary to specify the preset attribute. The default preset is mainnet.
+
+```
+/*
+ * <spec preset_var="FIELD_ELEMENTS_PER_BLOB" fork="electra" style="full">
+ * FIELD_ELEMENTS_PER_BLOB: uint64 = 4096
+ * </spec>
+ */
+```
+
+#### Config Variables
+
+These are items found in the
+[`configs`](https://github.com/ethereum/consensus-specs/tree/dev/presets) directory.
+
+```
+/*
+ * <spec config_var="MAX_REQUEST_BLOB_SIDECARS" fork="electra" style="full">
+ * MAX_REQUEST_BLOB_SIDECARS = 768
+ * </spec>
+ */
+```
+
+#### SSZ Objects
+
+These are items found in the `Containers` section of the specifications.
+
+```
+/*
+ * <spec ssz_object="ConsolidationRequest" fork="electra" style="full">
+ * class ConsolidationRequest(Container):
+ *     source_address: ExecutionAddress
+ *     source_pubkey: BLSPubkey
+ *     target_pubkey: BLSPubkey
+ * </spec>
+ */
+```
+
+#### Dataclasses
+
+These are classes with the `@dataclass` decorator.
+
+```
+/*
+ * <spec dataclass="PayloadAttributes" fork="electra" style="full">
+ * class PayloadAttributes(object):
+ *     timestamp: uint64
+ *     prev_randao: Bytes32
+ *     suggested_fee_recipient: ExecutionAddress
+ *     withdrawals: Sequence[Withdrawal]
+ *     parent_beacon_block_root: Root  # [New in Deneb:EIP4788]
+ * </spec>
+ */
+```
+
+#### Functions
+
+These are all the functions found in the specifications.
+
+For example, two versions of the same function:
+
+```
+/*
+ * <spec fn="is_fully_withdrawable_validator" fork="deneb" style="full">
+ * def is_fully_withdrawable_validator(validator: Validator, balance: Gwei, epoch: Epoch) -> bool:
+ *     """
+ *     Check if ``validator`` is fully withdrawable.
+ *     """
+ *     return (
+ *         has_eth1_withdrawal_credential(validator)
+ *         and validator.withdrawable_epoch <= epoch
+ *         and balance > 0
+ *     )
+ * </spec>
+ */
+```
+
+```
+/*
+ * <spec fn="is_fully_withdrawable_validator" fork="electra" style="full">
+ * def is_fully_withdrawable_validator(validator: Validator, balance: Gwei, epoch: Epoch) -> bool:
+ *     """
+ *     Check if ``validator`` is fully withdrawable.
+ *     """
+ *     return (
+ *         has_execution_withdrawal_credential(validator)  # [Modified in Electra:EIP7251]
+ *         and validator.withdrawable_epoch <= epoch
+ *         and balance > 0
+ *     )
+ * </spec>
+ */
+```
+
+With functions, it's possible to specify which line/lines should be displayed. For example:
+
+```
+/*
+ * <spec fn="is_fully_withdrawable_validator" fork="electra" style="full" lines="5-9">
+ * return (
+ *     has_execution_withdrawal_credential(validator)  # [Modified in Electra:EIP7251]
+ *     and validator.withdrawable_epoch <= epoch
+ *     and balance > 0
+ * )
+ * </spec>
+ */
+```
+
+Note that the content is automatically dedented.
+
+Or, to display just a single line, only specify a single number. For example:
+
+```
+/*
+ * <spec fn="is_fully_withdrawable_validator" fork="electra" style="full" lines="6">
+ * has_execution_withdrawal_credential(validator)  # [Modified in Electra:EIP7251]
+ * </spec>
+ */
+ ```

ethspecify-0.1.0.dist-info/RECORD

@@ -0,0 +1,9 @@
+ethspecify/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+ethspecify/cli.py,sha256=EFjH1ioHibDG1U-6XiozQ2aT2j-GyaWhUJJ-QMALrLc,925
+ethspecify/core.py,sha256=sxmTdXCQIpaAjebMG0NE-7mTf4m0NG_J9IjgGlmOTVk,12064
+ethspecify-0.1.0.dist-info/LICENSE,sha256=Awxsr73mm9YMBVhBYnzeI7bNdRd-bH6RDtO5ItG0DaM,1071
+ethspecify-0.1.0.dist-info/METADATA,sha256=-ot8oXPC7HfNHVD6_ZCcwn7oZJ6EHN5bJeQL9ERByDg,9965
+ethspecify-0.1.0.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
+ethspecify-0.1.0.dist-info/entry_points.txt,sha256=09viGkCg9J3h0c9BFRN-BKaJUEaIc4JyULNgBP5EL_g,51
+ethspecify-0.1.0.dist-info/top_level.txt,sha256=0klaMvlVyOkXW09fwZTijJpdybITEp2c9zQKV5v30VM,11
+ethspecify-0.1.0.dist-info/RECORD,,

ethspecify-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (75.8.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

ethspecify-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+ethspecify = ethspecify.cli:main

ethspecify-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+ethspecify