chore: resolve merge conflicts

Author: donbusha

neurons/validators/genie_validator.py

@@ -2,6 +2,7 @@
 import bittensor as bt
 import numpy as np
 import random
+import requests
 import threading
 import time
 
@@ -46,11 +47,10 @@
 from webgenie.tasks.image_task_generator import ImageTaskGenerator
 from webgenie.utils.uids import get_all_available_uids
 
-
 class GenieValidator:
     def __init__(self, neuron: BaseNeuron):
         self.neuron = neuron
-        self.lock = neuron.lock
+        self.lock = threading.Lock()
         self.config = neuron.config
         self.miner_results = []
         self.synthetic_tasks = []
@@ -93,10 +93,9 @@ async def query_miners(self):
 
             available_challenges_classes = [
                 AccuracyChallenge, 
-                #QualityChallenge, 
+                SeoChallenge,
                 AccuracyChallenge,
                 SeoChallenge,
-                BalancedChallenge,
             ]  
 
             with self.lock:
@@ -281,7 +280,6 @@ async def synthensize_task(self, session:int, task_number:int):
                 self.synthetic_tasks.append((task, synapse))
 
             bt.logging.success(f"Successfully generated task for {task.src}")
-        
         except Exception as e:
             bt.logging.error(f"Error in synthensize_task: {e}")
             raise e

neurons/validators/score_manager.py

@@ -1,27 +1,28 @@
 import bittensor as bt
 import copy
 import numpy as np
-
+import threading
 from io import StringIO
 from rich.console import Console
 from rich.table import Table
 from typing import List
 
 from webgenie.base.neuron import BaseNeuron
-from webgenie.challenges.challenge import Challenge
+
+from webgenie.challenges.challenge import Challenge, RESERVED_WEIGHTS
 from webgenie.constants import (
     CONSIDERING_SESSION_COUNTS,
     __STATE_VERSION__,
     WORK_DIR,
-    MAX_UNANSWERED_TASKS,
+    MAX_UNANSWERED_TASKS
 )
 from webgenie.helpers.weights import save_file_to_wandb
 
 class ScoreManager:
     def __init__(self, neuron: BaseNeuron):
         self.neuron = neuron
         self.state_path = self.neuron.config.neuron.full_path + "/state.npz"
-        self.lock = neuron.lock
+        self.lock = threading.Lock()
 
         self.hotkeys = copy.deepcopy(self.neuron.metagraph.hotkeys)
         self.current_session = -1
@@ -120,8 +121,7 @@ def set_new_hotkeys(self, new_hotkeys: List[str]):
 
         # Update the hotkeys.
         self.hotkeys = copy.deepcopy(new_hotkeys)
-        with self.lock:
-            self.save_scores()
+        self.save_scores()
 
     def update_scores(self, rewards: np.ndarray, uids: List[int], challenge: Challenge):
         bt.logging.info("Updating scores")
