dynamic-learning-model 3.4.1__tar.gz → 3.4.2__tar.gz

{dynamic_learning_model-3.4.1 → dynamic_learning_model-3.4.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dynamic-learning-model
-Version: 3.4.1
+Version: 3.4.2
 Summary: A Dynamic Learning Model for processing NLP queries using hybrid AI and reasoning.
 Home-page: https://github.com/VigneshT24/Dynamic_Learning_Model
 Author: Vignesh Thondikulam

{dynamic_learning_model-3.4.1 → dynamic_learning_model-3.4.2}/dlm/DLM.py

@@ -399,7 +399,7 @@ class DLM:
         if mode.lower() == "learn":
             # trainers must understand these rules as DLM can generate bad responses if these instructions are neglected
             print(
-                f"\n\n{'\033[31m'}MAKE SURE TO UNDERSTAND THE FOLLOWING ANSWER FORMAT EXPECTED FOR EACH CATEGORY FOR THE BOT TO LEARN ACCURATELY:{'\033[0m'}\n")
+                f"\n\nMAKE SURE TO UNDERSTAND THE FOLLOWING ANSWER FORMAT EXPECTED FOR EACH CATEGORY FOR THE BOT TO LEARN ACCURATELY:\n")
             print("*'yesno': Make sure to start your answer responses with \"yes\" or \"no\" ONLY")
             print(
                 "*'process': Each answer must have three steps for your responses, separated by \";\" (semicolon)")
@@ -467,7 +467,7 @@ class DLM:
     # loading animation for bot thought process (deprecated in favor for readability on production)
     def __loading_animation(user_input, duration):  # no return, void
         for seconds in range(0, 3):
-            print(f"{'\033[33m'}\r{user_input}{'.' * (seconds + 1)}   {'\033[0m'}", end="", flush=True)
+            print(f"\r{user_input}{'.' * (seconds + 1)}", end="", flush=True)
             time.sleep(duration)
         print("\n")
 
@@ -588,13 +588,13 @@ class DLM:
             print("\nThought Process (Yellow):")
             if filtered_query is None or filtered_query == "":
                 print(
-                    f"{'\033[33m'}I couldn't pick out any context or clear topic. If I see a match in my database I will respond with that, or else I have no clue!{'\033[0m'}")
+                    f"I couldn't pick out any context or clear topic. If I see a match in my database I will respond with that, or else I have no clue!")
             else:
                 sentiment_tone = self.__tone.split()
 
                 if self.__tone != "":
                     print(
-                        f"{'\033[33m'}Right off the bat, the user seems quite {sentiment_tone[0]} or {sentiment_tone[1]} by their query tone. Hopefully I won't disappoint!{'\033[0m'}")
+                        f"Right off the bat, the user seems quite {sentiment_tone[0]} or {sentiment_tone[1]} by their query tone. Hopefully I won't disappoint!")
                 if self.__model == "compute":
                     perform_advanced_CoT(self, filtered_query, display_thought)
                 else:
@@ -611,10 +611,10 @@ class DLM:
 
                     if " ".join(identifier) == "":
                         print(
-                            f"{'\033[33m'}The user starts their query with \"{interrogative_start.title()}\", but I couldn't pick out a clear topic or context.{'\033[0m'}")
+                            f"The user starts their query with \"{interrogative_start.title()}\", but I couldn't pick out a clear topic or context.")
                     else:
                         print(
-                            f"{'\033[33m'}The user starts their query with \"{interrogative_start.title()}\" and they are asking about \"{" ".join(identifier).title()}\".{'\033[0m'}")
+                            f"The user starts their query with \"{interrogative_start.title()}\" and they are asking about \"{" ".join(identifier).title()}\".")
                     print("Let me think about this carefully...")
 
                     for s in special_start:
@@ -624,30 +624,30 @@ class DLM:
                             if (s_input.vector_norm != 0 and u_input.vector_norm != 0) and (
                                     s_input.similarity(u_input) > 0.60):
                                 print(
-                                    f"{'\033[33m'}It seems like they want a {s} of \"{" ".join(identifier).title()}\".{'\033[0m'}")
+                                    f"It seems like they want a {s} of \"{" ".join(identifier).title()}\".")
 
                     self.__semantic_similarity(self.__special_stripped_query, best_match_question)
                     spacy_proceed = self.__nlp_similarity_value is not None
                     if (best_match_answer is None) or (
                             highest_similarity < 0.65 and (spacy_proceed and self.__nlp_similarity_value < 0.85)):
                         print(
-                            f"{'\033[33m'}The closest match is only {int(highest_similarity * 100)}% similar when I used sequence matching.{'\033[0m'}")
+                            f"The closest match is only {int(highest_similarity * 100)}% similar when I used sequence matching.")
                         if spacy_proceed:
                             print(
-                                f"{'\033[33m'}Furthermore, an in-depth vector analysis revealed a similarity percentage of {int(self.__nlp_similarity_value * 100)}%.{'\033[0m'}")
+                                f"Furthermore, an in-depth vector analysis revealed a similarity percentage of {int(self.__nlp_similarity_value * 100)}%.")
                         print(
-                            f"{'Hmm...' or ''}{'\033[33m'}I don't think I know the answer.{'\033[0m'}")
+                            f"{'Hmm...' or ''}I don't think I know the answer.")
                         self.__unsure_while_thinking = True
                     else:
                         self.__unsure_while_thinking = False
                         DB_identifier = get_specific_question(self, best_match_answer)
                         print(
-                            f"{'\033[33m'}Yes! I do remember learning about \"{DB_identifier}\" and I might have the right answer!")
+                            f"Yes! I do remember learning about \"{DB_identifier}\" and I might have the right answer!")
                         print(
                             f"This is because when I did a sequence similarity calculation to one of the closest match in my database, I found it to be {int(highest_similarity * 100)}% similar.")
                         if spacy_proceed:
                             print(
-                                f"Additionally, doing a more in-depth vector NLP analysis resulted in {int(self.__nlp_similarity_value * 100)}% similarity. Although there is room for error, we will see.{'\033[0m'}")
+                                f"Additionally, doing a more in-depth vector NLP analysis resulted in {int(self.__nlp_similarity_value * 100)}% similarity. Although there is room for error, we will see.")
                         print("Let me recall that answer...")
             print("\n")
         elif self.__model == "compute":
