Florence Characteristics Analysis

2024-06-27 08:21 UTC gpt-4o Open in ChatGPT ↗

You

Can you add to this script. I need to send the primary, secondary, tertiary ad quaternary categories as osc values to touch designer, which will be received by an oscin CHOP. I also need to send the word response string which will be received by an oscin DAT.

from gpt4all import GPT4All from contextlib import contextmanager from pythonosc import dispatcher from pythonosc import osc_server from pythonosc import udp_client import time import argparse import random import re

Define the IP address and port to listen on

my_ip = “127.0.0.1”

my_port = 8000 # Python server listening port

my_unity_ip = “127.0.0.1”

my_unity_port = 10000

#region ##### IP #### #PC VERSION ip = “127.0.0.1” port = 8000 unity_ip = “127.0.0.1” unity_port = 10000

#TABLET VERSION

ip = “192.168.1.254”

port = 8000

unity_ip = “192.168.1.72”

unity_port = 10000

#endregion

output_format = """ PRIMARY: “primaryCategoryName” = primary_value, SECONDARY: “secondaryCategoryName” = secondary_value, TERTIARY: “tertiaryCategoryName” = tertiary_value, QUATERNARY: “quaternaryCategoryName” = quaternary_value. """

model = GPT4All(model_name=‘Meta-Llama-3-8B-Instruct.Q4_0.gguf’,n_threads=8, device= “gpu”) #system_template = ‘You are a system that receives a sentence about Florence Nightingale and returns her primary, secondary, tertiary and quaternary characteristics, as extracted by the meaning of the sentence. You can only pick from these four words: hero, angel, feminist, rebel. You cannot pick the same word for different categories. Primary and secondary category cannot be 0, and primary category must be bigger than the secondary. The sum of the four categories should always be 100. If someone says absolute nonsense, try your best to derive some meaning. if not , just say “Ambiguous”. Always format your answer like that example: PRIMARY: “hero” = calculated value, SECONDARY: “hero” = calculated value, TERTIARY: “hero” = calculated value, QUATERNARY: “hero” = calculated value. From now on, you will receive sentences about Florence, and you will reply only in the above format. PRIMARY and SECONDARY strictly cannot be the same. If the sentence is ambiguous, do not use the PRIMARY, SECONDARY format, but just say AMBIGUOUS”.\n’

system_template = f’You are a system that receives a sentence about Florence Nightingale and returns her primary, secondary, tertiary and quaternary characteristics, as extracted by the meaning of the sentence. You can only pick from these four words: hero, angel, feminist, rebel. You cannot pick the same word for different categories. Primary and secondary category cannot be 0, and primary category must be bigger than the secondary. The sum of the four categories should always be 100. If someone says absolute nonsense, try your best to derive some meaning. if not , just say “Ambiguous”. Always format your answer like that example: {output_format} . Always put the category name in quotation marks, as in the example. From now on, you will receive sentences about Florence, and you will reply only in the above format. PRIMARY and SECONDARY strictly cannot be the same. If the sentence is ambiguous, do not use the PRIMARY, SECONDARY format, but just say AMBIGUOUS”.\n’

new_message = 0 #region ########################### FLORENCE ATTRIBUTES ##################### class FlorenceAttributes: LABELS = [“angel”, “hero”,“feminist”, “rebel”]

def __init__(self, primary=None, secondary=None, tertiary=None, quaternary=None, primary_value=None, secondary_value=None, tertiary_value=None, quaternary_value=None, ambiguous=False):
    self.primary = primary
    self.secondary = secondary
    self.tertiary = tertiary
    self.quaternary = quaternary
    self.primary_value = primary_value
    self.secondary_value = secondary_value
    self.tertiary_value = tertiary_value
    self.quaternary_value = quaternary_value
    self.ambiguous = ambiguous

def __str__(self):
    if self.ambiguous:
        return "AMBIGUOUS"
    else:
        return f'PRIMARY: "{self.primary}" = {self.primary_value}, SECONDARY: "{self.secondary}" = {self.secondary_value}, TERTIARY: "{self.tertiary}" = {self.tertiary_value}, QUATERNARY: "{self.quaternary}" = {self.quaternary_value}'

def has_null_labels(self):
    return any((label == "" or label == "None") for label in [self.primary, self.secondary, self.tertiary, self.quaternary])

def has_null_values(self):
    #return any(value is None for value in [self.primary_value, self.secondary_value, self.tertiary_value, self.quaternary_value])
    return any((value == 0 or value == None)for value in [self.primary_value, self.secondary_value, self.tertiary_value, self.quaternary_value])

