fixed website added better requirements file

app.py

@@ -1,270 +1,276 @@
 import gradio as gr
 import pandas as pd
-import bittensor as bt
-import requests
-from apscheduler.schedulers.background import BackgroundScheduler
+from concurrent.futures import ThreadPoolExecutor
+from datetime import datetime, timedelta
+from math import ceil
+from typing import TypeAlias, Optional, Tuple
 
-# 1. Define data functions first
-def get_validator_data() -> pd.DataFrame:
-    if subtensor is None or metagraph is None:
-        return pd.DataFrame(columns=['Name', 'UID', 'Axon', 'API', 'Step', 'Recent Bits', 'Updated', 'VTrust'])
-    
+import aiohttp
+import asyncio
+
+from fiber.chain.interface import get_substrate
+from fiber.chain.metagraph import Metagraph
+from fiber.chain.models import Node
+from substrateinterface.storage import StorageKey
+
+Weight: TypeAlias = float
+Hotkey: TypeAlias = str
+Uid: TypeAlias = int
+
+NET_UID = 36
+VALIDATOR_IDENTITIES: dict[Hotkey, str] = {}
+UPDATED: dict[Hotkey, int] = {}
+UIDS_BY_HOTKEY: dict[Hotkey, Uid] = {}
+HOTKEYS_BY_UID: dict[Uid, Hotkey] = {}
+
+substrate = get_substrate()
+metagraph = Metagraph(substrate, netuid=NET_UID, load_old_nodes=False)
+
+def query_subtensor(storage_keys: list[StorageKey], block: int) -> list:
+    global substrate
     try:
-        validator_ids = list(set([i for i in range(len(metagraph.validator_permit)) 
-                        if metagraph.validator_permit[i] and 
-                        metagraph.active[i] and 
-                        str(metagraph.axons[i].ip) != "0.0.0.0"]))
+        return substrate.query_multi(
+            storage_keys=storage_keys,
+            block_hash=substrate.get_block_hash(block),
+        )
+    except Exception:
+        substrate = get_substrate()
+        raise
+
+def is_validator(node: Node) -> bool:
+    if not hasattr(node, 'vtrust') or not hasattr(node, 'ip'):
+        return False
+    return node.vtrust > 0 and str(node.ip) != "0.0.0.0"
+
+def fetch_updated(block: int):
+    UPDATED.clear()
+    for hotkey, node in metagraph.nodes.items():
+        UPDATED[hotkey] = ceil(block - node.last_updated)
+
+def fetch_identities(block: int):
+    VALIDATOR_IDENTITIES.clear()
+    storage_keys: list[StorageKey] = []
+    for hotkey, node in metagraph.nodes.items():
+        if not is_validator(node): continue
+        storage_keys.append(substrate.create_storage_key(
+            "SubtensorModule",
+            "Identities",
+            [node.coldkey]
+        ))
+
+    identities = query_subtensor(storage_keys, block)
+    for hotkey, node in metagraph.nodes.items():
+        for storage, info in identities:
+            if node.coldkey != storage.params[0]: continue
+            if info is not None:
+                VALIDATOR_IDENTITIES[hotkey] = info.value["name"]
+                break
+
+async def fetch_validator_stats(session: aiohttp.ClientSession, ip: str) -> Tuple[Optional[int], Optional[str], bool]:
+    try:
+        # Fetch current step (in bits)
+        step_url = f"http://{ip}/step"
+        async with session.get(step_url, timeout=5) as resp:
+            if resp.status == 200:
+                step = await resp.json()
+                byte_pos = step // 8
+                byte_range = f"bytes={byte_pos}-{byte_pos}"
+                print(f"Got step {step}, using range: {byte_range}")
+            else:
+                print(f"Failed to get step from {ip}: {resp.status}")
+                return None, None, False
+                
+        # Get byte at step position
+        bits_url = f"http://{ip}/bits"
+        headers = {'Range': byte_range}
+        async with session.get(bits_url, headers=headers, timeout=5) as resp:
+            if resp.status == 206:
+                bytes_data = await resp.read()
+                if bytes_data:
+                    last_byte = format(bytes_data[0], '08b')
+                    print(f"Got byte from {ip}: {last_byte}")
+                    return step, last_byte, True
+                else:
+                    print(f"No byte data from {ip}")
+                    return None, None, False
+            else:
+                print(f"Failed byte request for {ip}: {resp.status}")
+                return None, None, False
+                
     except Exception as e:
