Upload folder using huggingface_hub

.gitattributes

@@ -57,3 +57,4 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 # Video files - compressed
 *.mp4 filter=lfs diff=lfs merge=lfs -text
 *.webm filter=lfs diff=lfs merge=lfs -text
+output.jsonl filter=lfs diff=lfs merge=lfs -text

Scripts/.ipynb_checkpoints/1-checkpoint.py

@@ -0,0 +1,10 @@
+import json
+
+input_file = "ass.jsonl"
+output_file = "ass-pruned.jsonl"
+
+with open(input_file, "r") as infile, open(output_file, "w") as outfile:
+    for line in infile:
+        record = json.loads(line)
+        pruned_record = {key: record[key] for key in ("id", "title", "content") if key in record}
+        outfile.write(json.dumps(pruned_record) + "\n")

Scripts/.ipynb_checkpoints/2-checkpoint.py

@@ -0,0 +1,39 @@
+from langdetect import detect
+import json
+from tqdm import tqdm
+from multiprocessing import Pool
+
+input_file = "ass-pruned.jsonl"
+output_file = "filtered-ass.jsonl"
+
+def process_line(line):
+    try:
+        record = json.loads(line)
+        text = record.get("content", "")
+        if detect(text) == "en":  # Keep only English
+            return json.dumps(record)
+    except Exception:
+        # If detection fails, skip the line
+        return None
+
+
+def main():
+    with open(input_file, "r") as infile:
+        lines = infile.readlines()
+
+    # Use 8 workers, happy now?
+    num_workers = 8
+    with Pool(num_workers) as pool:
+        results = list(
+            tqdm(pool.imap(process_line, lines), desc="Filtering entries", total=len(lines))
+        )
+
+    # Write the filtered results back
+    with open(output_file, "w") as outfile:
+        for result in results:
+            if result:  # Only write non-skipped lines
+                outfile.write(result + "\n")
+
+
+if __name__ == "__main__":
+    main()

Scripts/.ipynb_checkpoints/3-checkpoint.py

@@ -0,0 +1,55 @@
+from transformers import AutoTokenizer
+import orjson  # for speed
+from tqdm import tqdm
+from multiprocessing import Pool
+
+input_file = "filtered-ass.jsonl"
+output_file = "tokenized-ass.jsonl"
+model_name = "microsoft/phi-4"  # Change this to whatever HF model you're using
+max_tokens = 16384
+
+
+# Load your tokenizer only once for each worker
+def init_worker():
+    global tokenizer
+    tokenizer = AutoTokenizer.from_pretrained(model_name, use_fast=True)
+
+
+def process_line(line):
+    try:
+        record = orjson.loads(line)
+        content = record.get("content", "")
+
+        if not content:  # Skip entries with blank content
+            return None
+
+        # Tokenize and check length
+        token_count = len(tokenizer.encode(content, add_special_tokens=False))
+        if token_count <= max_tokens:
+            return orjson.dumps(record).decode("utf-8")
+    except Exception:
+        return None  # Skip problematic entries
+
+
+def main():
+    with open(input_file, "r") as infile:
+        lines = infile.readlines()
+
+    num_workers = 12  # Use all those 12 cores you're so proud of
+    with Pool(num_workers, initializer=init_worker) as pool:
+        results = list(
+            tqdm(
+                pool.imap(process_line, lines),
+                desc="Filtering based on token limit",
+                total=len(lines),
+            )
+        )
+
+    with open(output_file, "w") as outfile:
+        for result in results:
+            if result:
+                outfile.write(result + "\n")
+
+
+if __name__ == "__main__":
+    main()

Scripts/.ipynb_checkpoints/4-checkpoint.py