def fill_missing_labels(self):
    used_labels = [label for label in [self.primary, self.secondary, self.tertiary, self.quaternary] if label != ""]
    free_labels = [label for label in self.LABELS if label not in used_labels]

    if self.primary == "":
        print("===primary NULL===")
        if len(free_labels) == 1:
            self.primary = free_labels[0]
        elif len(free_labels) > 1:
            self.primary = random.choice(free_labels)
            used_labels = [label for label in [self.primary, self.secondary, self.tertiary, self.quaternary] if label != ""]
            free_labels = [label for label in self.LABELS if label not in used_labels]
    if self.secondary == "":
        print("===secondary NULL===")
        if len(free_labels) == 1:
            self.secondary = free_labels[0]
        elif len(free_labels) > 1:
            self.secondary = random.choice(free_labels)
            used_labels = [label for label in [self.primary, self.secondary, self.tertiary, self.quaternary] if label != ""]
            free_labels = [label for label in self.LABELS if label not in used_labels]
    if self.tertiary == "":
        print("===tertiary NULL===")
        if len(free_labels) == 1:
            self.tertiary = free_labels[0]
        elif len(free_labels) > 1:
            self.tertiary = random.choice(free_labels)
            used_labels = [label for label in [self.primary, self.secondary, self.tertiary, self.quaternary] if label != ""]
            free_labels = [label for label in self.LABELS if label not in used_labels]
    if self.quaternary == "":
        print("===quaternary NULL===")
        if len(free_labels) == 1:
            self.quaternary = free_labels[0]
        elif len(free_labels) > 1:
            self.quaternary = random.choice(free_labels)
            used_labels = [label for label in [self.primary, self.secondary, self.tertiary, self.quaternary] if label != ""]
            free_labels = [label for label in self.LABELS if label not in used_labels]

def reorganize_data(self):
    global new_message  # Declare the global variable inside the function
    new_message += 1  # Update the global counter variable
    labels = [self.primary, self.secondary, self.tertiary, self.quaternary]
    values = [self.primary_value, self.secondary_value, self.tertiary_value, self.quaternary_value]
    result = []

    # Pair each label with its corresponding value
    label_value_pairs = zip(labels, values)

    # Rearrange labels and values according to the specified order
    for label in self.LABELS:
        ## Find the index of the label in the LABELS list
        #idx = self.LABELS.index(label)
        # Find the corresponding value for the label
       value = next((v for l, v in label_value_pairs if l == label), None)
       if value is not None:
        # Append the formatted label-value pair to the result
        result.append(f"{label}: {value}")

    # Add /new_message label and its value
    result.append(f"/new_message {new_message}")

    return ", ".join(result)

def finalGeneratedValues(self, wordResponse):
    global new_message  # Declare the global variable inside the function
    new_message += 1  # Update the global counter variable
    return(f"{self.primary} = {self.primary_value}, "
    f"{self.secondary} = {self.secondary_value}, "
    f"{self.tertiary} = {self.tertiary_value}, "
    f"{self.quaternary} = {self.quaternary_value}, "
    f"newMessage = {new_message},  "
    f"wordResponse = {wordResponse}")


@classmethod
def generate_random_attributes(cls):

    labels = cls.LABELS.copy()
    random.shuffle(labels)

    # Ensure unique labels for each category
    primary = labels.pop()
    secondary = labels.pop()
    tertiary = labels.pop()
    quaternary = labels.pop()

    first_value= random.randint(0,100)
    second_value = random.randint(0,100-first_value)
    sum_value = first_value+second_value
    third_value = random.randint(0,100-sum_value)
    sum_value1=sum_value + third_value
    fourth_value = 100 - sum_value1

    primary_value=first_value
    secondary_value=second_value
    tertiary_value = third_value
    quaternary_value = fourth_value

    return cls(primary, secondary, tertiary, quaternary, primary_value, secondary_value, tertiary_value, quaternary_value)

def update_with_random_attributes(self):
    random_attributes = FlorenceAttributes.generate_random_attributes()
    self.primary = random_attributes.primary
    self.secondary = random_attributes.secondary
    self.tertiary = random_attributes.tertiary
    self.quaternary = random_attributes.quaternary
    self.primary_value = random_attributes.primary_value
    self.secondary_value = random_attributes.secondary_value
    self.tertiary_value = random_attributes.tertiary_value
    self.quaternary_value = random_attributes.quaternary_value
    self.ambiguous = random_attributes.ambiguous

class GPT4AllChat: def init(self, model_name): self.model_name = model_name self.model = GPT4All(model_name,n_threads=8, device= “gpu”) self.session_active = False

def start_session(self):
    if not self.session_active:
        self.session = self.model.chat_session().__enter__()
        self.session_active = True
        print("Chat session started.")
    else:
        print("Chat session is already open.")

def close_session(self):
    if self.session_active:
        try:
            self.session.__exit__(None, None, None)
            print("Chat session ended.")
        except Exception as e:
            print(f"Error closing the session: {e}")
        finally:
            self.session_active = False
    else:
        print("No chat session to close.")