-        print(f"Error getting validator IDs: {e}")
-        validator_ids = []
+        print(f"Error for {ip}: {str(e)}")
+        return None, None, False
+
+async def fetch_all_validators(ips: list[str]) -> dict[str, Tuple[Optional[int], Optional[str], bool]]:
+    async with aiohttp.ClientSession() as session:
+        tasks = [fetch_validator_stats(session, ip) for ip in ips]
+        results = await asyncio.gather(*tasks)
+        return dict(zip(ips, results))
 
-    current_block = subtensor.block
+def get_validator_data() -> pd.DataFrame:
     results = []
     
-    for uid in validator_ids:
-        validator_info = {
-            'Name': 'unavailable',
-            'UID': uid,
-            'Axon': 'unavailable',
-            'Step': 0,
-            'Recent Bits': 0,
-            'Updated': 0,
-            'VTrust': 0,
-            'API': '❌'
-        }
-        
-        try:
-            # Get validator name
-            try:
-                identity = subtensor.substrate.query('SubtensorModule', 'Identities', [metagraph.coldkeys[uid]])
-                validator_info['Name'] = identity.value["name"] if identity != None else 'unnamed'
-            except Exception as e:
-                print(f"Error getting Name for UID {uid}: {str(e)}")
-
-            validator_info['Axon'] = f"{metagraph.axons[uid].ip}:{metagraph.axons[uid].port}"
-            
-            # Get Step and Range from endpoints
-            try:
-                axon_endpoint = f"http://{validator_info['Axon']}"
-                step_response = requests.get(f"{axon_endpoint}/step", timeout=(2, 3))
-                step_response.raise_for_status()
-                validator_info['Step'] = step_response.json()
-                
-                bits_response = requests.get(
-                    f"{axon_endpoint}/bits",
-                    headers={"range": "bytes=-1"},
-                    timeout=(2, 3)
-                )
-                bits_response.raise_for_status()
-                binary_string = ''.join(format(byte, '08b') for byte in bits_response.content)
-                validator_info['Recent Bits'] = binary_string[-8:]
-                validator_info['API'] = '<span class="api-status api-up">✅</span>' if bits_response.ok else '<span class="api-status api-down">❌</span>'
-                
-            except requests.Timeout:
-                validator_info['API'] = '<span class="api-status api-down">❌</span>'
-            except Exception as e:
-                if not isinstance(e, requests.Timeout):
-                    print(f"Error connecting to {axon_endpoint}: {str(e)}")
-                validator_info['API'] = '<span class="api-status api-down">❌</span>'
-            
-            try:
-                last_update = int(metagraph.last_update[uid])
-                validator_info['Updated'] = current_block - last_update
-            except Exception as e:
-                print(f"Error getting Updated for UID {uid}: {str(e)}")
+    ips = [f"{node.ip}:{node.port}" for hotkey, node in metagraph.nodes.items() 
+           if is_validator(node)]
+    
+    stats = asyncio.run(fetch_all_validators(ips))
+    
+    for hotkey, node in metagraph.nodes.items():
+        if not is_validator(node):
+            continue
             
-            try:
-                validator_info['VTrust'] = float(metagraph.validator_trust[uid])
-            except Exception as e:
-                print(f"Error getting VTrust for UID {uid}: {str(e)}")
-                
-        except Exception as e:
-            print(f"Error getting Axon for UID {uid}: {str(e)}")
+        ip = f"{node.ip}:{node.port}"
+        step, last_byte, api_up = stats.get(ip, (None, None, False))
         
+        validator_info = {
+            'Name': VALIDATOR_IDENTITIES.get(hotkey, 'unnamed'),
+            'UID': UIDS_BY_HOTKEY.get(hotkey, -1),
+            'VTrust': float(node.vtrust),
+            'IP': ip,
+            'API': '✅' if api_up else '❌',
+            'Step': step if step is not None else 'N/A',
+            'Last Byte': last_byte if last_byte is not None else 'N/A',
+            'Updated': UPDATED.get(hotkey, 0)
+        }
         results.append(validator_info)
     
     df = pd.DataFrame(results)
     df['VTrust'] = df['VTrust'].round(4)
