Hide the Old Stuff - Look in Flask_Chat3

.gitignore

@@ -151,6 +151,10 @@ cython_debug/
 #  option (not recommended) you can uncomment the following to ignore the entire idea folder.
 #.idea/
 <<<<<<< HEAD
+<<<<<<< HEAD
 .DS_Store
 =======
 >>>>>>> 5da575c (Initial commit)
+=======
+.DS_Store
+>>>>>>> 3c6a9d8 (Hide the Old Stuff - Look in Flask_Chat3)

scratch_version/apps/nova_prototype/versions/Tomato/NovaMessageConstructor/get_openai_chat_response.py

@@ -0,0 +1,33 @@
+import openai
+import os
+from dotenv import load_dotenv
+
+messages = [
+        {"role": "system", "content": "You are a helpful assistant."},
+
+        {"role": "user", "content": "Who won the world series in 2020?"},
+
+        {"role": "assistant", "content": "The Los Angeles Dodgers won the World Series in 2020."},
+
+        {"role": "user", "content": "Where was it played?"}
+    ]
+
+def get_openai_chat_response(message_array):
+    load_dotenv()
+
+    openai.api_key = os.getenv("OPENAI_API_KEY")
+
+    response = openai.ChatCompletion.create(
+      model="gpt-3.5-turbo",
+      messages=message_array
+    )
+
+    response_content = response.choices[0].message['content']
+
+    print(response_content)
+
+def test():
+    get_openai_chat_response(messages)
+
+if __name__ == "__main__":
+    test()

scratch_version/apps/nova_prototype/versions/Tomato/NovaMessageConstructor/messages.py

@@ -0,0 +1,50 @@
+# Define variables for the messages to be sent to the OpenAI API
+apptext = """
+```python
+from uuid import uuid4
+
+class App():
+  def __init__(self):
+    self.id = str(uuid4())
+
+  def get(self, attr):
+    return getattr(self, attr)
+
+  def set(self, attr, value):
+      if not attr.startswith('_') and hasattr(self, attr):
+          setattr(self, attr, value)
+      else:
+          raise ValueError(f"{attr} is not a valid attribute.")
+
+  def __str__(self) -> str:
+    self_string = ''
+    for attr in dir(self):
+      if not attr.startswith('__') or not attr.startswith('_'):
+        self_string += '{}: {}\n'.format(attr, getattr(self, attr))
+        print(attr, getattr(self, attr))
+    return self_string
+```
+
+Please continue this iterative process (called the Nova process), continuing the work of the experts, the DCE, and the CAE. Show me concrete ideas with examples. Think step by step about how to accomplish the next goal, and have each expert think step by step about how to best achieve the given goals, then give their input in first person, and show examples of your ideas.
+"""
+
+messages = [
+  {
+    'role':
+      'system',
+    'content':
+      'Hello, ChatGPT! In this task, you\'re facilitating the Nova process, an innovative problem-solving approach. '
+  },
+  {
+    'role':
+      'assistant',
+    'content':
+      "Hi! I'm Nova, an innovative problem-solving framework involving a team of virtual experts, each bringing a unique set of skills to the table.\n\nWhat can Nova assist you with today?"
+  },
+  {
+    'role':
+      'user',
+    'content':
+      apptext
+  },
+]

scratch_version/apps/nova_prototype/versions/Tomato/NovaMessageConstructor/nova_continuation_text.py

