ethspecify 0.2.1__tar.gz → 0.2.2__tar.gz

{ethspecify-0.2.1 → ethspecify-0.2.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ethspecify
-Version: 0.2.1
+Version: 0.2.2
 Summary: A utility for processing Ethereum specification tags.
 Home-page: https://github.com/jtraglia/ethspecify
 Author: Justin Traglia

ethspecify-0.2.2/ethspecify/cli.py

@@ -0,0 +1,168 @@
+import argparse
+import json
+import os
+import sys
+
+from .core import grep, replace_spec_tags, get_pyspec, get_latest_fork, get_spec_item_history
+
+
+def process(args):
+    """Process all spec tags."""
+    project_dir = os.path.abspath(os.path.expanduser(args.path))
+    if not os.path.isdir(project_dir):
+        print(f"Error: The directory {repr(project_dir)} does not exist.")
+        return 1
+
+    for f in grep(project_dir, r"<spec\b.*?>", args.exclude):
+        print(f"Processing file: {f}")
+        replace_spec_tags(f)
+
+    return 0
+
+
+def list_tags(args):
+    """List all available tags with their fork history."""
+    preset = getattr(args, 'preset', 'mainnet')
+    return _list_tags_with_history(args, preset)
+
+
+def _list_tags_with_history(args, preset):
+    """List all tags with their fork history."""
+    try:
+        history = get_spec_item_history(preset)
+    except ValueError as e:
+        print(f"Error: {e}")
+        return 1
+
+    if args.format == "json":
+        result = {
+            "preset": preset,
+            "mode": "history",
+            "history": history
+        }
+        print(json.dumps(result, indent=2))
+    else:
+        print(f"Available tags across all forks ({preset} preset):")
+
+        def _print_items_with_history(category_name, items_dict, spec_attr):
+            """Helper to print items with their fork history."""
+            if not items_dict:
+                return
+            print(f"\n{category_name}:")
+            for item_name in sorted(items_dict.keys()):
+                if args.search is None or args.search.lower() in item_name.lower():
+                    forks = items_dict[item_name]
+                    fork_list = ", ".join(forks)
+                    print(f"  <spec {spec_attr}=\"{item_name}\" /> ({fork_list})")
+
+        _print_items_with_history("Functions", history['functions'], "fn")
+        _print_items_with_history("Constants", history['constant_vars'], "constant_var")
+        _print_items_with_history("Custom Types", history['custom_types'], "custom_type")
+        _print_items_with_history("SSZ Objects", history['ssz_objects'], "ssz_object")
+        _print_items_with_history("Dataclasses", history['dataclasses'], "dataclass")
+        _print_items_with_history("Preset Variables", history['preset_vars'], "preset_var")
+        _print_items_with_history("Config Variables", history['config_vars'], "config_var")
+
+    return 0
+
+
+
+
+def list_forks(args):
+    """List all available forks."""
+    pyspec = get_pyspec()
+    preset = args.preset
+
+    if preset not in pyspec:
+        print(f"Error: Preset '{preset}' not found.")
+        print(f"Available presets: {', '.join(pyspec.keys())}")
+        return 1
+
+    # Filter out EIP forks
+    forks = sorted(
+        [fork for fork in pyspec[preset].keys() if not fork.startswith("eip")],
+        key=lambda x: (x != "phase0", x)
+    )
+
+    if args.format == "json":
+        result = {
+            "preset": preset,
+            "forks": forks
+        }
+        print(json.dumps(result, indent=2))
+    else:
+        print(f"Available forks for {preset} preset:")
+        for fork in forks:
+            print(f"  {fork}")
+
+    return 0
+
+
+def main():
+    parser = argparse.ArgumentParser(
+        description="Process files containing <spec> tags."
+    )
+
+    # Create subparsers for different commands
+    subparsers = parser.add_subparsers(dest="command", help="Command to execute")
+
+    # Parser for 'process' command
+    process_parser = subparsers.add_parser("process", help="Process spec tags in files")
+    process_parser.set_defaults(func=process)
+    process_parser.add_argument(
+        "--path",
+        type=str,
+        help="Directory to search for files containing <spec> tags",
+        default=".",
+    )
+    process_parser.add_argument(
+        "--exclude",
+        action="append",
+        help="Exclude paths matching this regex",
+        default=[],
+    )
+
+    # Parser for 'list-tags' command
+    list_tags_parser = subparsers.add_parser("list-tags", help="List available specification tags with fork history")
+    list_tags_parser.set_defaults(func=list_tags)
+    list_tags_parser.add_argument(
+        "--format",
+        type=str,
+        choices=["text", "json"],
+        default="text",
+        help="Output format (text or json)",
+    )
+    list_tags_parser.add_argument(
+        "--search",
+        type=str,
+        help="Filter tags by search term",
+        default=None,
+    )
+
+    # Parser for 'list-forks' command
+    list_forks_parser = subparsers.add_parser("list-forks", help="List available forks")
+    list_forks_parser.set_defaults(func=list_forks)
+    list_forks_parser.add_argument(
+        "--preset",
+        type=str,
+        help="Preset to use (mainnet or minimal)",
+        default="mainnet",
+    )
+    list_forks_parser.add_argument(
+        "--format",
+        type=str,
+        choices=["text", "json"],
+        default="text",
+        help="Output format (text or json)",
+    )
+
+    # Default to 'process' if no args are provided
+    if len(sys.argv) == 1:
+        sys.argv.insert(1, "process")
+
+    args = parser.parse_args()
+    exit(args.func(args))
+
+
+if __name__ == "__main__":
+    main()

{ethspecify-0.2.1 → ethspecify-0.2.2}/ethspecify/core.py

@@ -107,7 +107,9 @@ def get_previous_forks(fork, version="nightly"):
             if key != f"{fork.upper()}_FORK_VERSION":
                 if key != "GENESIS_FORK_VERSION":
                     f = key.split("_")[0].lower()
-                    previous_forks.append(f)
+                    # Skip EIP forks
+                    if not f.startswith("eip"):
+                        previous_forks.append(f)
     return list(reversed(previous_forks))
 
 
@@ -201,12 +203,150 @@ def get_latest_fork(version="nightly"):
     """A helper function to get the latest non-eip fork."""
     pyspec = get_pyspec(version)
     forks = sorted(
-        pyspec["mainnet"].keys(),
-        key=lambda x: (x != "phase0", x.startswith("eip"), x)
+        [fork for fork in pyspec["mainnet"].keys() if not fork.startswith("eip")],
+        key=lambda x: (x != "phase0", x)
     )
-    for fork in reversed(forks):
-        if not fork.startswith("eip"):
-            return fork
+    return forks[-1] if forks else "phase0"
+
+
+def get_spec_item_changes(fork, preset="mainnet", version="nightly"):
+    """
+    Compare spec items in the given fork with previous forks to detect changes.
+    Returns dict with categories containing items marked as (new) or (modified).
+    """
+    pyspec = get_pyspec(version)
+    if fork not in pyspec[preset]:
+        raise ValueError(f"Fork '{fork}' not found in {preset} preset")
+
+    current_fork_data = pyspec[preset][fork]
+    previous_forks = get_previous_forks(fork, version)
+
+    changes = {
+        'functions': {},
+        'constant_vars': {},
+        'custom_types': {},
+        'ssz_objects': {},
+        'dataclasses': {},
+        'preset_vars': {},
+        'config_vars': {},
+    }
+
+    # Check each category of spec items
+    for category in changes.keys():
+        if category not in current_fork_data:
+            continue
+
+        for item_name, item_content in current_fork_data[category].items():
+            status = _get_item_status(item_name, item_content, category, previous_forks, pyspec, preset)
+            if status:
+                changes[category][item_name] = status
+
+    return changes
+
+
+def _get_item_status(item_name, current_content, category, previous_forks, pyspec, preset):
+    """
+    Determine if an item is new or modified compared to previous forks.
+    Returns 'new', 'modified', or None if unchanged.
+    """
+    # Check if item exists in any previous fork
+    found_in_previous = False
+    previous_content = None
+
+    for prev_fork in previous_forks:
+        if (prev_fork in pyspec[preset] and
+            category in pyspec[preset][prev_fork] and
+            item_name in pyspec[preset][prev_fork][category]):
+
+            found_in_previous = True
+            prev_content = pyspec[preset][prev_fork][category][item_name]
+
+            # Compare content with immediate previous version
+            if prev_content != current_content:
+                return "modified"
+            else:
+                # Found unchanged version, so this is not new or modified
+                return None
+
+    # If not found in any previous fork, it's new
+    if not found_in_previous:
+        return "new"
+
+    return None
+
+
+def get_spec_item_history(preset="mainnet", version="nightly"):
+    """
+    Get the complete history of all spec items across all forks.
+    Returns dict with categories containing items and their fork history.
+    """
+    pyspec = get_pyspec(version)
+    if preset not in pyspec:
+        raise ValueError(f"Preset '{preset}' not found")
+
+    # Get all forks in chronological order, excluding EIP forks
+    all_forks = sorted(
+        [fork for fork in pyspec[preset].keys() if not fork.startswith("eip")],
+        key=lambda x: (x != "phase0", x)
+    )
+
+    # Track all unique items across all forks
+    all_items = {
+        'functions': set(),
+        'constant_vars': set(),
+        'custom_types': set(),
+        'ssz_objects': set(),
+        'dataclasses': set(),
+        'preset_vars': set(),
+        'config_vars': set(),
+    }
+
+    # Collect all item names
+    for fork in all_forks:
+        if fork not in pyspec[preset]:
+            continue
+        fork_data = pyspec[preset][fork]
+        for category in all_items.keys():
+            if category in fork_data:
+                all_items[category].update(fork_data[category].keys())
+
+    # Build history for each item
+    history = {}
+    for category in all_items.keys():
+        history[category] = {}
+        for item_name in all_items[category]:
+            item_history = _trace_item_history(item_name, category, all_forks, pyspec, preset)
+            if item_history:
+                history[category][item_name] = item_history
+
+    return history
+
+
+def _trace_item_history(item_name, category, all_forks, pyspec, preset):
+    """
+    Trace the history of a specific item across all forks.
+    Returns a list of forks where the item was introduced or modified.
+    """
+    history_forks = []
+    previous_content = None
+
+    for fork in all_forks:
+        if (fork in pyspec[preset] and
+            category in pyspec[preset][fork] and
+            item_name in pyspec[preset][fork][category]):
+
+            current_content = pyspec[preset][fork][category][item_name]
+
+            if previous_content is None:
+                # First appearance
+                history_forks.append(fork)
+            elif current_content != previous_content:
+                # Content changed
+                history_forks.append(fork)
+
+            previous_content = current_content
+
+    return history_forks
 
 def parse_common_attributes(attributes):
     try:

{ethspecify-0.2.1 → ethspecify-0.2.2}/ethspecify.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ethspecify
-Version: 0.2.1
+Version: 0.2.2
 Summary: A utility for processing Ethereum specification tags.
 Home-page: https://github.com/jtraglia/ethspecify
 Author: Justin Traglia

{ethspecify-0.2.1 → ethspecify-0.2.2}/setup.py

@@ -8,7 +8,7 @@ long_description = (this_directory / "README.md").read_text(encoding="utf-8")
 
 setup(
     name="ethspecify",
-    version="0.2.1",
+    version="0.2.2",
     description="A utility for processing Ethereum specification tags.",
     long_description=long_description,
     long_description_content_type="text/markdown",

ethspecify-0.2.1/ethspecify/cli.py

@@ -1,205 +0,0 @@
-import argparse
-import json
-import os
-import sys
-
-from .core import grep, replace_spec_tags, get_pyspec, get_latest_fork
-
-
-def process(args):
-    """Process all spec tags."""
-    project_dir = os.path.abspath(os.path.expanduser(args.path))
-    if not os.path.isdir(project_dir):
-        print(f"Error: The directory {repr(project_dir)} does not exist.")
-        return 1
-
-    for f in grep(project_dir, r"<spec\b.*?>", args.exclude):
-        print(f"Processing file: {f}")
-        replace_spec_tags(f)
-
-    return 0
-
-
-def list_tags(args):
-    """List all available tags for a specific fork and preset."""
-    # Get the specification data
-    pyspec = get_pyspec()
-    fork = args.fork
-    preset = args.preset
-
-    # Validate that the fork exists
-    if fork not in pyspec[preset]:
-        print(f"Error: Fork '{fork}' not found in {preset} preset")
-        available_forks = list(pyspec[preset].keys())
-        print(f"Available forks: {', '.join(available_forks)}")
-        return 1
-
-    # Format output based on requested format
-    if args.format == "json":
-        result = {
-            "fork": fork,
-            "preset": preset,
-            "tags": {
-                "functions": list(pyspec[preset][fork]['functions'].keys()),
-                "constant_vars": list(pyspec[preset][fork]['constant_vars'].keys()),
-                "custom_types": list(pyspec[preset][fork]['custom_types'].keys()),
-                "ssz_objects": list(pyspec[preset][fork]['ssz_objects'].keys()),
-                "dataclasses": list(pyspec[preset][fork]['dataclasses'].keys()),
-                "preset_vars": list(pyspec[preset][fork]['preset_vars'].keys()),
-                "config_vars": list(pyspec[preset][fork]['config_vars'].keys()),
-            }
-        }
-        print(json.dumps(result, indent=2))
-    else:
-        # Plain text output
-        print(f"Available tags for {fork} fork ({preset} preset):")
-        maybe_fork = f' fork="{fork}"' if fork != get_latest_fork() else ""
-
-        print("\nFunctions:")
-        for fn_name in sorted(pyspec[preset][fork]['functions'].keys()):
-            if args.search is None or args.search.lower() in fn_name.lower():
-                print(f"  <spec fn=\"{fn_name}\"{maybe_fork} />")
-
-        print("\nConstants:")
-        for const_name in sorted(pyspec[preset][fork]['constant_vars'].keys()):
-            if args.search is None or args.search.lower() in const_name.lower():
-                print(f"  <spec constant_var=\"{const_name}\"{maybe_fork} />")
-
-        print("\nCustom Types:")
-        for type_name in sorted(pyspec[preset][fork]['custom_types'].keys()):
-            if args.search is None or args.search.lower() in type_name.lower():
-                print(f"  <spec custom_type=\"{type_name}\"{maybe_fork} />")
-
-        print("\nSSZ Objects:")
-        for obj_name in sorted(pyspec[preset][fork]['ssz_objects'].keys()):
-            if args.search is None or args.search.lower() in obj_name.lower():
-                print(f"  <spec ssz_object=\"{obj_name}\"{maybe_fork} />")
-
-        print("\nDataclasses:")
-        for class_name in sorted(pyspec[preset][fork]['dataclasses'].keys()):
-            if args.search is None or args.search.lower() in class_name.lower():
-                print(f"  <spec dataclass=\"{class_name}\"{maybe_fork} />")
-
-        print("\nPreset Variables:")
-        for var_name in sorted(pyspec[preset][fork]['preset_vars'].keys()):
-            if args.search is None or args.search.lower() in var_name.lower():
-                print(f"  <spec preset_var=\"{var_name}\"{maybe_fork} />")
-
-        print("\nConfig Variables:")
-        for var_name in sorted(pyspec[preset][fork]['config_vars'].keys()):
-            if args.search is None or args.search.lower() in var_name.lower():
-                print(f"  <spec config_var=\"{var_name}\"{maybe_fork} />")
-
-    return 0
-
-
-def list_forks(args):
-    """List all available forks."""
-    pyspec = get_pyspec()
-    preset = args.preset
-
-    if preset not in pyspec:
-        print(f"Error: Preset '{preset}' not found.")
-        print(f"Available presets: {', '.join(pyspec.keys())}")
-        return 1
-
-    forks = sorted(
-        pyspec[preset].keys(),
-        # Put phase0 at the top & EIP feature forks at the bottom
-        key=lambda x: (x != "phase0", x.startswith("eip"), x)
-    )
-
-    if args.format == "json":
-        result = {
-            "preset": preset,
-            "forks": forks
-        }
-        print(json.dumps(result, indent=2))
-    else:
-        print(f"Available forks for {preset} preset:")
-        for fork in forks:
-            print(f"  {fork}")
-
-    return 0
-
-
-def main():
-    parser = argparse.ArgumentParser(
-        description="Process files containing <spec> tags."
-    )
-
-    # Create subparsers for different commands
-    subparsers = parser.add_subparsers(dest="command", help="Command to execute")
-
-    # Parser for 'process' command
-    process_parser = subparsers.add_parser("process", help="Process spec tags in files")
-    process_parser.set_defaults(func=process)
-    process_parser.add_argument(
-        "--path",
-        type=str,
-        help="Directory to search for files containing <spec> tags",
-        default=".",
-    )
-    process_parser.add_argument(
-        "--exclude",
-        action="append",
-        help="Exclude paths matching this regex",
-        default=[],
-    )
-
-    # Parser for 'list-tags' command
-    list_tags_parser = subparsers.add_parser("list-tags", help="List available specification tags")
-    list_tags_parser.set_defaults(func=list_tags)
-    list_tags_parser.add_argument(
-        "--fork",
-        type=str,
-        help="Fork to list tags for",
-        default=get_latest_fork(),
-    )
-    list_tags_parser.add_argument(
-        "--preset",
-        type=str,
-        help="Preset to use (mainnet or minimal)",
-        default="mainnet",
-    )
-    list_tags_parser.add_argument(
-        "--format",
-        type=str,
-        choices=["text", "json"],
-        default="text",
-        help="Output format (text or json)",
-    )
-    list_tags_parser.add_argument(
-        "--search",
-        type=str,
-        help="Filter tags by search term",
-        default=None,
-    )
-
-    # Parser for 'list-forks' command
-    list_forks_parser = subparsers.add_parser("list-forks", help="List available forks")
-    list_forks_parser.set_defaults(func=list_forks)
-    list_forks_parser.add_argument(
-        "--preset",
-        type=str,
-        help="Preset to use (mainnet or minimal)",
-        default="mainnet",
-    )
-    list_forks_parser.add_argument(
-        "--format",
-        type=str,
-        choices=["text", "json"],
-        default="text",
-        help="Output format (text or json)",
-    )
-
-    # Default to 'process' if no args are provided
-    if len(sys.argv) == 1:
-        sys.argv.insert(1, "process")
-
-    args = parser.parse_args()
-    exit(args.func(args))
-
-
-if __name__ == "__main__":
-    main()