-    return df.sort_values('Step', ascending=False)[['Name', 'UID', 'Axon', 'API', 'Step', 'Recent Bits', 'Updated', 'VTrust']]
+    return df.sort_values('VTrust', ascending=False)
 
-# 2. Initialize bittensor and load data
-try:
-    subtensor = bt.subtensor()
-    metagraph = bt.metagraph(netuid=36)
-    initial_df = get_validator_data()
-    initial_timestamp = pd.Timestamp.now().strftime("%Y-%m-%d %H:%M:%S UTC")
-    print("✅ Data loaded successfully")
-except Exception as e:
-    print(f"❌ Failed to initialize: {e}")
-    initial_df = pd.DataFrame()
-    initial_timestamp = "Failed to load initial data"
-
-# 3. Then CSS and UI components
-background_url = "https://cdn-lfs.hf.co/repos/a4/b4/a4b48e51a6a5ebd9414fc6798da9acf09a6a9425ea160334a1a81c4ad3fdb801/7f89926e2018d54403ac1dc8b0d6fe2401a6489d7da11df27259a07cde7acf87?response-content-disposition=inline%3B+filename*%3DUTF-8%27%27background2.png%3B+filename%3D%22background2.png%22%3B&response-content-type=image%2Fpng&Expires=1731722075&Policy=eyJTdGF0ZW1lbnQiOlt7IkNvbmRpdGlvbiI6eyJEYXRlTGVzc1RoYW4iOnsiQVdTOkVwb2NoVGltZSI6MTczMTcyMjA3NX19LCJSZXNvdXJjZSI6Imh0dHBzOi8vY2RuLWxmcy5oZi5jby9yZXBvcy9hNC9iNC9hNGI0OGU1MWE2YTVlYmQ5NDE0ZmM2Nzk4ZGE5YWNmMDlhNmE5NDI1ZWExNjAzMzRhMWE4MWM0YWQzZmRiODAxLzdmODk5MjZlMjAxOGQ1NDQwM2FjMWRjOGIwZDZmZTI0MDFhNjQ4OWQ3ZGExMWRmMjcyNTlhMDdjZGU3YWNmODc%7EcmVzcG9uc2UtY29udGVudC1kaXNwb3NpdGlvbj0qJnJlc3BvbnNlLWNvbnRlbnQtdHlwZT0qIn1dfQ__&Signature=Y9KvhLMB7xHfQUnq2RC4rMDegTBzbqoMiHAIJzVKy%7E7ajPw2p-AQ19KCYCaXPNbElSV7PZowowMOS%7EtK98A7SM4ndHDePx3OcD%7EDNP8w150rLj58XeCZuVSZ32ayv%7Eb6nZEwYjUbrtrFboN5T9HG8xezW7BgmcXzV3iHppgSNu%7EnwKwJvorVr%7EyddXC6AMsAjsYKYOl1AxnkiMiIKeoD7Rd4ZaAlQsbqAC31BfnbSkBfPq4g0HlCiQYvYsxoofyLsGslnx9X5yIPaYRIRz3uJibPwDZg6GCEYViOfKWwiWV74iA1ptt2DeWLSxBRkjRfnv-HMAs25GmMjqyF85o8vA__&Key-Pair-Id=K3RPWS32NSSJCE"
+# Sync logic
+last_sync: datetime = datetime.fromtimestamp(0)
+last_identity_sync: datetime = datetime.fromtimestamp(0)
+
+def sync_metagraph(timeout: int = 10):
+    global substrate, last_sync
+    now = datetime.now()
+    if now - last_sync < timedelta(minutes=5):
+        return
+    last_sync = now
+
+    def sync_task():
+        print("Syncing metagraph...")
+        block = substrate.get_block_number(None)
+        metagraph.sync_nodes()
+
+        for uid, node in enumerate(metagraph.nodes.values()):
+            UIDS_BY_HOTKEY[node.hotkey] = uid
+            HOTKEYS_BY_UID[uid] = node.hotkey
+
+        fetch_updated(block)
+
+        global last_identity_sync
+        if now - last_identity_sync > timedelta(hours=1):
+            print("Syncing identities...")
+            last_identity_sync = now
+            fetch_identities(block)
+
+    with ThreadPoolExecutor(max_workers=1) as executor:
+        future = executor.submit(sync_task)
+        try:
+            future.result(timeout=timeout)
+        except Exception as e:
+            print(f"Error syncing metagraph: {e}")
+            substrate = get_substrate()
+
+# Create Gradio interface
 custom_css = """
-#component-0 {
-    max-width: 100% !important;
-    padding: 0 !important;
-    margin: 0 !important;
-}
-
-.gradio-container {
-    max-width: 100% !important;
-    padding: 0 !important;
-    margin: 0 !important;
-    background-image: url('""" + background_url + """') !important;
-    background-size: cover !important;
-    background-position: center !important;
-    background-repeat: no-repeat !important;
-    min-height: 100vh !important;
-}
-
-.header-box {
-    text-align: center;
-    max-width: 100%;
-    margin: 20px auto;
-    padding: 1rem;
-    background-color: rgba(17, 24, 39, 0.95);  /* Darker, more opaque background */
-    border-radius: 1rem;
-}
-
-.header-box h1 {
-    color: white;
-    margin: 0;
-    font-size: 2rem;
-}
-
-.header-box p {
-    color: white;  /* Changed to white instead of gray */
-    margin-top: 0.5rem;
-}
-"""
+    :root {
+        --primary: #2A4365;          /* Base blue */
+        --primary-light: #3B5C8F;    /* Lighter blue for hover states */
+        --primary-dark: #1A2F4C;     /* Darker blue for backgrounds */
+        --primary-fade: #4A6285;     /* Faded blue for secondary elements */
+        --text-primary: #EDF2F7;     /* Light gray for main text */
+        --text-secondary: #CBD5E0;   /* Darker gray for secondary text */
+    }
 