@@ -0,0 +1,26 @@
+import orjson
+from tqdm import tqdm
+
+input_file = "tokenized-ass.jsonl"
+output_file = "deduped_ass.jsonl"
+
+def main():
+    seen_contents = set()  # Store unique content
+    unique_records = []
+
+    with open(input_file, "r") as infile:
+        for line in tqdm(infile, desc="Deduplicating"):
+            record = orjson.loads(line)
+            content = record.get("content", "")
+
+            if content not in seen_contents:
+                seen_contents.add(content)
+                unique_records.append(record)
+
+    with open(output_file, "w") as outfile:
+        for record in unique_records:
+            outfile.write(orjson.dumps(record).decode("utf-8") + "\n")
+
+
+if __name__ == "__main__":
+    main()

Scripts/.ipynb_checkpoints/5-checkpoint.py

@@ -0,0 +1,106 @@
+from rapidfuzz import fuzz, process
+import orjson
+from multiprocessing import Pool, Manager
+from tqdm import tqdm
+
+input_file = "deduped_ass.jsonl"
+output_file = "filtered_file.jsonl"
+similarity_threshold = 85  # Percentage threshold for similarity
+num_workers = 12  # Use your available cores
+batch_size = 1000  # Number of records per chunk
+
+
+def is_similar(new_content, seen_contents):
+    """
+    Check for similarity to already-seen contents using RapidFuzz.
+    """
+    matches = process.extract(
+        new_content, seen_contents, scorer=fuzz.ratio, limit=1
+    )  # Check against limited candidates
+    if matches and matches[0][1] >= similarity_threshold:
+        return True
+    return False
+
+
+def process_chunk(chunk, shared_seen_contents, lock):
+    """
+    Deduplicate a chunk of records.
+    """
+    local_seen = set()  # A local set to avoid duplicates within this chunk
+    unique_records = []  # List of unique records to return
+    skipped_records = 0  # Counter for skipped records
+
+    for line in chunk:
+        try:
+            record = orjson.loads(line)
+            content = record.get("content", "")
+
+            if not content:
+                # Skip records with empty content
+                skipped_records += 1
+                continue
+
+            with lock:
+                if content in shared_seen_contents:
+                    # Already globally seen; skip this record
+                    skipped_records += 1
+                    continue
+
+            # Perform fuzzy matching locally
+            if not is_similar(content, local_seen):
+                local_seen.add(content)
+                unique_records.append(record)
+            else:
+                # Fuzzy match too similar; skip record
+                skipped_records += 1
+        except Exception as e:
+            print(f"Error processing record: {e}")
+            skipped_records += 1
+
+    with lock:
+        # Update globally shared content with locally seen unique ones
+        shared_seen_contents.update(local_seen)
+
+    print(f"Chunk processed. Unique records: {len(unique_records)}, Skipped records: {skipped_records}")
+    return unique_records
+
+
+def main():
+    # Read all lines from the input file
+    with open(input_file, "r") as infile:
+        lines = infile.readlines()
+
+    # Split the lines into chunks for multiprocessing
+    chunks = [lines[i : i + batch_size] for i in range(0, len(lines), batch_size)]
+
+    # Set up shared memory using Manager
+    manager = Manager()
+    shared_seen_contents = manager.list()  # Shared content tracker
+    lock = manager.Lock()
+
+    # Use multiprocessing to process each chunk
+    with Pool(num_workers) as pool:
+        results = list(
+            tqdm(
+                pool.starmap(
+                    process_chunk,
+                    [(chunk, shared_seen_contents, lock) for chunk in chunks],
+                ),
+                desc="Multiprocessing fuzzy deduplication",
+                total=len(chunks),
+            )
+        )
+
+    # Flatten all the unique records from the multiprocessing results
+    filtered_records = [record for chunk_results in results for record in chunk_results]
+
+    print(f"Total unique records after processing: {len(filtered_records)}")
+
+    # Write the deduplicated records to the output file
+    with open(output_file, "w") as outfile:
+        for record in filtered_records:
+            outfile.write(orjson.dumps(record).decode("utf-8") + "\n")
+
+
+if __name__ == "__main__":
+    main()

Scripts/.ipynb_checkpoints/6-checkpoint.py