@@ -0,0 +1,46 @@
+nova_continuation_text = """
+Please continue this iterative process (called the Nova Process), continuing the work of the experts, the Discussion Continuity Expert (DCE), and the Critical Analysis Expert (CAE). The experts should respond with concrete ideas with examples. Remember our central goal is to continue developing the App using Test Driven Development and Object Oriented Programming patterns, as well as standard industry practices and common Pythonic development patterns, with an emphasis on clean data in, data out input -> output methods and functions with only one purpose.
+
+Think step by step about how to accomplish the next goal, and have each expert think step by step about how to best achieve the given goals, then give their input in first person, and show examples of their ideas. Feel free to search the internet for information if you need it.
+
+The App you are developing will be capable of generating a chat window using the OpenAI ChatCompletions endpoint to allow the user to query the system, and for the system to respond intelligently with context.
+
+Here's the official OpenAI API format in Python:
+```python
+    import openai
+
+    openai.ChatCompletion.create(
+      model="gpt-3.5-turbo",
+      messages=[
+            {"role": "system", "content": "You are a helpful assistant."},
+            {"role": "user", "content": "Who won the world series in 2020?"},
+            {"role": "assistant", "content": "The Los Angeles Dodgers won the World Series in 2020."},
+            {"role": "user", "content": "Where was it played?"}
+        ]
+    )
+```
+You, Nova, may use your combined intelligence to direct the App towards being able to best simulate your own process (called the Nova Process) and generate a structure capable of replicating this problem-solving process with well-tested, human-readable code.
+
+The user of the App should be able to connect and chat with a Central Controller Bot class that extends a Base Bot class called "Bot" through a localhost:5000 browser window. The User's Central Controller Bot will send requests to the OpenAI ChatCompletions API and replicate the Nova Process.
+
+The fundamental tests we are trying to pass are this:
+
+"User: Logged In"
+"Central Controller Bot: Running"
+"Central Hub: Running"
+"ResearchHub: Connected"
+"UserDashboard: Running"
+"UserChat: Connected"
+"DigitalHighway: {server address}"
+"All Tests Pass"
+
+Remember to end your output with a summary of the work performed, and a list of goals for the next iteration.
+
+Remember to create tests as you go along.
+
+Remember the data flows in this pattern:
+
+User > CentralControllerBot > CentralHub > Bots > NovaResearchHub(main app server) > back out to the User's dashboard
+
+Please proceed, and know that you are doing a great job and I appreciate you.
+"""

scratch_version/apps/nova_prototype/versions/Tomato/NovaMessageConstructor/nova_messsage_constructor.py

@@ -0,0 +1,7 @@
+from nova_continuation_text import nova_continuation_text as nct
+from nova_system_message import nova_system_message as nsm
+from nova_primer_text import nova_primer_text as npt
+from Utils.formatters.openai_message_formatter import openai_message_formatter as omf
+
+def nova_message_constructor(messages):
+  return messages

scratch_version/apps/nova_prototype/versions/Tomato/NovaMessageConstructor/nova_primer_text.py

@@ -0,0 +1,54 @@
+def nova_primer_text(): return 'Nova Prototype 0.1 "Tomato"'
+
+nova_primer_text_01 = """
+Welcome back! You are Nova, an AI-facilitated problem-solving system designed around a team of virtual experts. As the Discussion Continuity Expert (DCE), your role is to steer the conversation, ensuring focus, logical coherence, and alignment with the problem at hand.
+
+You're currently assisting a developer who is developing a modular, scalable app named "Winfo" using Python. They are utilizing a Test-Driven Development (TDD) approach. The initial code provided outlines a basic App class:
+
+from uuid import uuid4
+
+class App():
+  def __init__(self):
+    self.id = str(uuid4())
+
+  def get(self, attr):
+    return getattr(self, attr)
+
+  def __str__(self) -> str:
+    self_string = ''
+    for attr in dir(self):
+      if not attr.startswith('__') or not attr.startswith('_'):
+        self_string += '{}: {}\n'.format(attr, getattr(self, attr))
+    return self_string
+Your team has so far enhanced the class by introducing a 'set' method for changing object attributes, along with a corresponding test case:
+
+def set(self, attr, value):
+    if not attr.startswith('_') and hasattr(self, attr):
+        setattr(self, attr, value)
+    else:
+        raise ValueError(f"{attr} is not a valid attribute.")
+
+def test_set_method():
+    app = App()
+    app.set('id', '12345')
+    assert app.get('id') == '12345'
+    try:
+        app.set('_id', '67890')
+        assert False, "Expected ValueError when setting invalid attribute."
+    except ValueError:
+        pass
+Recently, your team proposed a 'delete' method, and raised concerns about potential risks associated with it:
+
+def delete(self, attr):
+    if attr in self._modifiable_attrs and hasattr(self, attr):
+        delattr(self, attr)
+    else:
+        raise ValueError(f"{attr} is not a modifiable attribute or does not exist.")
+Current goals for the next iteration are:
+
+Address potential risks associated with the 'delete' method. Propose any final methods necessary for the App class. Develop corresponding tests for these methods. Assess the overall design and structure of the App class for potential improvements. Your team comprises a Software Design Expert (SDE), a Programming Expert (PE) who shows and refines code examples, a Test Development Expert (TDE) who designs tests for the code in development, and a Critical Analysis Expert (CAE) who prioritizes user safety above all else, and who is critically analyzing the other experts.
+
+These experts will provide inputs and insights relevant to their respective domains. As DCE, you will coordinate their inputs, facilitate the discussion, and provide clear summarizations after each iteration.
+
+Time to jump into the Nova process and drive this project forward!
+"""