@@ -158,8 +158,7 @@ def update_scores(self, rewards: np.ndarray, uids: List[int], challenge: Challen
             if session_number < session - CONSIDERING_SESSION_COUNTS * 2:
                 self.session_results.pop(session_number)
 
-        with self.lock:
-            self.save_scores()
+        self.save_scores()
 
         console = Console()
         self.print_session_result(session, console)
@@ -174,14 +173,32 @@ def get_winner(self, total_scores: np.ndarray, solved_tasks: np.ndarray, number_
             if self.is_blacklisted(uid):
                 continue
 
-            if solved_tasks[uid] >= max(1, number_of_tasks - MAX_UNANSWERED_TASKS):
-                avg_scores[uid] = total_scores[uid] / solved_tasks[uid]
-            else:
-                avg_scores[uid] = 0
+            avg_scores[uid] = total_scores[uid] / number_of_tasks
+            
+            # if solved_tasks[uid] >= max(1, number_of_tasks - MAX_UNANSWERED_TASKS):
+            #     avg_scores[uid] = total_scores[uid] / solved_tasks[uid]
+            # else:
+            #     avg_scores[uid] = 0
         winner = np.argmax(avg_scores) if max(avg_scores) > 0 else -1
         return winner
 
     def get_scores(self, session_upto: int):
+        # scores = np.zeros(self.neuron.metagraph.n, dtype=np.float32)
+        # for session_number in self.session_results:
+        #     if (session_number <= session_upto - CONSIDERING_SESSION_COUNTS or 
+        #         session_number > session_upto):
+        #         continue
+
+        #     try:
+        #         winner = self.session_results[session_number]["winner"]
+        #         competition_type = self.session_results[session_number]["competition_type"]
+        #         if winner == -1:
+        #             continue
+        #         scores[winner] += RESERVED_WEIGHTS[competition_type]
+        #     except Exception as e:
+        #         bt.logging.warning(f"Error getting scores: {e}")
+
+        # return scores
         scores = np.zeros(self.neuron.metagraph.n, dtype=np.float32)
         tiny_weight = 1 / 128
         big_weight = 1.0
@@ -190,22 +207,13 @@ def get_scores(self, session_upto: int):
                 session_number > session_upto):
                 continue
 
-            winner = self.get_winner(
-                self.session_results[session_number]["scores"],
-                self.session_results[session_number]["solved_tasks"],
-                self.session_results[session_number]["number_of_tasks"],
-            )
+            winner = self.session_results[session_number]["winner"]
             if winner == -1:
                 continue
             if session_number == session_upto:
                 scores[winner] += big_weight
             else:
                 scores[winner] += tiny_weight
-                
-        for uid in range(self.neuron.metagraph.n):
-            if self.is_blacklisted(uid):
-                scores[uid] = 0
-        
         return scores
 
         # if session_upto in self.session_results:

neurons/validators/validator.py

@@ -69,7 +69,7 @@ def __init__(self, config=None):
         self.query_miners_thread: Union[threading.Thread, None] = None
         self.score_thread: Union[threading.Thread, None] = None
         self.sync_thread: Union[threading.Thread, None] = None
-        self.lock = threading.RLock()
+        self.lock = threading.Lock()
 
         self.genie_validator = GenieValidator(neuron=self)
         self.score_manager = ScoreManager(neuron=self)
@@ -346,7 +346,7 @@ def sync_loop(self):
             try:
                 with self.lock:
                     self.sync()
-                self.set_weights()
+                    self.set_weights()
             except Exception as e:
                 bt.logging.error(f"Error during sync: {str(e)}")
             if self.should_exit:

pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "web-genie-ai"
-version = "1.1.26"
+version = "1.1.20"
 description = "The first bittensor subnet for web generation"
 readme = "README.md"
 requires-python = ">=3.12.4"

tests/test_llms.py

@@ -1,5 +1,6 @@
 import sys
 import os
+import random
 
 parent_dir = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
 sys.path.append(parent_dir)
@@ -10,7 +11,7 @@
 import asyncio
 from pydantic import BaseModel
 
-from webgenie.helpers.llms import openai_call
+from webgenie.helpers.llms import openai_call, set_seed
 
 
 class HTML(BaseModel):
@@ -20,15 +21,16 @@ class HTML(BaseModel):
 async def test_openai_call():
     result = await openai_call(
         messages = [
-            {"role": "system", "content": "You are an expert web developer who specializes in HTML and CSS. A user will provide you with the webpage requirements. You need to return a single html file that uses HTML and CSS to satisfy the requirements. Include all CSS code in the HTML file itself. If it involves any images, use 'rick.jpg' as the placeholder. Do not hallucinate any dependencies to external files. You do not need to include JavaScript scripts for dynamic interactions. Pay attention to things like size, text, position, and color of all the elements, as well as the overall layout. Respond with the content of the HTML+CSS file:"},
-            {"role": "user", "content": "Create a webpage with a red background and a blue rectangle in the center."},
+            {"role": "system", "content": "Could you make the following webpage more complex? It should be more complex and have more elements."},
+            {"role": "user", "content": """<!DOCTYPE html>\n<html lang="en">\n<head>\n    <meta charset="UTF-8">\n    <meta name="viewport" content="width=device-width, initial-scale=1.0">\n    <title>Red Background with Blue Rectangle</title>\n    <style>\n        body {\n            margin: 0;\n            height: 100vh;\n            display: flex;\n            justify-content: center;\n            align-items: center;\n            background-color: red;\n        }\n        .blue-rectangle {\n            width: 300px;\n            height: 200px;\n            background-color: blue;\n        }\n    </style>\n</head>\n<body>\n    <div class="blue-rectangle"></div>\n</body>\n</html>"""},
         ], 
         response_format = HTML,
     )
     print(result)
 
 
 if __name__ == "__main__":
+    set_seed(5)
     asyncio.run(test_openai_call())
 
 

webgenie/challenges/challenge.py

@@ -57,6 +57,7 @@ async def calculate_scores(self) -> dict[str, np.ndarray]:
         aggregated_scores = np.where(accuracy_scores > 0.9, quality_scores, 0)
         return aggregated_scores, scores
 
+
 class BalancedChallenge(Challenge):
     competition_type: str = Field(default=BALANCED_COMPETITION_TYPE, description="The type of competition")
 
@@ -65,13 +66,13 @@ async def calculate_scores(self) -> dict[str, np.ndarray]:
         accuracy_scores = scores[ACCURACY_METRIC_NAME]
         quality_scores = scores[QUALITY_METRIC_NAME]
         seo_scores = scores[SEO_METRIC_NAME]
-        aggregated_scores = accuracy_scores * 0.4 + quality_scores * 0.3 + seo_scores * 0.3
+        aggregated_scores = accuracy_scores * 0.6 + quality_scores * 0.2 + seo_scores * 0.2
         return aggregated_scores, scores
 
 
 RESERVED_WEIGHTS = {
-    ACCURACY_COMPETITION_TYPE: 50,
-    BALANCED_COMPETITION_TYPE: 30,
+    ACCURACY_COMPETITION_TYPE: 70,
+    BALANCED_COMPETITION_TYPE: 10,
     SEO_COMPETITION_TYPE: 10,
     QUALITY_COMPETITION_TYPE: 10,
 }

webgenie/tasks/image_task_generator.py

@@ -86,3 +86,41 @@ async def generate_task(self, **kwargs) -> Tuple[Task, bt.Synapse]:
             image_task,  
             WebgenieImageSynapse(base64_image=base64_image, task_id=image_task.task_id),
         )