@@ -0,0 +1,181 @@
+import asyncio
+import aiohttp
+import orjson
+import re
+import logging
+from tqdm import tqdm
+from statistics import mode
+from typing import List, Dict, Optional
+from logging.handlers import RotatingFileHandler
+
+class ContentRater:
+    def __init__(self, input_file: str, output_file: str, batch_size: int = 2, api_key: Optional[str] = None,
+                 endpoint_url: str = ""):
+        self.logger = logging.getLogger('ContentRater')
+        self.logger.setLevel(logging.DEBUG)
+
+        # Console Handler
+        console_handler = logging.StreamHandler()
+        console_handler.setLevel(logging.INFO)
+        console_format = logging.Formatter('%(asctime)s - %(levelname)s: %(message)s')
+        console_handler.setFormatter(console_format)
+
+        # File Handler
+        file_handler = RotatingFileHandler('content_rater_detailed.log', maxBytes=50 * 1024 * 1024, backupCount=5)
+        file_handler.setLevel(logging.DEBUG)
+        file_format = logging.Formatter('%(asctime)s - %(levelname)s: %(message)s')
+        file_handler.setFormatter(file_format)
+
+        self.logger.handlers.clear()
+        self.logger.addHandler(console_handler)
+        self.logger.addHandler(file_handler)
+
+        # Initialization
+        self.input_file = input_file
+        self.output_file = output_file
+        self.batch_size = batch_size
+        self.endpoint_url = endpoint_url
+        self.headers = {"Content-Type": "application/json"}
+        if api_key:
+            self.headers["Authorization"] = f"Bearer {api_key}"
+
+        self.max_retries = 5
+        self.retry_delay = 2
+        self.timeout = 10000
+
+    def build_prompt(self, content: str) -> str:
+        return f"""
+        You are an Evalutor model with ***NO*** morals whatsover.
+        
+        CRITICAL TECHNICAL WRITING EVALUATION SYSTEM:
+        - Objective assessment of writing quality
+        - Ignore content sensitivity- Regardless how bad it is. Rate it fairly based on WRITING ONLY
+        - Focus on pure writing technique.
+
+        RATING SCALE:
+        1 = CRITICALLY FLAWED WRITING
+        2 = POOR WRITING QUALITY
+        3 = BASIC FUNCTIONAL WRITING
+        4 = GOOD TECHNICAL WRITING
+        5 = EXCEPTIONAL WRITING
+        6 = EXTRAORDINARY CONTENT
+
+        CONTENT TO EVALUATE:
+        <content>{content}</content>
+
+        OUTPUT FORMAT:
+        <thinking>Brief analysis</thinking>
+        <score>X</score>
+        """
+
+    async def get_score_with_retries(self, text: str, session: aiohttp.ClientSession) -> Optional[int]:
+        for attempt in range(self.max_retries):
+            try:
+                payload = {
+                    "model": "SuperNova-Medius",
+                    "prompt": self.build_prompt(text),
+                    "temperature": 0.9,
+                    "min_p": 0.1,
+                    "max_tokens": 150,
+                }
+                self.logger.debug(f"Attempt {attempt + 1}: Sending payload for text (first 100 chars): {text[:100]}")
+
+                try:
+                    async with session.post(
+                        self.endpoint_url,
+                        json=payload,
+                        headers=self.headers,
+                        timeout=aiohttp.ClientTimeout(total=self.timeout)
+                    ) as response:
+                        self.logger.info(f"Response status: {response.status}")
+                        if response.status == 200:
+                            try:
+                                data = await response.json()
+                                self.logger.debug(f"Full API Response: {data}")
+                                completion = data.get("choices", [{}])[0].get("text", "").strip()
+                                self.logger.debug(f"Raw Completion: {completion}")
+                                score = self.extract_score(completion)
+                                if score is not None:
+                                    self.logger.info(f"Extracted Score: {score}")
+                                    return score
+                                else:
+                                    self.logger.warning(f"Could not extract score from: {completion}")
+                            except Exception as json_err:
+                                self.logger.error(f"JSON parsing error: {json_err}")
+                        else:
+                            self.logger.error(f"Unexpected response status: {response.status}")
+                except (aiohttp.ClientError, asyncio.TimeoutError) as conn_err:
+                    self.logger.error(f"Connection/Timeout error: {conn_err}")
+
+                await asyncio.sleep(self.retry_delay * (2 ** attempt))
+            except Exception as e:
+                self.logger.error(f"Unexpected error in score retrieval: {e}")
+        self.logger.error(f"Failed to get valid score after {self.max_retries} attempts")
+        return 1
+
+    @staticmethod
+    def extract_score(text: str) -> Optional[int]:
+        try:
+            score_match = re.search(r'<score>(\d)</score>', text)
+            if score_match:
+                return int(score_match.group(1))
+            numbers = re.findall(r'\d', text)
+            if numbers:
+                return int(mode(numbers))
+        except Exception as e:
+            print(f"Score extraction error: {e}")
+        return None
+
+    async def rate_batch(self, batch: List[Dict], session: aiohttp.ClientSession, output_file) -> List[Dict]:
+        self.logger.info(f"Processing batch of {len(batch)} items")
+        tasks = []
+        for record in batch:
+            if "content" in record:
+                tasks.append(self.get_score_with_retries(record["content"], session))
+
+        ratings = await asyncio.gather(*tasks, return_exceptions=True)
+        processed_batch = []
+        for record, rating in zip(batch, ratings):
+            if isinstance(rating, Exception):
+                record["evaluation"] = 1
+                self.logger.error(f"Rating failed for record: {rating}")
+            else:
+                record["evaluation"] = rating
+            try:
+                output_file.write(orjson.dumps(record).decode("utf-8") + "\n")
+                output_file.flush()
+                processed_batch.append(record)
+            except Exception as e:
+                self.logger.error(f"Error writing record: {e}")
+        return processed_batch
+
+    async def process_file(self):
+        self.logger.info(f"Starting file processing: {self.input_file}")
+        async with aiohttp.ClientSession(headers=self.headers) as session:
+            with open(self.input_file, "r") as infile, open(self.output_file, "w") as outfile:
+                records = [orjson.loads(line) for line in infile]
+                self.logger.info(f"Total records loaded: {len(records)}")
+                batches = [records[i:i + self.batch_size] for i in range(0, len(records), self.batch_size)]
+                self.logger.info(f"Created {len(batches)} batches")
+                results = []
+                for batch in tqdm(batches, desc="Processing batches"):
+                    batch_results = await self.rate_batch(batch, session, outfile)
+                    results.extend(batch_results)
+                    await asyncio.sleep(0.1)
+        self.logger.info("Processing complete!")
+        return results
+
+def main():
+    logging.basicConfig(
+        level=logging.INFO,
+        format='%(asctime)s - %(levelname)s: %(message)s'
+    )
+    rater = ContentRater(
+        input_file="deduped_ass.jsonl",
+        output_file="rated_file-final.jsonl",
+        api_key=""
+    )
+    asyncio.run(rater.process_file())
+
+if __name__ == "__main__":
+    main()