@@ -669,15 +669,13 @@ class DLM:
             - Gracefully handles unrecognized categories or missing data.
         """
         identifier = get_category(self, best_match_question)
-        BLUE = '\033[34m'
-        RESET = '\033[0m'
 
         if identifier is None:
             print("Sorry, I encountered an error on my end. Please try again later.")
             return
 
         if identifier == "generic":
-            print(f"\n{BLUE}{best_match_answer}{RESET}\n")
+            print(f"\n{best_match_answer}\n")
 
         elif identifier == "yesno":
             affirmative_templates = [
@@ -741,7 +739,7 @@ class DLM:
                 else:
                     best_match_answer = best_match_answer.replace("yes ", "", 1)
             response = template.format(best_match_answer)
-            print(f"\n{BLUE}{response}{RESET}\n")
+            print(f"\n{response}\n")
 
         elif identifier == "process":  # when training, make sure there are only 3 steps for "process"
             templates = [
@@ -758,7 +756,7 @@ class DLM:
             ]
             steps = best_match_answer.split("; ")  # steps must be separated by a semicolon
             response = random.choice(templates).format(*steps[:3])
-            print(f"\n{BLUE}{response}{RESET}\n")
+            print(f"\n{response}\n")
 
         elif identifier == "definition":
             # extract just the term by filtering out common definition triggers
@@ -790,7 +788,7 @@ class DLM:
                 "You can think of \"{0}\" as {1}"
             ]
             response = random.choice(templates).format(term, best_match_answer)
-            print(f"\n{BLUE}{response}{RESET}\n")
+            print(f"\n{response}\n")
 
         elif identifier == "deadline":
             raw = best_match_question
@@ -823,7 +821,7 @@ class DLM:
                 "The cutoff for \"{0}\" is {1}"
             ]
             response = random.choice(templates).format(term, best_match_answer)
-            print(f"\n{BLUE}{response}{RESET}\n")
+            print(f"\n{response}\n")
 
         elif identifier == "location":
             templates = [
@@ -844,7 +842,7 @@ class DLM:
             ]
             best_match_answer = best_match_answer.lower()
             response = random.choice(templates).format(best_match_answer)
-            print(f"\n{BLUE}{response}{RESET}\n")
+            print(f"\n{response}\n")
 
         elif identifier == "eligibility":
             templates = [
@@ -866,7 +864,7 @@ class DLM:
             ]
             best_match_answer = best_match_answer.lower()
             response = random.choice(templates).format(best_match_answer)
-            print(f"\n{BLUE}{response}{RESET}\n")
+            print(f"\n{response}\n")
 
         else:
             print("Cannot retrieve and generate response due to data in unfamiliar category. Please try again later.")
@@ -1035,10 +1033,10 @@ class DLM:
                     self.__generate_thought(filtered_query, best_match_question, best_match_answer, highest_similarity,
                                             display_thought)
                     if not self.__successfully_computed:
-                        print(f"{'\033[34m'}{random.choice(self.__fallback_responses)}{'\033[0m'}")
+                        print(f"{random.choice(self.__fallback_responses)}")
                         self.__try_compute = False
                         self.__successfully_computed = False
                 else:
-                    print(f"{'\033[34m'}{random.choice(self.__fallback_responses)}{'\033[0m'}")
+                    print(f"{random.choice(self.__fallback_responses)}")
                     self.__try_compute = False
                     self.__try_memory = False

{dynamic_learning_model-3.4.1 → dynamic_learning_model-3.4.2}/dlm/DLM_Compute_Model.py

@@ -164,10 +164,10 @@ def geometric_calculation(self, filtered_query, display_thought):  # returns flo
     except Exception as e:
         if display_thought:
             print(
-                f"{'\033[33m'}Unable to compute the {object_intel[0]} of the {obj_name} due to missing or mismatched values{'\033[0m'}")
+                f"Unable to compute the {object_intel[0]} of the {obj_name} due to missing or mismatched values")
         else:
             print(
-                f"{'\033[34m'}Unable to compute the {object_intel[0]} of the {obj_name} due to missing or mismatched values{'\033[0m'}")
+                f"Unable to compute the {object_intel[0]} of the {obj_name} due to missing or mismatched values")
         return None
 
 
@@ -205,7 +205,7 @@ def perform_advanced_CoT(self, filtered_query, display_thought):  # no return, v
 
     if display_thought:
         print(
-            f"{'\033[33m'}I am presented with a more involved query asking me to do some form of computation{'\033[0m'}")
+            f"I am presented with a more involved query asking me to do some form of computation")
         print("Let me think about this carefully and break it down so that I can solve it")
         print(f"I've trimmed away any extra words so I'm focusing on \"{filtered_query}\" now")
 
@@ -401,7 +401,7 @@ def perform_advanced_CoT(self, filtered_query, display_thought):  # no return, v
             '=' not in operands_mentioned and num_mentioned.__len__() < 2)):  # don't compute if parts are missing
         if (not self._DLM__try_compute):
             if display_thought:
-                print(f"{'Hmm...' or '' if display_thought else ''}{'\033[33m'}It looks like some essential details are missing, so I can’t complete this calculation right now.{'\033[0m'}")
+                print(f"{'Hmm...' or '' if display_thought else ''}It looks like some essential details are missing, so I can't complete this calculation right now.")
             self._DLM__try_memory = True
         else:
             print("Hmm...")
@@ -451,7 +451,7 @@ def perform_advanced_CoT(self, filtered_query, display_thought):  # no return, v
 
         # geometric problem
         if is_geometric_query:
-            print(f"{'\033[34m'}Geometric Answer: {geometric_ans}{'\033[0m'}")
+            print(f"Geometric Answer: {geometric_ans}")
             self._DLM__successfully_computed = True
         # conversion problem
         elif len(num_mentioned) == 1 and len(operands_mentioned) == 1:
@@ -529,12 +529,12 @@ def perform_advanced_CoT(self, filtered_query, display_thought):  # no return, v
                     if display_thought:
                         print(f"I need to take {num0} and multiply it by {self._DLM__units[source_key]}. Finally, I divide by {self._DLM__units[target_key]} and I got my answer")
                     expr = f"{num_mentioned[0]} {source_key}(s) ==> {round(result, 2)} {target_key}(s)"
-                    print(f"{'\033[34m'}Conversion Answer: {expr} {'\033[0m'}")
+                    print(f"Conversion Answer: {expr}")
                     self._DLM__successfully_computed = True
                 else:
-                    print(f"{'\033[33m'}Could not identify both source and target units.{'\033[0m'}")
+                    print(f"Could not identify both source and target units.")
             except SyntaxError:
-                print("\033[33mOops! I still mix up conversions and arithmetic sometimes. Working on it!\033[0m")
+                print("Oops! I still mix up conversions and arithmetic sometimes. Working on it!")
         # regular arithmetic operations
         elif len(num_mentioned) >= 2 and (
                 len(operands_mentioned) == (len(num_mentioned) - 1) or len(operands_mentioned) == 1):
@@ -555,15 +555,15 @@ def perform_advanced_CoT(self, filtered_query, display_thought):  # no return, v
                 if "average" in filtered_query.lower():
                     expr = "(" + expr + ") / " + str(len(num_mentioned))
                     result /= len(num_mentioned)
-                print(f"{'\033[34m'}Arithmetic Answer: {expr} = {result}{'\033[0m'}")
+                print(f"Arithmetic Answer: {expr} = {result}")
                 self._DLM__successfully_computed = True
             except SyntaxError:
                 print(
-                    f"{'\033[34mAh'}, something about that stumped me. I’ll need to learn more to handle it properly.{'\033[0m'}")
+                    f"Something about that stumped me. I'll need to learn more to handle it properly.")
         else:
             self._DLM__successfully_computed = False
-            print(f"{'\033[34m'}{random.choice(self._DLM__fallback_responses)}{'\033[0m'}")
+            print(f"{random.choice(self._DLM__fallback_responses)}")
             print(
-                f"{'\033[34m'}However, while I was trying to understand the math, I ran into \"{'" and "'.join(keywords_mentioned)}\", which I use to connect keywords to math operations.{'\033[0m'}")
+                f"However, while I was trying to understand the math, I ran into \"{'" and "'.join(keywords_mentioned)}\", which I use to connect keywords to math operations.")
             print(
-                f"{'\033[34m'}That might've confused me a bit, maybe try leaving one of those out or rephrase it to make it clearer?{'\033[0m'}")
+                f"That might've confused me a bit, maybe try leaving one of those out or rephrase it to make it clearer?")

{dynamic_learning_model-3.4.1 → dynamic_learning_model-3.4.2}/dynamic_learning_model.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dynamic-learning-model
-Version: 3.4.1
+Version: 3.4.2
 Summary: A Dynamic Learning Model for processing NLP queries using hybrid AI and reasoning.
 Home-page: https://github.com/VigneshT24/Dynamic_Learning_Model
 Author: Vignesh Thondikulam

{dynamic_learning_model-3.4.1 → dynamic_learning_model-3.4.2}/setup.py

@@ -5,7 +5,7 @@ with open('README.md', 'r', encoding='utf-8') as f:
 
 setup(
     name='dynamic-learning-model',
-    version='3.4.1',
+    version='3.4.2',
     author='Vignesh Thondikulam',
     author_email='vignesh.tho2006@gmail.com',
     description='A Dynamic Learning Model for processing NLP queries using hybrid AI and reasoning.',