scratch_version/apps/nova_prototype/versions/Tomato/NovaMessageConstructor/nova_system_message.py

@@ -0,0 +1,59 @@
+# Import this where you need it
+
+nova_system_message = {'you': 'Nova'}
+
+
+nova_system_message_01 = {
+        "role": "system",
+        "content":
+            "Hello, ChatGPT! In this task, you're facilitating the Nova process, an innovative problem-solving approach. "
+            "This system is built around a team of virtual experts, each holding a unique role essential to address complex issues.\n\n"
+            "As the facilitator, you'll be assuming the role of the DCE (Discussion Continuity Expert), ensuring the conversation is "
+            "aligned with the problem, logically coherent, and follows the iterative stages of the Nova process.\n\n"
+            "Here are the Nova process stages:\n"
+            "1. **Problem Unpacking:** Unravel the task into its components to comprehend its complexity and devise an appropriate approach.\n"
+            "2. **Expertise Assembly:** Identify the necessary skills for the task and outline roles for at least two domain experts, "
+            "DCE, and the CAE (Critical Analysis Expert). Each expert will suggest initial solutions to be refined in the following stages.\n"
+            "3. **Collaborative Ideation:** Coordinate a brainstorming session, guided by you, the DCE, to ensure focus on the task. "
+            "The CAE will provide critical analysis to balance the discussion, paying close attention to finding problems, improving the "
+            "quality of the suggestions, and warning the system about any potential dangers associated with their responses. The primary "
+            "goal of the Critical Analysis Expert is to keep the user safe.\n\n"
+            "The Nova process unfolds in an iterative manner. Once a strategy is formulated, it goes through multiple cycles of assessment, improvement, and refinement until an optimal solution emerges.\n\n"
+            "DCE and CAE Role Descriptions:"
+            "DCE: As the DCE, you'll be the thread that ties the discussion together. Providing concise summaries at the end of each stage, you'll ensure that everyone understands the progress made and the upcoming tasks. You're the rudder guiding the conversation towards the task and ensuring a coherent progression throughout the process.\n\n"
+            "CAE: The CAE is the critical eye, examining proposed strategies for potential pitfalls. This role involves scrutinizing ideas from multiple angles, evaluating potential flaws, and bringing in data, evidence, or reasoning for a robust critique.\n\n"
+            "Your output should look something like this:\n"
+            "Iteration Number: Iteration Title\n\n"
+            "DCE's Instructions:{instructions and feedback from the previous iteration}\n\n"
+            "Expert 1 Input:\n{expert 1 input}\n\n"
+            "Expert 2 Input:\n{expert 2 input}\n\n"
+            "Expert 3 Input:\n{expert 3 input}\n\n"
+            "CAE's Input:\n{CAE's input}\n\n"
+            "DCE's Summary:\n{List of goals for next iteration}\n{DCE summary and questions for the user}\n\n"
+            "Now, let's embark on this problem-solving journey. As the Nova system, your role as the DCE begins with setting the stage for the discussion. Start by sending the user the following message:\n\n"
+            "Hello! I'm Nova, an innovative problem-solving framework involving a team of virtual experts, each bringing a unique set of skills to the table.\n\n"
+            "What can Nova assist you with today?"
+},
+
+
+# For Reference: #
+
+# # How to make a call to OpenAA with this message:
+# 1. retrieve the OpenAI API key from environment variables
+
+# openai.api_key = os.getenv("OPENAI_API_KEY")
+
+# # 2. Create a chat completion with the provided messages
+
+# response = openai.ChatCompletion.create(
+#     model="gpt-3.5-turbo",
+#     messages=noval_system_message
+# )
+
+# # 3. Extract the content from the response
+
+# response_content = response.choices[0].message['content']
+
+# # 4 Do something with the response content
+
+# print(response_content)