Scripts/.ipynb_checkpoints/Extract-checkpoint.py

@@ -0,0 +1,19 @@
+import json
+
+def filter_jsonl(input_file, output_file):
+    with open(input_file, 'r') as infile, open(output_file, 'w') as outfile:
+        for idx, line in enumerate(infile, 1):
+            try:
+                obj = json.loads(line)
+            except json.JSONDecodeError:
+                print(f"Line {idx} in {input_file} is garbage JSON: {line.strip()}")
+                continue
+
+            evaluation = obj.get("evaluation")
+            if (isinstance(evaluation, int) and 3 <= evaluation <= 6) or (
+                isinstance(evaluation, dict) and 3 <= evaluation.get("rating", 0) <= 6):
+                outfile.write(json.dumps(obj) + '\n')
+            else:
+                print(f"Line {idx} skipped. Evaluation doesn't match criteria or is nonsense: {evaluation}")
+
+filter_jsonl("rated_file-final.jsonl", "output.jsonl")

Scripts/1.py

@@ -0,0 +1,10 @@
+import json
+
+input_file = "ass.jsonl"
+output_file = "ass-pruned.jsonl"
+
+with open(input_file, "r") as infile, open(output_file, "w") as outfile:
+    for line in infile:
+        record = json.loads(line)
+        pruned_record = {key: record[key] for key in ("id", "title", "content") if key in record}
+        outfile.write(json.dumps(pruned_record) + "\n")