-# Data functions first
-def fetch_data():
-    # your data fetching logic
-    pass
+    .gradio-container {
+        background-image: url('https://huggingface.co/spaces/wombo/pyramid-scheme-validator-states/resolve/main/assets/background2.png') !important;
+        background-size: cover !important;
+        background-position: center !important;
+        background-attachment: fixed !important;
+        min-height: 100vh !important;
+    }
 
-def create_leaderboard():
-    try:
-        data = fetch_data()
-        if not data:
-            return pd.DataFrame()
-        return data
-    except Exception as e:
-        print(f"Error creating leaderboard: {e}")
-        return pd.DataFrame()
+    /* Style the table */
+    .table-wrap {
+        background-color: var(--primary) !important;
+        border-radius: 8px !important;
+        box-shadow: 0 4px 6px rgba(0, 0, 0, 0.1) !important;
+        opacity: 0.95 !important;  /* Slight transparency to show background */
+    }
 
-def update_data():
-    try:
-        data = create_leaderboard()
-        error_msg = ""
-        success = True
-    except Exception as e:
-        data = pd.DataFrame()
-        error_msg = f"Error loading data: {str(e)}"
-        success = False
-    return data, error_msg, not success
-
-# Add this before creating the app
-header_html = """
-<div class="header-box">
-    <h1>SN36 Validator Leaderboard</h1>
-    <p>Real-time validator status monitoring</p>
-</div>
-"""
+    /* Style the table headers */
+    thead tr th {
+        background-color: var(--primary-fade) !important;
+        color: var(--text-primary) !important;
+        font-weight: 600 !important;
+        border-bottom: 2px solid var(--primary-light) !important;
+    }
 
-# UI components last
-# Create the Gradio interface with custom theme
-app = gr.Blocks(
-    title="SN36 Validator Leaderboard",
-    css=custom_css,
-    theme=gr.themes.Soft().set(
-        body_background_fill="rgba(17, 24, 39, 0.95)",
-        background_fill_secondary="rgba(17, 24, 39, 0.95)", 
-    )
-)
+    /* Style table cells */
+    tbody tr td {
+        color: var(--text-primary) !important;
+        border-bottom: 1px solid var(--primary-light) !important;
+    }
 
