Merge branch 'main' of https://github.com/inbravo/python-feature-set

Author: inbravo

com/inbravo/llm/ollama_evaluate.py

@@ -0,0 +1,126 @@
+# Copyright (c) Sebastian Raschka under Apache License 2.0 (see LICENSE.txt).
+# Source for "Build a Large Language Model From Scratch"
+#   - https://www.manning.com/books/build-a-large-language-model-from-scratch
+# Code: https://github.com/rasbt/LLMs-from-scratch
+#
+# A minimal instruction finetuning file based on the code in chapter 7
+
+import json
+import psutil
+from tqdm import tqdm
+import urllib.request
+
+
+def query_model(prompt, model="llama3", url="http://localhost:11434/api/chat"):
+    # Create the data payload as a dictionary
+    data = {
+        "model": model,
+        "messages": [
+            {"role": "user", "content": prompt}
+        ],
+        "options": {     # Settings below are required for deterministic responses
+            "seed": 123,
+            "temperature": 0,
+            "num_ctx": 2048
+        }
+    }
+
+    # Convert the dictionary to a JSON formatted string and encode it to bytes
+    payload = json.dumps(data).encode("utf-8")
+
+    # Create a request object, setting the method to POST and adding necessary headers
+    request = urllib.request.Request(url, data=payload, method="POST")
+    request.add_header("Content-Type", "application/json")
+
+    # Send the request and capture the response
+    response_data = ""
+    with urllib.request.urlopen(request) as response:
+        # Read and decode the response
+        while True:
+            line = response.readline().decode("utf-8")
+            if not line:
+                break
+            response_json = json.loads(line)
+            response_data += response_json["message"]["content"]
+
+    return response_data
+
+
+def check_if_running(process_name):
+    running = False
+    for proc in psutil.process_iter(["name"]):
+        if process_name in proc.info["name"]:
+            running = True
+            break
+    return running
+
+
+def format_input(entry):
+    instruction_text = (
+        f"Below is an instruction that describes a task. "
+        f"Write a response that appropriately completes the request."
+        f"\n\n### Instruction:\n{entry['instruction']}"
+    )
+
+    input_text = f"\n\n### Input:\n{entry['input']}" if entry["input"] else ""
+
+    return instruction_text + input_text
+
+
+def main(file_path):
+    ollama_running = check_if_running("ollama")
+
+    if not ollama_running:
+        raise RuntimeError("Ollama not running. Launch ollama before proceeding.")
+    print("Ollama running:", check_if_running("ollama"))
+
+    with open(file_path, "r") as file:
+        test_data = json.load(file)
+
+    model = "llama3"
+    scores = generate_model_scores(test_data, "model_response", model)
+    print(f"Number of scores: {len(scores)} of {len(test_data)}")
+    print(f"Average score: {sum(scores)/len(scores):.2f}\n")
+
+
+def generate_model_scores(json_data, json_key, model="llama3"):
+    scores = []
+    for entry in tqdm(json_data, desc="Scoring entries"):
+        if entry[json_key] == "":
+            scores.append(0)
+        else:
+            prompt = (
+                f"Given the input `{format_input(entry)}` "
+                f"and correct output `{entry['output']}`, "
+                f"score the model response `{entry[json_key]}`"
+                f" on a scale from 0 to 100, where 100 is the best score. "
+                f"Respond with the integer number only."
+            )
+            score = query_model(prompt, model)
+            try:
+                scores.append(int(score))
+            except ValueError:
+                print(f"Could not convert score: {score}")
+                continue
+
+    return scores
+
+
+if __name__ == "__main__":
+
+    import argparse
+
+    parser = argparse.ArgumentParser(
+        description="Evaluate model responses with ollama"
+    )
+    parser.add_argument(
+        "--file_path",
+        required=True,
+        help=(
+            "The path to the test dataset `.json` file with the"
+            " `'output'` and `'model_response'` keys"
+        )
+    )
+    args = parser.parse_args()
+
+    main(file_path=args.file_path)

com/inbravo/modules/mod.py

@@ -0,0 +1,29 @@
+"""
+This module provides an example of a Python script with a constant, a function, and a class.
+"""
+
+QUOTE = "If Comrade Napoleon says it, it must be right."
+NUMBERS = [100, 200, 300]
+
+def print_argument(argument):
+    """
+    Prints the provided argument.
+    """
+    print(f'argument = {argument}')
+
+class ExampleClass:
+    """
+    Example class with two public methods.
+    """
+
+    def method_one(self):
+        """
+        First example method.
+        """
+        return "Method one executed."
+
+    def method_two(self):
+        """
+        Second example method.
+        """
+        return "Method two executed."

com/inbravo/modules/mod_test.py

@@ -0,0 +1,40 @@
+# trunk-ignore-all(black)
+"""This module demonstrates importing and printing constants from another module."""
+
+# Importing specific constants instead of the entire module
+from mod import NUMBERS, QUOTE
+
+# You can also import everything using '*', but it's not recommended
+# '*' will place the names of all objects from module into the local symbol table, with the exception of any that begin with the underscore (_) character.
+print(QUOTE)
+print(NUMBERS)
+print("-----")
+
+# Importing the entire module
+import mod
+
+print(mod.QUOTE)
+print(mod.NUMBERS)
+print("-----")
+
+# Importing the class from the module
+from mod import ExampleClass
+
+example_instance = ExampleClass()
+print(example_instance.method_one())
+print(example_instance.method_two())
+print("-----")
+
+# Importing the entire module and using the class
+import mod
+
+example_instance2 = mod.ExampleClass()
+print(example_instance2.method_one())
+print(example_instance2.method_two())
+print("-----")
+
+# Importing the function from the module        
+from mod import print_argument
+
+print_argument("Hello from mod_test.py")
+print("-----")

com/inbravo/selenium/page_hitter.py

@@ -0,0 +1,33 @@
+from selenium import webdriver
+from selenium.webdriver.common.by import By
+from selenium.webdriver.support.ui import WebDriverWait
+from selenium.webdriver.support import expected_conditions as EC
+import time
+
+# Initialize the WebDriver (Make sure you have the appropriate WebDriver for your browser)
+driver = webdriver.Chrome()  # You can use Firefox, Edge, etc., by replacing `Chrome` with the desired browser.
+
+try:
+    # Open the web page
+    driver.get("https://providencejournal.com/story/sports/high-school/2025/09/15/vote-for-providence-journal-week-1-high-school-football-player-of-the-week-2025-rhode-island-mvp/86151823007/")  # Replace with the URL of the web page you want to access.
+
+    # Wait for the page to load and locate the radio button
+    WebDriverWait(driver, 10).until(EC.presence_of_element_located((By.NAME, "radio_button_name")))
+
+    # Select the radio button (replace 'radio_button_name' with the actual name or ID of the radio button)
+    radio_button = driver.find_element(By.NAME, "radio_button_name")
+    radio_button.click()
+
+    # Wait for the submit button to be clickable
+    WebDriverWait(driver, 10).until(EC.element_to_be_clickable((By.NAME, "submit_button_name")))
+
+    # Click the submit button (replace 'submit_button_name' with the actual name or ID of the submit button)
+    submit_button = driver.find_element(By.NAME, "submit_button_name")
+    submit_button.click()
+
+    # Optionally, wait for the next page to load or for a confirmation message
+    time.sleep(5)  # Adjust the sleep time as needed.
+
+finally:
+    # Close the browser
+    driver.quit()