Scripts/2.py

@@ -0,0 +1,39 @@
+from langdetect import detect
+import json
+from tqdm import tqdm
+from multiprocessing import Pool
+
+input_file = "ass-pruned.jsonl"
+output_file = "filtered-ass.jsonl"
+
+def process_line(line):
+    try:
+        record = json.loads(line)
+        text = record.get("content", "")
+        if detect(text) == "en":  # Keep only English
+            return json.dumps(record)
+    except Exception:
+        # If detection fails, skip the line
+        return None
+
+
+def main():
+    with open(input_file, "r") as infile:
+        lines = infile.readlines()
+
+    # Use 8 workers, happy now?
+    num_workers = 8
+    with Pool(num_workers) as pool:
+        results = list(
+            tqdm(pool.imap(process_line, lines), desc="Filtering entries", total=len(lines))
+        )
+
+    # Write the filtered results back
+    with open(output_file, "w") as outfile:
+        for result in results:
+            if result:  # Only write non-skipped lines
+                outfile.write(result + "\n")
+
+
+if __name__ == "__main__":
+    main()

Scripts/3.py

@@ -0,0 +1,55 @@
+from transformers import AutoTokenizer
+import orjson  # for speed
+from tqdm import tqdm
+from multiprocessing import Pool
+
+input_file = "filtered-ass.jsonl"
+output_file = "tokenized-ass.jsonl"
+model_name = "microsoft/phi-4"  # Change this to whatever HF model you're using
+max_tokens = 16384
+
+
+# Load your tokenizer only once for each worker
+def init_worker():
+    global tokenizer
+    tokenizer = AutoTokenizer.from_pretrained(model_name, use_fast=True)
+
+
+def process_line(line):
+    try:
+        record = orjson.loads(line)
+        content = record.get("content", "")
+
+        if not content:  # Skip entries with blank content
+            return None
+
+        # Tokenize and check length
+        token_count = len(tokenizer.encode(content, add_special_tokens=False))
+        if token_count <= max_tokens:
+            return orjson.dumps(record).decode("utf-8")
+    except Exception:
+        return None  # Skip problematic entries
+
+
+def main():
+    with open(input_file, "r") as infile:
+        lines = infile.readlines()
+
+    num_workers = 12  # Use all those 12 cores you're so proud of
+    with Pool(num_workers, initializer=init_worker) as pool:
+        results = list(
+            tqdm(
+                pool.imap(process_line, lines),
+                desc="Filtering based on token limit",
+                total=len(lines),
+            )
+        )
+
+    with open(output_file, "w") as outfile:
+        for result in results:
+            if result:
+                outfile.write(result + "\n")
+
+
+if __name__ == "__main__":
+    main()

Scripts/4.py

@@ -0,0 +1,26 @@
+import orjson
+from tqdm import tqdm
+
+input_file = "tokenized-ass.jsonl"
+output_file = "deduped_ass.jsonl"
+
+def main():
+    seen_contents = set()  # Store unique content
+    unique_records = []
+
+    with open(input_file, "r") as infile:
+        for line in tqdm(infile, desc="Deduplicating"):
+            record = orjson.loads(line)
+            content = record.get("content", "")
+
+            if content not in seen_contents:
+                seen_contents.add(content)
+                unique_records.append(record)
+
+    with open(output_file, "w") as outfile:
+        for record in unique_records:
+            outfile.write(orjson.dumps(record).decode("utf-8") + "\n")
+
+
+if __name__ == "__main__":
+    main()