-with app:
-    gr.HTML(header_html)
-    
-    with gr.Tabs(elem_id="main-tabs"):
-        with gr.Tab("📊 Leaderboard", elem_id="leaderboard-tab"):
-            # Initialize with preloaded data
-            leaderboard = gr.DataFrame(
-                value=initial_df,
-                headers=["Name", "UID", "Axon", "API", "Step", "Recent Bits", "Updated", "VTrust"],
-                datatype=["str", "number", "str", "html", "number", "str", "number", "number"],
-                elem_id="leaderboard-table",
-                render=True
-            )
-            
-            # Initialize with preloaded timestamp
-            status_message = gr.Markdown(
-                value=f"Last updated: {initial_timestamp}",
-                elem_classes=["status-msg"]
-            )
-            
-            with gr.Row(equal_height=True):
-                refresh_button = gr.Button("🔄 Refresh Data", variant="primary", elem_classes=["refresh-btn"])
-                auto_refresh = gr.Checkbox(
-                    label="Auto-refresh (5 min)",
-                    value=True,
-                    interactive=True
-                )
-            
-        with gr.Tab("ℹ️ About"):
-            gr.Markdown(
-                """
-                <div style="color: white;">
-                ## About this Leaderboard
-                
-                This dashboard shows real-time information about validators on the network:
-                
-                - **Name**: Validator's registered name on the network
-                - **UID**: Unique identifier of the validator
-                - **Axon**: Validator's Axon address (IP:port)
-                - **API**: API status (✅ online, ❌ offline)
-                - **Step**: Current step count (0 if unavailable)
-                - **Range**: Validator's bit range (0 if unavailable)
-                - **Updated**: Blocks since last update (0 if unavailable)
-                - **VTrust**: Validator's trust score (0 if unavailable)
-                
-                Data is automatically refreshed every 5 minutes, or you can manually refresh using the button.
-                </div>
-                """
-            )
-
-    def update_leaderboard():
-        df = get_validator_data()
-        timestamp = pd.Timestamp.now().strftime("%Y-%m-%d %H:%M:%S UTC")
-        return df, f"Last updated: {timestamp}"
-    
-    refresh_button.click(
-        fn=update_leaderboard,
-        outputs=[leaderboard, status_message],
-        queue=False
-    )
+    /* Alternating row colors */
+    tbody tr:nth-child(even) {
+        background-color: var(--primary-dark) !important;
+    }
 
-    # Auto-refresh logic
-    def setup_auto_refresh():
-        app.scheduler = BackgroundScheduler()
-        app.scheduler.add_job(
-            lambda: app.queue(update_leaderboard), 
-            'interval', 
-            minutes=5
-        )
-        app.scheduler.start()
+    /* Row hover effect */
+    tbody tr:hover {
+        background-color: var(--primary-light) !important;
+    }
+
+    /* Style the refresh button */
+    button.primary {
+        background-color: var(--primary) !important;
+        color: var(--text-primary) !important;
+        border: 1px solid var(--primary-light) !important;
+        transition: all 0.2s ease !important;
+    }
 