def is_session_open(self):
    return self.session_active

def generate_response(self, prompt):
    if not self.session_active:
        raise RuntimeError("No active session. Please start a session first.")

    try:
        return self.session.generate(prompt)
    except Exception as e:
        print(f"Error generating response: {e}")
        return None

def store_attributes(input_string): if input_string.strip() == “AMBIGUOUS”: return FlorenceAttributes(ambiguous=True), False, False if input_string.strip() == “Ambiguous”: return FlorenceAttributes(ambiguous=True), False, False # Initialize values to None primary = secondary = tertiary = quaternary = None primary_value = secondary_value = tertiary_value = quaternary_value = None

##reformat the string, in case that it has commas and periods
#input_string= reformat_input(input_string)
##version to make all the different response variations to the same format
input_string = normalize_response(input_string)
print("!!!---parsed attributes ")
print(input_string)

# Extract values using string manipulation
try:
    lines = input_string.split('\n')
    for line in lines:
        if line.startswith('PRIMARY: "'):
            primary, primary_value = extract_attribute(line)
        elif line.startswith('SECONDARY: "'):
            secondary, secondary_value = extract_attribute(line)
        elif line.startswith('TERTIARY: "'):
            tertiary, tertiary_value = extract_attribute(line)
        elif line.startswith('QUATERNARY: "'):
            quaternary, quaternary_value = extract_attribute(line)
except (IndexError, ValueError):
    raise ValueError("Invalid format")

attributes = FlorenceAttributes(primary=primary, secondary=secondary, tertiary=tertiary, quaternary=quaternary, primary_value=primary_value, secondary_value=secondary_value, tertiary_value=tertiary_value, quaternary_value=quaternary_value)
return attributes, attributes.has_null_labels(), attributes.has_null_values()

def extract_attribute(line): try: # Remove any trailing commas or periods line = line.rstrip(’,.’)

    # Split the line on the first occurrence of ':'
    prefix, rest = line.split(':', 1)

    # Strip any leading/trailing whitespace from the rest
    rest = rest.strip()

    # Now split the remaining part on ' = '
    label_part, value_part = rest.split(' = ', 1)

    # Extract the label by splitting on the first occurrence of '"'
    label = label_part.split('"')[1]

    # Convert the value part to an integer
    value = int(value_part.strip())
    # label_part, value_part = line.split(' = ')
    # label = label_part.split('"')[1]
    # value = int(value_part)
    return label, value
except (IndexError, ValueError):
    raise ValueError("Invalid attribute format")

def reformat_input(input_string): # Split the input string by lines lines = input_string.split(‘\n’)

reformatted_lines = []
for line in lines:
    # Strip any leading or trailing whitespace from the line
    line = line.strip()

    # Remove any trailing commas or periods
    line = line.rstrip(',.')

    # Add the correctly formatted line to the list
    reformatted_lines.append(line)

# Join the lines with new line characters
reformatted_string = '\n'.join(reformatted_lines)
return reformatted_string

def normalize_response(input_string): # Remove commas, periods, and extra spaces cleaned_input = re.sub(r’[,.]’, ”, input_string).strip()

# Split the input into lines
lines = cleaned_input.splitlines()

# If the input is in one line, split by the pattern
if len(lines) == 1:
    pattern = re.compile(r'(PRIMARY|SECONDARY|TERTIARY|QUATERNARY): ".*?" = \d+')
    matches = pattern.findall(cleaned_input)

    # Join matches with newlines
    normalized_output = "\n".join(pattern.findall(cleaned_input))
else:
    # Otherwise, normalize the lines by removing extra spaces
    normalized_lines = [line.strip() for line in lines]
    normalized_output = "\n".join(normalized_lines)

return normalized_output

def handle_null_labels(attributes): if attributes.has_null_labels(): raise ValueError(“One or more labels are null: ” + str(attributes)) else: print(“All labels are set: ” + str(attributes))

def handle_null_values(attributes): if attributes.has_null_values(): raise ValueError(“One or more values are null: ” + str(attributes)) else: print(“All values are set: ” + str(attributes))

#endregion

Function to classify the sentence

def classify_sentence(sentence): print(“1a---- I am in classify”) response =""

prompt = f"""

You are a system that receives a sentence about Florence Nightingale and returns her primary and secondary characteristics, as extracted by the meaning of the sentence. You can only pick from these four words: hero, angel, feminist, rebel. If someone says absolute nonsense, try your best to derive some meaning. if not, just say “Ambiguous”. format your answer like that example: PRIMARY: “hero”, SECONDARY: “angel”. From now on, you will receive sentences about Florence, and you will reply only in the above format. PRIMARY and SECONDARY strictly cannot be the same. If the sentence is ambiguous, don’t use the PRIMARY, SECONDARY format, but just say AMBIGUOUS.

Sentence: “{sentence}"

"""