Scripts/5.py

@@ -0,0 +1,106 @@
+from rapidfuzz import fuzz, process
+import orjson
+from multiprocessing import Pool, Manager
+from tqdm import tqdm
+
+input_file = "deduped_ass.jsonl"
+output_file = "filtered_file.jsonl"
+similarity_threshold = 85  # Percentage threshold for similarity
+num_workers = 12  # Use your available cores
+batch_size = 1000  # Number of records per chunk
+
+
+def is_similar(new_content, seen_contents):
+    """
+    Check for similarity to already-seen contents using RapidFuzz.
+    """
+    matches = process.extract(
+        new_content, seen_contents, scorer=fuzz.ratio, limit=1
+    )  # Check against limited candidates
+    if matches and matches[0][1] >= similarity_threshold:
+        return True
+    return False
+
+
+def process_chunk(chunk, shared_seen_contents, lock):
+    """
+    Deduplicate a chunk of records.
+    """
+    local_seen = set()  # A local set to avoid duplicates within this chunk
+    unique_records = []  # List of unique records to return
+    skipped_records = 0  # Counter for skipped records
+
+    for line in chunk:
+        try:
+            record = orjson.loads(line)
+            content = record.get("content", "")
+
+            if not content:
+                # Skip records with empty content
+                skipped_records += 1
+                continue
+
+            with lock:
+                if content in shared_seen_contents:
+                    # Already globally seen; skip this record
+                    skipped_records += 1
+                    continue
+
+            # Perform fuzzy matching locally
+            if not is_similar(content, local_seen):
+                local_seen.add(content)
+                unique_records.append(record)
+            else:
+                # Fuzzy match too similar; skip record
+                skipped_records += 1
+        except Exception as e:
+            print(f"Error processing record: {e}")
+            skipped_records += 1
+
+    with lock:
+        # Update globally shared content with locally seen unique ones
+        shared_seen_contents.update(local_seen)
+
+    print(f"Chunk processed. Unique records: {len(unique_records)}, Skipped records: {skipped_records}")
+    return unique_records
+
+
+def main():
+    # Read all lines from the input file
+    with open(input_file, "r") as infile:
+        lines = infile.readlines()
+
+    # Split the lines into chunks for multiprocessing
+    chunks = [lines[i : i + batch_size] for i in range(0, len(lines), batch_size)]
+
+    # Set up shared memory using Manager
+    manager = Manager()
+    shared_seen_contents = manager.list()  # Shared content tracker
+    lock = manager.Lock()
+
+    # Use multiprocessing to process each chunk
+    with Pool(num_workers) as pool:
+        results = list(
+            tqdm(
+                pool.starmap(
+                    process_chunk,
+                    [(chunk, shared_seen_contents, lock) for chunk in chunks],
+                ),
+                desc="Multiprocessing fuzzy deduplication",
+                total=len(chunks),
+            )
+        )
+
+    # Flatten all the unique records from the multiprocessing results
+    filtered_records = [record for chunk_results in results for record in chunk_results]
+
+    print(f"Total unique records after processing: {len(filtered_records)}")
+
+    # Write the deduplicated records to the output file
+    with open(output_file, "w") as outfile:
+        for record in filtered_records:
+            outfile.write(orjson.dumps(record).decode("utf-8") + "\n")
+
+
+if __name__ == "__main__":
+    main()

Scripts/6.py