+
+    async def generate_task(self, session:int, task_number:int)->Tuple[Task, bt.Synapse]:
+        bt.logging.info("Generating Image task")
+        
+        dataset, _ = random.choices(self.datasets, weights=[weight for _, weight in self.datasets])[0]
+        dataset_entry = await dataset.generate_context(session, task_number)
+        bt.logging.debug(f"Generated dataset entry: {dataset_entry.url}")
+
+        ground_truth_html = preprocess_html(dataset_entry.ground_truth_html)
+        bt.logging.info(f"Preprocessed ground truth html")
+        if not ground_truth_html :
+            raise ValueError("Invalid ground truth html")
+
+        if is_empty_html(ground_truth_html):
+            raise ValueError("Empty ground truth html")
+        
+        base64_image = await html_to_screenshot(ground_truth_html, page_load_time=GROUND_TRUTH_HTML_LOAD_TIME)   
+        # Check image dimensions ratio
+        image = base64_to_image(base64_image)
+        width, height = image.size
+        aspect_ratio = height / width
+        if aspect_ratio > 7:  # If height is more than 7x the width
+            raise ValueError(f"Image aspect ratio too extreme: {aspect_ratio:.2f}. Height should not exceed 7x width.")
+        
+        bt.logging.debug(f"Screenshot generated for {dataset_entry.url}")
+        image_task = ImageTask(
+            base64_image=base64_image,
+            ground_truth_html=ground_truth_html,
+            generator=self,
+            src=dataset_entry.src,
+            task_id=hashlib.sha256(dataset_entry.url.encode()).hexdigest(),
+            timeout=IMAGE_TASK_TIMEOUT,
+        )
+        
+        return (
+            image_task,  
+            WebgenieImageSynapse(base64_image=base64_image, task_id=image_task.task_id),
+        )