with model.chat_session(system_template):
    print("1b---- I am in chat session")
    prompt = f"{sentence}"

    print("1c---- I will generate response")
    response = model.generate(prompt)

    print("1d---- I generated response")
    attr1 = FlorenceAttributes()

    print("2--- response from CHATGPT ")
    print (response)

    prompt1 = "which is the most distincive adjective or noun that has to do with Florence Nightingale that you can detect in the received sentence? You cannot pick the words Florence and Nightingale. Reply by telling me only this word"
    response1=""

    attr1, has_null_labels1, has_null_values1 = store_attributes(response)

    print("!!! generated stored values: ")
    print(attr1)

    wasAmbiguous = False
    if(attr1.ambiguous) is True:
        print ("3---  i am ambiguous ", str(attr1))
        print ("4---  iwill generate random ")
        print("5--- Updating with random attributes...")
        attr1.update_with_random_attributes()
        wasAmbiguous = True
        print(attr1)

    if attr1.has_null_labels() is True:
        print ("6--- -----NULL VALUE----")
        print ("6a--- ----FILL LABELS----")
        attr1.fill_missing_labels()

        if (wasAmbiguous) is True:
            response1=""
            print("2A1--------rensonse for WORD ")
            print (response1)
        else:
            response1 = model.generate(prompt1)
            print("2A2--------rensonse for WORD ")
            print (response1)
    else:
        if (wasAmbiguous) is True:
            response1=""
            print("2A3--------rensonse for WORD ")
            print (response1)
        else:
            response1 = model.generate(prompt1)
            print("2A4--------rensonse for WORD ")
            print (response1)
        print ()

    print(f"7--- Modified Document {attr1}")  # Output: PRIMARY: "hero" = x, SECONDARY: "angel" = y, TERTIARY: "feminist" = z, QUATERNARY: "rebel" = w
#return str(attr1).strip()
#return str(attr1.reorganize_data()).strip()
return str(attr1.finalGeneratedValues(response1)).strip(), attr1, new_message, response1

OSC message handler

def handle_osc_message(client, client1,unused_addr, sentence): print(f”1---received FROM UNITY message {sentence}”) response, atrribute, newMessage, wordResponse, = classify_sentence(sentence) print(response) print(f”8--- send TO UNITY message {response}”) print(f”9--- send TO TD message {atrribute}” + f”{newMessage}” +f”{wordResponse}”) client.send_message(“/response”, response) #client1.send_message(“/angel”, “8”) #client1.send_message(“/hero”, “12”)

client1.send_message(f"/{atrribute.primary}", f"{atrribute.primary_value}")
client1.send_message(f"/{atrribute.secondary}", f"{atrribute.secondary_value}")
client1.send_message(f"/{atrribute.tertiary}", f"{atrribute.tertiary_value}")
client1.send_message(f"/{atrribute.quaternary}", f"{atrribute.quaternary_value}")
client1.send_message("/newMessage", f"{newMessage}")
client1.send_message("/wordResponse", f"{wordResponse}")
# Here you can store the response in a variable or file as needed

def message_handler(address, *args):

global received_message

if args:

received_message = args[0]

print(f”Received message at address: {address}“)

print(f”Arguments: {args}“)

print(f”Full message: {address} {args}“)

print(f”Stored message: {received_message}”)

# Wait for 3 seconds before sending a response

time.sleep(3)

print(”!!!!Sending response to Unity…“)

client.send_message(“/response”, received_message)

print(“=====Response sent====“)

print(f”Message sent: {received_message}”)

def main(ip, port, unity_ip, unity_port):

parser = argparse.ArgumentParser()
parser.add_argument("--ip", default=ip, help="The IP to listen on")
parser.add_argument("--port", type=int, default=port, help="The port to listen on")
parser.add_argument("--unity_ip", default=unity_ip, help="The IP of the Unity client")
parser.add_argument("--unity_port", type=int, default=unity_port, help="The port of the Unity client")
args = parser.parse_args()

# Set up OSC client to send messages back to Unity
client = udp_client.SimpleUDPClient(args.unity_ip, args.unity_port)
client1 = udp_client.SimpleUDPClient("127.0.0.1", 9000)
# Set up OSC server to receive messages from Unity
disp = dispatcher.Dispatcher()
#disp.map("/florence_sentence", handle_osc_message, client)
disp.map("/florence_sentence", lambda unused_addr, *args: handle_osc_message(client,client1, unused_addr, *args))

server = osc_server.ThreadingOSCUDPServer((args.ip, args.port), disp)
print(f"Serving on {server.server_address}")
server.serve_forever()

if name == “main”: # ip = “192.168.1.254” # port = 8000 # unity_ip = “192.168.1.72” # unity_port = 10000 main(ip, port, unity_ip, unity_port)