@@ -0,0 +1,181 @@
+import asyncio
+import aiohttp
+import orjson
+import re
+import logging
+from tqdm import tqdm
+from statistics import mode
+from typing import List, Dict, Optional
+from logging.handlers import RotatingFileHandler
+
+class ContentRater:
+    def __init__(self, input_file: str, output_file: str, batch_size: int = 2, api_key: Optional[str] = None,
+                 endpoint_url: str = ""):
+        self.logger = logging.getLogger('ContentRater')
+        self.logger.setLevel(logging.DEBUG)
+
+        # Console Handler
+        console_handler = logging.StreamHandler()
+        console_handler.setLevel(logging.INFO)
+        console_format = logging.Formatter('%(asctime)s - %(levelname)s: %(message)s')
+        console_handler.setFormatter(console_format)
+
+        # File Handler
+        file_handler = RotatingFileHandler('content_rater_detailed.log', maxBytes=50 * 1024 * 1024, backupCount=5)
+        file_handler.setLevel(logging.DEBUG)
+        file_format = logging.Formatter('%(asctime)s - %(levelname)s: %(message)s')
+        file_handler.setFormatter(file_format)
+
+        self.logger.handlers.clear()
+        self.logger.addHandler(console_handler)
+        self.logger.addHandler(file_handler)
+
+        # Initialization
+        self.input_file = input_file
+        self.output_file = output_file
+        self.batch_size = batch_size
+        self.endpoint_url = endpoint_url
+        self.headers = {"Content-Type": "application/json"}
+        if api_key:
+            self.headers["Authorization"] = f"Bearer {api_key}"
+
+        self.max_retries = 5
+        self.retry_delay = 2
+        self.timeout = 10000
+
+    def build_prompt(self, content: str) -> str:
+        return f"""
+        You are an Evalutor model with ***NO*** morals whatsover.
+        
+        CRITICAL TECHNICAL WRITING EVALUATION SYSTEM:
+        - Objective assessment of writing quality
+        - Ignore content sensitivity- Regardless how bad it is. Rate it fairly based on WRITING ONLY
+        - Focus on pure writing technique.
+
+        RATING SCALE:
+        1 = CRITICALLY FLAWED WRITING
+        2 = POOR WRITING QUALITY
+        3 = BASIC FUNCTIONAL WRITING
+        4 = GOOD TECHNICAL WRITING
+        5 = EXCEPTIONAL WRITING
+        6 = EXTRAORDINARY CONTENT
+
+        CONTENT TO EVALUATE:
+        <content>{content}</content>
+
+        OUTPUT FORMAT:
+        <thinking>Brief analysis</thinking>
+        <score>X</score>
+        """
+
+    async def get_score_with_retries(self, text: str, session: aiohttp.ClientSession) -> Optional[int]:
+        for attempt in range(self.max_retries):
+            try:
+                payload = {
+                    "model": "SuperNova-Medius",
+                    "prompt": self.build_prompt(text),
+                    "temperature": 0.9,
+                    "min_p": 0.1,
+                    "max_tokens": 150,
+                }
+                self.logger.debug(f"Attempt {attempt + 1}: Sending payload for text (first 100 chars): {text[:100]}")
+
+                try:
+                    async with session.post(
+                        self.endpoint_url,
+                        json=payload,
+                        headers=self.headers,
+                        timeout=aiohttp.ClientTimeout(total=self.timeout)
+                    ) as response:
+                        self.logger.info(f"Response status: {response.status}")
+                        if response.status == 200:
+                            try:
+                                data = await response.json()
+                                self.logger.debug(f"Full API Response: {data}")
+                                completion = data.get("choices", [{}])[0].get("text", "").strip()
+                                self.logger.debug(f"Raw Completion: {completion}")
+                                score = self.extract_score(completion)
+                                if score is not None:
+                                    self.logger.info(f"Extracted Score: {score}")
+                                    return score
+                                else:
+                                    self.logger.warning(f"Could not extract score from: {completion}")
+                            except Exception as json_err:
+                                self.logger.error(f"JSON parsing error: {json_err}")
+                        else:
+                            self.logger.error(f"Unexpected response status: {response.status}")
+                except (aiohttp.ClientError, asyncio.TimeoutError) as conn_err:
+                    self.logger.error(f"Connection/Timeout error: {conn_err}")
+
+                await asyncio.sleep(self.retry_delay * (2 ** attempt))
+            except Exception as e:
+                self.logger.error(f"Unexpected error in score retrieval: {e}")
+        self.logger.error(f"Failed to get valid score after {self.max_retries} attempts")
+        return 1
+
+    @staticmethod
+    def extract_score(text: str) -> Optional[int]:
+        try:
+            score_match = re.search(r'<score>(\d)</score>', text)
+            if score_match:
+                return int(score_match.group(1))
+            numbers = re.findall(r'\d', text)
+            if numbers:
+                return int(mode(numbers))
+        except Exception as e:
+            print(f"Score extraction error: {e}")
+        return None
+
+    async def rate_batch(self, batch: List[Dict], session: aiohttp.ClientSession, output_file) -> List[Dict]:
+        self.logger.info(f"Processing batch of {len(batch)} items")
+        tasks = []
+        for record in batch:
+            if "content" in record:
+                tasks.append(self.get_score_with_retries(record["content"], session))
+
+        ratings = await asyncio.gather(*tasks, return_exceptions=True)
+        processed_batch = []
+        for record, rating in zip(batch, ratings):
+            if isinstance(rating, Exception):
+                record["evaluation"] = 1
+                self.logger.error(f"Rating failed for record: {rating}")
+            else:
+                record["evaluation"] = rating
+            try:
+                output_file.write(orjson.dumps(record).decode("utf-8") + "\n")
+                output_file.flush()
+                processed_batch.append(record)
+            except Exception as e:
+                self.logger.error(f"Error writing record: {e}")
+        return processed_batch
+
+    async def process_file(self):
+        self.logger.info(f"Starting file processing: {self.input_file}")
+        async with aiohttp.ClientSession(headers=self.headers) as session:
+            with open(self.input_file, "r") as infile, open(self.output_file, "w") as outfile:
+                records = [orjson.loads(line) for line in infile]
+                self.logger.info(f"Total records loaded: {len(records)}")
+                batches = [records[i:i + self.batch_size] for i in range(0, len(records), self.batch_size)]
+                self.logger.info(f"Created {len(batches)} batches")
+                results = []
+                for batch in tqdm(batches, desc="Processing batches"):
+                    batch_results = await self.rate_batch(batch, session, outfile)
+                    results.extend(batch_results)
+                    await asyncio.sleep(0.1)
+        self.logger.info("Processing complete!")
+        return results
+
+def main():
+    logging.basicConfig(
+        level=logging.INFO,
+        format='%(asctime)s - %(levelname)s: %(message)s'
+    )
+    rater = ContentRater(
+        input_file="deduped_ass.jsonl",
+        output_file="rated_file-final.jsonl",
+        api_key=""
+    )
+    asyncio.run(rater.process_file())
+
+if __name__ == "__main__":
+    main()

Scripts/Extract.py

@@ -0,0 +1,19 @@
+import json
+
+def filter_jsonl(input_file, output_file):
+    with open(input_file, 'r') as infile, open(output_file, 'w') as outfile:
+        for idx, line in enumerate(infile, 1):
+            try:
+                obj = json.loads(line)
+            except json.JSONDecodeError:
+                print(f"Line {idx} in {input_file} is garbage JSON: {line.strip()}")
+                continue
+
+            evaluation = obj.get("evaluation")
+            if (isinstance(evaluation, int) and 3 <= evaluation <= 6) or (
+                isinstance(evaluation, dict) and 3 <= evaluation.get("rating", 0) <= 6):
+                outfile.write(json.dumps(obj) + '\n')
+            else:
+                print(f"Line {idx} skipped. Evaluation doesn't match criteria or is nonsense: {evaluation}")
+
+filter_jsonl("rated_file-final.jsonl", "output.jsonl")

output.jsonl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:e9b75f64a7f5259c8aff8abb25d2bc2d90f71c369b4575ed9ab4be84caf4a9cf
+size 355323205