-    # Initial data load
-    app.load(
-        fn=update_leaderboard,
-        outputs=[leaderboard, status_message]
+    button.primary:hover {
+        background-color: var(--primary-light) !important;
+        transform: translateY(-1px) !important;
+    }
+
+    /* Style the title */
+    h1 {
+        color: var(--text-primary) !important;
+        text-shadow: 2px 2px 4px rgba(0, 0, 0, 0.3);
+    }
+"""
+
+with gr.Blocks(title="📊 SN36 Validator States", css=custom_css) as demo:
+    gr.Markdown("""
+    <h1 style="text-align: center; font-size: 3em; margin: 0.5em 0;">
+        📊 SN36 Validator States
+    </h1>
+    """, elem_id="title")
+    
+    # Initialize table with empty DataFrame
+    sync_metagraph()  # Initial sync
+    initial_df = get_validator_data()
+    
+    table = gr.DataFrame(
+        value=initial_df,
+        headers=['Name', 'UID', 'VTrust', 'IP', 'API', 'Step', 'Last Byte', 'Updated'],
+        datatype=['str', 'number', 'number', 'str', 'str', 'str', 'str', 'number'],
+        interactive=False
     )
     
-    setup_auto_refresh()
+    refresh_btn = gr.Button("Refresh")
+    
+    def update():
+        sync_metagraph()
+        return get_validator_data()
+    
+    refresh_btn.click(fn=update, outputs=table)
+    demo.load(fn=update, outputs=table)
 
-# Launch the interface with file serving enabled
-app.launch(
-    share=False
-)
+if __name__ == "__main__":
+    demo.launch(share=False, debug=True, allowed_paths=["assets"])

requirements.txt

@@ -1,5 +1,119 @@
-gradio==5.4.0
-fastapi==0.110.1
+fiber @ git+https://github.com/rayonlabs/fiber.git@1.0.0#egg=fiber[chain]
+aiofiles>=23.2.1
+aiohappyeyeballs>=2.4.3
+aiohttp>=3.10.11
+aiosignal>=1.3.1
+annotated-types>=0.7.0
+ansible>=6.7.0
+ansible-core>=2.13.13
+ansible-vault>=2.1.0
+anyio>=4.6.2.post1
+async-property>=0.2.2
+async-timeout>=5.0.1
+attrs>=24.2.0
+backoff>=2.2.1
+base58>=2.1.1
+bittensor>=8.2.1
+bittensor-cli>=8.3.1
+bittensor-wallet>=2.1.1
+bt-decode>=0.2.0a0
+certifi>=2024.8.30
+cffi>=1.17.1
+charset-normalizer>=3.4.0
+click>=8.1.7
+colorama>=0.4.6
+cryptography>=43.0.3
+cytoolz>=1.0.0
+decorator>=5.1.1
+ecdsa>=0.19.0
+eth-hash>=0.7.0
+eth-keys>=0.6.0
+eth-typing>=5.0.0
+eth-utils>=2.2.2
+exceptiongroup>=1.2.2
+fastapi>=0.110.3
+ffmpy>=0.4.0
+fiber>=1.0.0
+filelock>=3.16.1
+frozenlist>=1.5.0
+fsspec>=2024.10.0
+fuzzywuzzy>=0.18.0
+gitdb>=4.0.11
+GitPython>=3.1.43
+gradio>=5.1.0
+gradio_client>=1.4.0
+h11>=0.14.0
+httpcore>=1.0.7
+httpx>=0.27.2
+huggingface-hub>=0.26.2
+idna>=3.10
+iniconfig>=2.0.0
+Jinja2>=3.1.4
+Levenshtein>=0.26.1
+markdown-it-py>=3.0.0
+MarkupSafe>=2.1.5
+mdurl>=0.1.2
+more-itertools>=10.5.0
+msgpack>=1.1.0
+msgpack-numpy-opentensor>=0.5.0
+multidict>=6.1.0
+munch>=2.5.0
+nest-asyncio>=1.6.0
+netaddr>=1.3.0
+numpy>=2.0.2
+orjson>=3.10.11
+packaging>=24.2
 pandas>=2.2.3
+password-strength>=0.0.3.post2
+pillow>=10.4.0
+pluggy>=1.5.0
+propcache>=0.2.0
+py>=1.11.0
+py-bip39-bindings>=0.1.11
+py-ed25519-zebra-bindings>=1.1.0
+py-sr25519-bindings>=0.2.1
+pycparser>=2.22
+pycryptodome>=3.21.0
+pydantic>=2.9.2
+pydantic_core>=2.23.4
+pydub>=0.25.1
+Pygments>=2.18.0
+PyNaCl>=1.5.0
+pytest>=8.3.3
+python-dateutil>=2.9.0.post0
+python-dotenv>=1.0.1
+python-Levenshtein>=0.26.1
+python-multipart>=0.0.17
+python-statemachine>=2.4.0
+pytz>=2024.2
+PyYAML>=6.0.2
+RapidFuzz>=3.10.1
 requests>=2.32.3
-apscheduler==3.10.4
+resolvelib>=0.8.1
+retry>=0.9.2
+rich>=13.9.4
+ruff>=0.7.4
+scalecodec>=1.2.11
+semantic-version>=2.10.0
+shellingham>=1.5.4
+six>=1.16.0
+smmap>=5.0.1
+sniffio>=1.3.1
+starlette>=0.37.2
+substrate-interface>=1.7.10
+tenacity>=9.0.0
+termcolor>=2.5.0
+toml>=0.10.0
+tomli>=2.1.0
+tomlkit>=0.12.0
+toolz>=1.0.0
+tqdm>=4.67.0
+typer>=0.13.1
+typing_extensions>=4.12.2
+tzdata>=2024.2
+urllib3>=2.2.3
+uvicorn>=0.32.1
+websocket-client>=1.8.0
+websockets>=12.0
+xxhash>=3.5.0
+yarl>=1.18.0