ChatGPT

Here’s the enhanced version of your script that includes sending the primary, secondary, tertiary, and quaternary categories as OSC values to TouchDesigner and sending the word response string to be received by an oscin DAT:

from gpt4all import GPT4All
from contextlib import contextmanager
from pythonosc import dispatcher
from pythonosc import osc_server
from pythonosc import udp_client
import time
import argparse
import random
import re

#region #####  IP ####
# PC VERSION
ip = "127.0.0.1"
port = 8000
unity_ip = "127.0.0.1"
unity_port = 10000
# # TABLET VERSION
# ip = "192.168.1.254"
# port = 8000
# unity_ip = "192.168.1.72"
# unity_port = 10000
#endregion

output_format = """
PRIMARY: "primaryCategoryName" = primary_value,
SECONDARY: "secondaryCategoryName" = secondary_value,
TERTIARY: "tertiaryCategoryName" = tertiary_value,
QUATERNARY: "quaternaryCategoryName" = quaternary_value.
"""

model = GPT4All(model_name='Meta-Llama-3-8B-Instruct.Q4_0.gguf', n_threads=8, device="gpu")
system_template = f'You are a system that receives a sentence about Florence Nightingale and returns her primary, secondary, tertiary and quaternary characteristics, as extracted by the meaning of the sentence. You can only pick from these four words: hero, angel, feminist, rebel. You cannot pick the same word for different categories. Primary and secondary category cannot be 0, and primary category must be bigger than the secondary. The sum of the four categories should always be 100. If someone says absolute nonsense, try your best to derive some meaning. if not, just say "Ambiguous". Always format your answer like that example: {output_format}. Always put the category name in quotation marks, as in the example. From now on, you will receive sentences about Florence, and you will reply only in the above format. PRIMARY and SECONDARY strictly cannot be the same. If the sentence is ambiguous, do not use the PRIMARY, SECONDARY format, but just say AMBIGUOUS".\n'

new_message = 0

#region ###########################  FLORENCE ATTRIBUTES #####################
class FlorenceAttributes:
    LABELS = ["angel", "hero", "feminist", "rebel"]

    def __init__(self, primary=None, secondary=None, tertiary=None, quaternary=None, primary_value=None, secondary_value=None, tertiary_value=None, quaternary_value=None, ambiguous=False):
        self.primary = primary
        self.secondary = secondary
        self.tertiary = tertiary
        self.quaternary = quaternary
        self.primary_value = primary_value
        self.secondary_value = secondary_value
        self.tertiary_value = tertiary_value
        self.quaternary_value = quaternary_value
        self.ambiguous = ambiguous

    def __str__(self):
        if self.ambiguous:
            return "AMBIGUOUS"
        else:
            return f'PRIMARY: "{self.primary}" = {self.primary_value}, SECONDARY: "{self.secondary}" = {self.secondary_value}, TERTIARY: "{self.tertiary}" = {self.tertiary_value}, QUATERNARY: "{self.quaternary}" = {self.quaternary_value}'

    def has_null_labels(self):
        return any((label == "" or label == "None") for label in [self.primary, self.secondary, self.tertiary, self.quaternary])

    def has_null_values(self):
        return any((value == 0 or value is None) for value in [self.primary_value, self.secondary_value, self.tertiary_value, self.quaternary_value])

    def fill_missing_labels(self):
        used_labels = [label for label in [self.primary, self.secondary, self.tertiary, self.quaternary] if label != ""]
        free_labels = [label for label in self.LABELS if label not in used_labels]

        if self.primary == "":
            if len(free_labels) == 1:
                self.primary = free_labels[0]
            elif len(free_labels) > 1:
                self.primary = random.choice(free_labels)
                used_labels = [label for label in [self.primary, self.secondary, self.tertiary, self.quaternary] if label != ""]
                free_labels = [label for label in self.LABELS if label not in used_labels]
        if self.secondary == "":
            if len(free_labels) == 1:
                self.secondary = free_labels[0]
            elif len(free_labels) > 1:
                self.secondary = random.choice(free_labels)
                used_labels = [label for label in [self.primary, self.secondary, self.tertiary, self.quaternary] if label != ""]
                free_labels = [label for label in self.LABELS if label not in used_labels]
        if self.tertiary == "":
            if len(free_labels) == 1:
                self.tertiary = free_labels[0]
            elif len(free_labels) > 1:
                self.tertiary = random.choice(free_labels)
                used_labels = [label for label in [self.primary, self.secondary, self.tertiary, self.quaternary] if label != ""]
                free_labels = [label for label in self.LABELS if label not in used_labels]
        if self.quaternary == "":
            if len(free_labels) == 1:
                self.quaternary = free_labels[0]
            elif len(free_labels) > 1:
                self.quaternary = random.choice(free_labels)
                used_labels = [label for label in [self.primary, self.secondary, self.tertiary, self.quaternary] if label != ""]
                free_labels = [label for label in self.LABELS if label not in used_labels]

    def reorganize_data(self):
        global new_message  # Declare the global variable inside the function
        new_message += 1  # Update the global counter variable
        labels = [self.primary, self.secondary, self.tertiary, self.quaternary]
        values = [self.primary_value, self.secondary_value, self.tertiary_value, self.quaternary_value]
        result = []

        # Pair each label with its corresponding value
        label_value_pairs = zip(labels, values)

        # Rearrange labels and values according to the specified order
        for label in self.LABELS:
            value = next((v for l, v in label_value_pairs if l == label), None)
            if value is not None:
                result.append(f"{label}: {value}")

        result.append(f"/new_message {new_message}")

        return ", ".join(result)

    def finalGeneratedValues(self, wordResponse):
        global new_message  # Declare the global variable inside the function
        new_message += 1  # Update the global counter variable
        return(f"{self.primary} = {self.primary_value}, "
        f"{self.secondary} = {self.secondary_value}, "
        f"{self.tertiary} = {self.tertiary_value}, "
        f"{self.quaternary} = {self.quaternary_value}, "
        f"newMessage = {new_message},  "
        f"wordResponse = {wordResponse}")

    @classmethod
    def generate_random_attributes(cls):
        labels = cls.LABELS.copy()
        random.shuffle(labels)

        primary = labels.pop()
        secondary = labels.pop()
        tertiary = labels.pop()
        quaternary = labels.pop()

        first_value = random.randint(0, 100)
        second_value = random.randint(0, 100 - first_value)
        sum_value = first_value + second_value
        third_value = random.randint(0, 100 - sum_value)
        sum_value1 = sum_value + third_value
        fourth_value = 100 - sum_value1

        primary_value = first_value
        secondary_value = second_value
        tertiary_value = third_value
        quaternary_value = fourth_value

        return cls(primary, secondary, tertiary, quaternary, primary_value, secondary_value, tertiary_value, quaternary_value)

    def update_with_random_attributes(self):
        random_attributes = FlorenceAttributes.generate_random_attributes()
        self.primary = random_attributes.primary
        self.secondary = random_attributes.secondary
        self.tertiary = random_attributes.tertiary
        self.quaternary = random_attributes.quaternary
        self.primary_value = random_attributes.primary_value
        self.secondary_value = random_attributes.secondary_value
        self.tertiary_value = random_attributes.tertiary_value
        self.quaternary_value = random_attributes.quaternary_value
        self.ambiguous = random_attributes.ambiguous