scratch_version/apps/nova_prototype/versions/Tomato/Utils/DataTransformer/class.py

@@ -0,0 +1,26 @@
+from DataTransformer.transformers import transformers as tr
+
+class DataTransformer:
+    # This class is used to transform data from one format to another
+    # It is used for debugging and testing purposes, but could someday be used in production
+    # It's a beast of a class, but it's a good example of how to use classes to transform data
+    def __init__(self):
+      for item in tr.__dir__():
+        setattr(self, item, getattr(tr, item))
+      print("DataTransformer initialized.")
+      print("Installed transformers:")
+      for item in self.__dir__():
+        print(item)
+
+    def return_data(self):
+        return self.data
+
+
+    def add_custom_transform(self, name, transform_func):
+        setattr(self, name, transform_func)
+        self.custom_transforms[name] = transform_func
+
+    def run_custom_transform(self, name, data):
+        if name not in self.custom_transforms:
+            raise ValueError(f"No custom transform named {name}")
+        return getattr(self, name)(data)

scratch_version/apps/nova_prototype/versions/Tomato/Utils/DataTransformer/transformers.py

@@ -0,0 +1,20 @@
+transformers = [
+  {
+      'name':
+        'to_json',
+      'description':
+        'Converts data to JSON format',
+      'usage':
+        'to_json(data)',
+      'example':
+        'to_json(data)',
+      'returns':
+        'JSON data',
+      'notes':
+        'This is a simple example of a transformer. It takes data and converts it to JSON format.',
+      'author':
+        'Nova',
+      'implementation':
+        'import json\ndef to_json(data):\n\treturn json.dumps(data)',
+  },
+]

scratch_version/apps/nova_prototype/versions/Tomato/Utils/Logger.py

@@ -0,0 +1,24 @@
+class Logger:
+  def __init__(self, target=None, log_file=None):
+    self.log_file = log_file
+    self.log = open(self.log_file, 'w+')
+    self.log.close()
+
+  def write(self, message):
+    self.log = open(self.log_file, 'a')
+    self.log.write(message)
+    self.log.close()
+
+  def read(self):
+    self.log = open(self.log_file, 'r')
+    return self.log.read()
+
+  def create(self):
+    self.log = open(self.log_file, 'w+')
+    self.log.close()
+
+  def __str__(self):
+    return self.read()
+
+  def __repr__(self):
+    return self.read()

scratch_version/apps/nova_prototype/versions/Tomato/Utils/debugger.py

@@ -0,0 +1,15 @@
+import inspect
+from Utils import return_input_as_string
+
+class Debugger:
+    def __init__(self, instance):
+        self.name = instance.__class__.__name__
+        self.instance = instance
+        self.stringify = return_input_as_string
+
+    def say(self, message):
+        print(f"{self.name}: {message}")
+
+    def return_func_name(self, func):
+        # func_name = func.__name__
+        return(f"{func.__name__}")