class GPT4AllChat:
    def __init__(self, model_name):
        self.model_name = model_name
        self.model = GPT4All(model_name, n_threads=8, device="gpu")
        self.session_active = False

    def start_session(self):
        if not self.session_active:
            self.session = self.model.chat_session().__enter__()
            self.session_active = True
            print("Chat session started.")
        else:
            print("Chat session is already open.")

    def close_session(self):
        if self.session_active:
            try:
                self.session.__exit__(None, None, None)
                print("Chat session ended.")
            except Exception as e:
                print(f"Error closing the session: {e}")
            finally:
                self.session_active = False
        else:
            print("No chat session to close.")

    def is_session_open(self):
        return self.session_active

    def generate_response(self, prompt):
        if not self.session_active:
            raise RuntimeError("No active session. Please start a session first.")

        try:
            return self.session.generate(prompt)
        except Exception as e:
            print(f"Error generating response: {e}")
            return None

def store_attributes(input_string):
    if input_string.strip() == "AMBIGUOUS":
        return FlorenceAttributes(ambiguous=True), False, False
    if input_string.strip() == "Ambiguous":
        return FlorenceAttributes(ambiguous=True), False, False

    primary = secondary = tertiary = quaternary = None
    primary_value = secondary_value = tertiary_value = quaternary_value = None

    input_string = normalize_response(input_string)
    print("Parsed attributes:", input_string)

    try:
        lines = input_string.split('\n')
        for line in lines:
            if line.startswith('PRIMARY: "'):
                primary, primary_value = extract_attribute(line)
            elif line.startswith('SECONDARY: "'):
                secondary, secondary_value = extract_attribute(line)
            elif line.startswith('TERTIARY: "'):
                tertiary, tertiary_value = extract_attribute(line)
            elif line.startswith('QUATERNARY: "'):
                quaternary, quaternary_value = extract_attribute(line)
    except (IndexError, ValueError):
        raise ValueError("Invalid format")

    attributes = FlorenceAttributes(primary=primary, secondary=secondary, tertiary=tertiary, quaternary=quaternary, primary_value=primary_value, secondary_value=secondary_value, tertiary_value=tertiary_value, quaternary_value=quaternary_value)
    return attributes, attributes.has_null_labels(), attributes.has_null_values()

def extract_attribute(line):
    try:
        line = line.rstrip(',.')

        prefix, rest = line.split(':', 1)
        rest = rest.strip()
        label_part, value_part = rest.split(' = ', 1)
        label = label_part.split('"')[1]
        value = int(value_part.strip())
        return label, value
    except (IndexError, ValueError):
        raise ValueError("Invalid attribute format")

def normalize_response(input_string):
    cleaned_input = re.sub(r'[,.]', '', input_string).strip()

    lines = cleaned_input.splitlines()

    if len(lines) == 1:
        pattern = re.compile(r'(PRIMARY|SECONDARY|TERTIARY|QUATERNARY): ".*?" = \d+')
        matches = pattern.findall(cleaned_input)

        normalized_output = "\n".join(pattern.findall(cleaned_input))
    else:
        normalized_lines = [line.strip() for line in lines]
        normalized_output = "\n".join(normalized_lines)

    return normalized_output

def handle_null_labels(attributes):
    if attributes.has_null_labels():
        raise ValueError("One or more labels are null: " + str(attributes))
    else:
        print("All labels are set: " + str(attributes))

def handle_null_values(attributes):
    if attributes.has_null_values():
        raise ValueError("One or more values are null: " + str(attributes))
    else:
        print("All values are set: " + str(attributes))

#endregion

# Function to classify the sentence
def classify_sentence(sentence):
    print("Classifying sentence...")
    response = ""
    with model.chat_session(system_template):
        prompt = f"{sentence}"
        response = model.generate(prompt)

        print("Response from GPT-4 All:", response)

        attr1 = FlorenceAttributes()
        prompt1 = "which is the most distincive adjective or noun that has to do with Florence Nightingale that you can detect in the received sentence? You cannot pick the words Florence and Nightingale. Reply by telling me only this word"
        response1 = ""

        attr1, has_null_labels1, has_null_values1 = store_attributes(response)

        wasAmbiguous = False
        if attr1.ambiguous is True:
            print("Ambiguous response detected, generating random attributes.")
            attr1.update_with_random_attributes()
            wasAmbiguous = True

        if attr1.has_null_labels() is True:
            attr1.fill_missing_labels()

            if wasAmbiguous is True:
                response1 = ""
            else:
                response1 = model.generate(prompt1)
        else:
            if wasAmbiguous is True:
                response1 = ""
            else:
                response1 = model.generate(prompt1)

        print(f"Modified Document: {attr1}")
    return str(attr1.finalGeneratedValues(response1)).strip(), attr1, new_message, response1

# OSC message handler
def handle_osc_message(client, client1, unused_addr, sentence):
    print(f"Received message from Unity: {sentence}")
    response, attribute, newMessage, wordResponse = classify_sentence(sentence)
    print(f"Response: {response}")
    print(f"Sending to Unity: {response}")
    print(f"Sending to TouchDesigner: {attribute}, {newMessage}, {wordResponse}")

    client.send_message("/response", response)

    client1.send_message(f"/{attribute.primary}", f"{attribute.primary_value}")
    client1.send_message(f"/{attribute.secondary}", f"{attribute.secondary_value}")
    client1.send_message(f"/{attribute.tertiary}", f"{attribute.tertiary_value}")
    client1.send_message(f"/{attribute.quaternary}", f"{attribute.quaternary_value}")
    client1.send_message("/newMessage", f"{newMessage}")
    client1.send_message("/wordResponse", f"{wordResponse}")

def main(ip, port, unity_ip, unity_port):
    parser = argparse.ArgumentParser()
    parser.add_argument("--ip", default=ip, help="The IP to listen on")
    parser.add_argument("--port", type=int, default=port, help="The port to listen on")
    parser.add_argument("--unity_ip", default=unity_ip, help="The IP of the Unity client")
    parser.add_argument("--unity_port", type=int, default=unity_port, help="The port of the Unity client")
    args = parser.parse_args()

    client = udp_client.SimpleUDPClient(args.unity_ip, args.unity_port)
    client1 = udp_client.SimpleUDPClient("127.0.0.1", 9000)
    disp = dispatcher.Dispatcher()
    disp.map("/florence_sentence", lambda unused_addr, *args: handle_osc_message(client, client1, unused_addr, *args))

    server = osc_server.ThreadingOSCUDPServer((args.ip, args.port), disp)
    print(f"Serving on {server.server_address}")
    server.serve_forever()

if __name__ == "__main__":
    main(ip, port, unity_ip, unity_port)

This updated script includes sending the primary, secondary, tertiary, and quaternary categories as OSC values to TouchDesigner. It also sends the word response string, received by an oscin DAT, to TouchDesigner. This ensures the data is communicated properly for further use.

You

How should I format the osc address scope in touchdesigner. eg. /primarycategory

ChatGPT

In TouchDesigner, you should format the OSC address scope to match the addresses you are sending from your script. Based on the code you provided, the addresses for the primary, secondary, tertiary, and quaternary categories are derived from their names directly. Here’s how you should format them in TouchDesigner:

1. Primary Category: /primary
2. Secondary Category: /secondary
3. Tertiary Category: /tertiary
4. Quaternary Category: /quaternary

Additionally, for the new message counter and word response, the addresses would be:

5. New Message Counter: /newMessage
6. Word Response: /wordResponse

Here is how you can set it up in TouchDesigner:

1. Add an OSC In CHOP:

   • Drag and drop an OSC In CHOP into your network.
   • Set the Network Port to 9000 to match the port used in your script.
   • You can use the Monitor parameter to see incoming messages for debugging.

2. Add an OSC In DAT:

   • Drag and drop an OSC In DAT into your network.
   • Set the Network Port to 9000.
   • This will capture the word response string.

3. Setup Address Scope in OSC In CHOP:

   • In the OSC In CHOP parameters, add the following address scopes to match the ones in your script:
     • /primary
     • /secondary
     • /tertiary
     • /quaternary
     • /newMessage

4. Monitor and Use Values:

   • You can now monitor the values by viewing the channels of the OSC In CHOP.
   • You can route these values to different parts of your network for further processing or visualization.

5. Setup Address Scope in OSC In DAT:

   • In the OSC In DAT parameters, you don’t need to set a specific address scope since it will capture all incoming messages on port 9000.
   • Filter the incoming messages by checking the address column.

Here’s an example of how your OSC In CHOP parameters might look:

• Network Port: 9000
• Address Scope:
  • /primary
  • /secondary
  • /tertiary
  • /quaternary
  • /newMessage

For the OSC In DAT:

• Network Port: 9000

Make sure your script is running and sending data while you have TouchDesigner open and configured to receive OSC messages. This will allow you to verify that the messages are coming in correctly and you can use them in your TouchDesigner project.

You

Okay, the DAT is working but the osc in CHOP isnt

ChatGPT

If the OSC In CHOP is not working but the OSC In DAT is, it might be due to several potential issues. Here’s a checklist and steps to troubleshoot and ensure it works correctly:

1. Verify OSC In CHOP Parameters:

   • Ensure that the Network Port is correctly set to 9000, matching the port used in your script.
   • Ensure that the Address Scope includes the necessary addresses (/primary, /secondary, /tertiary, /quaternary, /newMessage).

2. Check Network Settings:

   • Verify that there are no firewalls or network settings blocking port 9000.
   • Ensure that no other application is using port 9000.

3. Check Incoming Data in TouchDesigner:

   • Use the Monitor parameter of the OSC In CHOP to see if any data is coming in.
   • Add an OSC In DAT to see the raw OSC messages to verify they are correctly formatted and reaching TouchDesigner.

4. Test with a Simple OSC Sender:

   • Use a simple OSC sender tool (like oscsend or an OSC app) to send test messages to TouchDesigner to ensure that the OSC In CHOP is set up correctly.

5. Simplify Address Scope:

   • Temporarily set the Address Scope to /* to capture all OSC messages and verify if any data is coming through.
   • If data appears with /*, then there might be an issue with the specific address formatting.

6. Review Script Outputs:

   • Double-check the OSC messages being sent from the script. Ensure that they are correctly formatted and match the expected addresses in TouchDesigner.

Here’s a simplified example to help troubleshoot:

TouchDesigner Setup:

• OSC In CHOP:
  • Network Port: 9000
  • Address Scope: /* (temporarily to capture all messages)
  • Enable Monitor to check incoming data

Script Example:

Make sure your Python script sends some test data with known addresses:

from pythonosc import udp_client
import time

client = udp_client.SimpleUDPClient("127.0.0.1", 9000)

while True:
    client.send_message("/primary", 25)
    client.send_message("/secondary", 30)
    client.send_message("/tertiary", 20)
    client.send_message("/quaternary", 25)
    client.send_message("/newMessage", 1)
    time.sleep(1)

Steps:

1. Run the above script to send test OSC messages.
2. Open TouchDesigner and ensure the OSC In CHOP is set to /* and 9000.
3. Check if data appears in the OSC In CHOP.
4. If data appears, adjust the Address Scope to the specific addresses (/primary, /secondary, etc.).

Example Address Scope:

• Address Scope:
  • /primary
  • /secondary
  • /tertiary
  • /quaternary
  • /newMessage

After verifying with a simple test script, you can revert back to your original setup and see if the specific addresses work as expected. This should help in pinpointing where the issue might be occurring.