dynamic-learning-model 1.2.6__tar.gz → 1.3__tar.gz

{dynamic_learning_model-1.2.6/dynamic_learning_model.egg-info → dynamic_learning_model-1.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dynamic-learning-model
-Version: 1.2.6
+Version: 1.3
 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-1.2.6 → dynamic_learning_model-1.3}/dlm/DLM.py

@@ -7,6 +7,7 @@ import time
 import sqlite3
 import re
 import nltk
+import math
 from better_profanity import profanity
 from nltk.corpus import names
 from word2number import w2n
@@ -213,6 +214,40 @@ class DLM:
         ]
     }
 
+    # to solve geometric problems (advanced CoT)
+    __geometric_calculation_identifiers = {
+        "triangle": {
+            "keywords": ["area", "triangle"], # keyword that will be mentioned while in CoT
+            "params": ["base", "height"], # helps with formula
+            "formula": lambda d: 0.5 * d["base"] * d["height"] # formula to solve geometric problem
+        },
+        "rectangle": {
+            "keywords": ["area", "rectangle"],
+            "params": ["length", "width"],
+            "formula": lambda d: d["length"] * d["width"]
+        },
+        "parallelogram": {
+            "keywords": ["area", "parallelogram"],
+            "params": ["base", "height"],
+            "formula": lambda d: d["base"] * d["height"]
+        },
+        "square": {
+            "keywords": ["area", "square"],
+            "params": ["side"],
+            "formula": lambda d: math.pow(d["side"], 2)
+        },
+        "trapezoid": {
+            "keywords": ["area", "trapezoid"],
+            "params": ["other", "height"],
+            "formula": lambda d: 0.5 * (d["other"][0] + d["other"][1]) * d["height"]
+        },
+        "circle": {
+            "keywords": ["area", "circle"],
+            "params": ["radius"],
+            "formula": lambda d: (math.pow(d["radius"], 2)) * math.pi
+        }
+    }
+
     # for SI conversion and CoT
     __units = {
         # distance units (base = meters)
@@ -534,6 +569,131 @@ class DLM:
         else:
             self.__tone = ""
 
+    def __geometric_calculation(self, filtered_query, display_thought):
+        """
+        Perform formula-related math and geometric problems that will be called inside perform_advanced_CoT
+
+        Parameters:
+            filtered_query (str): user query that has been filtered to have mostly computational details
+            display_thought (bool): Indicates whether the user wants to have the bot display its thought process or just give the answer
+
+        Returns:
+            float: The result after computing the formula calculation
+
+        Behavior:
+            - Search through query to find specific keywords like 'area' or 'volume'
+            - Then, search to find shape or object to perform math on like 'triangle' or 'square'
+            - Find numbers associated with object details and store in appropriate list
+            - Finally, find appropriate formula with identifiers and plug in and return answer
+
+        """
+        height_value = None
+        height_value_index = None
+        other_values = []
+        object_intel = []
+        common_endings = ["ular", "ish", "al"] # some people might say "squarish" or "rectangular" etc
+
+        tokens = filtered_query.split()
+        lower_tokens = [t.lower() for t in tokens]
+
+        # set height value number (if exists) to height_value and also its corresponding index
+        for idx, token in enumerate(lower_tokens):
+            is_similar = difflib.get_close_matches(token, ["height"], n=1, cutoff=0.7)
+            if is_similar and is_similar[0] == "height":
+                # try token before
+                if idx > 0:
+                    candidate = lower_tokens[idx - 1]
+                    try:
+                        height_value = w2n.word_to_num(candidate)
+                        height_value_index = idx - 1
+                    except ValueError:
+                        if candidate.replace('.', '', 1).isdigit():
+                            height_value = float(candidate)
+                            height_value_index = idx - 1
+                            break
+                        pass
+
+                # try token after
+                if idx < len(tokens) - 1:
+                    candidate = lower_tokens[idx + 1]
+                    try:
+                        height_value = w2n.word_to_num(candidate)
+                        height_value_index = idx + 1
+                    except ValueError:
+                        if candidate.replace('.', '', 1).isdigit():
+                            height_value = float(candidate)
+                            height_value_index = idx + 1
+                            break
+                        pass
+
+        # append all other numbers to "other_value" list
+        for i, token in enumerate(tokens):
+            if i == height_value_index:
+                continue  # skip the height value itself
+            try:
+                num = w2n.word_to_num(token)
+                other_values.append(num)
+            except ValueError:
+                if token.replace('.', '', 1).isdigit():
+                    other_values.append(float(token))
+
+        # find the object name and what to compute about the object
+        for token in lower_tokens:
+            for obj in self.__geometric_calculation_identifiers:
+                # remove common endings for better matching
+                for ending in common_endings:
+                    if token.endswith(ending):
+                        token = token[: -len(ending)]  # Remove the ending
+                        break
+                is_similar = difflib.get_close_matches(token, [obj], n=1, cutoff=0.80)
+                if is_similar and is_similar[0] == obj:
+                    object_intel.extend(self.__geometric_calculation_identifiers[obj]["keywords"])
+
+        obj_name = object_intel[1]
+        if display_thought:
+            self.__loadingAnimation(f"It seems that the user wants to compute the {' of a '.join(object_intel)}", 0.5)
+            if height_value is not None:
+                self.__loadingAnimation(f"* The user has mentioned that the height of the {obj_name} object is {height_value}", 0.4)
+            else:
+                self.__loadingAnimation(f"* The {object_intel[1]} object has no height associated with it, so moving on", 0.4)
+            if len(other_values) > 0:
+                self.__loadingAnimation(f"* Additional numerical values associated with the dimensions of the {obj_name} object is {' and '.join(str(v) for v in other_values)}", 0.4)
+            else:
+                self.__loadingAnimation(f"* No additional numerical values associated with the dimensions of the {obj_name} were given",0.4)
+
+        # Now iterate through the geometric identifier list, find the correct object, and then find its formula, then plug compute
+        formula = self.__geometric_calculation_identifiers[obj_name]["formula"]
+        params = self.__geometric_calculation_identifiers[obj_name]["params"]
+
+        formula_inputs = {} # all data gathered to compute geometry
+
+        try:
+            if "height" in params:
+                formula_inputs["height"] = height_value
+
+            value_idx = 0 # count how many values to be added in formula_inputs
+            for param in params:
+                if param == "height":
+                    continue  # already added
+                elif param == "other": # two consecutive numbers to append
+                    formula_inputs["other"] = other_values[value_idx:value_idx + 2]
+                    value_idx += 2
+                else: # only one number to append
+                    formula_inputs[param] = other_values[value_idx]
+                    value_idx += 1
+
+            # Try calculating the result and return
+            result = round(formula(formula_inputs), 4)
+            return result
+
+        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'}")
+            else:
+                print(f"{'\033[34m'}Unable to compute the {object_intel[0]} of the {obj_name} due to missing or mismatched values{'\033[0m'}")
+            return None
+
+
     def __perform_advanced_CoT(self, filtered_query, display_thought):  # no return, void
         """
         Perform advanced Chain-of-Thought (CoT) reasoning to solve arithmetic or unit conversion problems.
@@ -570,8 +730,7 @@ class DLM:
             print(
                 f"{'\033[33m'}I am presented with a more involved query asking me to do some form of computation{'\033[0m'}")
             self.__loadingAnimation("Let me think about this carefully and break it down so that I can solve it", 0.8)
-            self.__loadingAnimation(f"I’ve trimmed away any extra words so I’m focusing on \"{filtered_query}\" now",
-                                    0.8)
+            self.__loadingAnimation(f"I’ve trimmed away any extra words so I’m focusing on \"{filtered_query}\" now", 0.8)
 
         # Have the bot pick out names mentioned (in order) using SpaCy and NLTK (for maximum coverage)
         for ent in doc.ents:
@@ -599,176 +758,189 @@ class DLM:
         tokens_lower = filtered_query.lower().split()
         last_two = set(tokens_lower[-2:])  # only the final 2 words from filtered input
 
-        # Then have it find all operand indicating keywords
-        found_operand = False
-        for fq in filtered_query.split():
-            fq_l = fq.lower()
-            # If this word is one of the ending phrases and sits among the last five, skip it
-            if fq_l in arithmetic_ending_phrases and fq_l in last_two:
-                continue
-            if fq_l in {"+", "-", "*", "/"}:
-                operands_mentioned.append(fq_l)
-                keywords_mentioned.append(fq_l)
-                continue  # move on to the next token
-            for operand, keywords in self.__computation_identifiers.items():
-                for kw in keywords:
-                    p1 = self.__nlp(kw)
-                    p2 = self.__nlp(fq_l)
-                    word_num_surrounded = re.search(rf'\d+\s*{fq.lower()}\s*\d+', filtered_query.lower())
-
-                    # Direct match or lemma match
-                    if (kw.lower() == fq.lower()) or p1[0].lemma_ == p2[0].lemma_:
-                        keywords_mentioned.append(kw.title())
-                        if kw.lower() == "average":
-                            operands_mentioned.append("+")
-                        elif kw.lower() == "out of":
-                            if word_num_surrounded:
+        # First see if the problem is a geometric problem
+        words = filtered_query.lower().split()
+        geometric_ans = None
+        # checks if the query contains shapes or object to perform possibly formula calculation
+        geometric_calc = any(difflib.get_close_matches(word, self.__geometric_calculation_identifiers.keys(), n=1, cutoff=0.70) for word in words)
+        is_geometric_query = False
+
+        geo_types = set() # currently supported types of geometric calculations
+
+        for t in self.__geometric_calculation_identifiers:
+            shape = self.__geometric_calculation_identifiers[t]["keywords"]
+            geo_types.add(shape[0])
+        if any(difflib.get_close_matches(word, geo_types, n=1, cutoff=0.70) for word in words) and geometric_calc:
+            geometric_ans = self.__geometric_calculation(filtered_query, display_thought)
+            if geometric_ans is not None:
+                is_geometric_query = True
+        else: # Not geometric, so have the bot find all operand indicating keywords
+            found_operand = False
+            for fq in filtered_query.split():
+                fq_l = fq.lower()
+                # If this word is one of the ending phrases and sits among the last five, skip it
+                if fq_l in arithmetic_ending_phrases and fq_l in last_two:
+                    continue
+                if fq_l in {"+", "-", "*", "/"}:
+                    operands_mentioned.append(fq_l)
+                    keywords_mentioned.append(fq_l)
+                    continue  # move on to the next token
+                for operand, keywords in self.__computation_identifiers.items():
+                    for kw in keywords:
+                        p1 = self.__nlp(kw)
+                        p2 = self.__nlp(fq_l)
+                        word_num_surrounded = re.search(rf'\d+\s*{fq.lower()}\s*\d+', filtered_query.lower())
+
+                        # Direct match or lemma match
+                        if (kw.lower() == fq.lower()) or p1[0].lemma_ == p2[0].lemma_:
+                            keywords_mentioned.append(kw.title())
+                            if kw.lower() == "average":
+                                operands_mentioned.append("+")
+                            elif kw.lower() == "out of":
+                                if word_num_surrounded:
+                                    operands_mentioned.append(operand)
+                                    found_operand = True
+                                    break  # only break if 'out of' condition is satisfied
+                                continue  # skip adding 'out of' if not surrounded by numbers
+                            else:
                                 operands_mentioned.append(operand)
                                 found_operand = True
-                                break  # only break if 'out of' condition is satisfied
-                            continue  # skip adding 'out of' if not surrounded by numbers
-                        else:
-                            operands_mentioned.append(operand)
-                            found_operand = True
-                            break
+                                break
 
-                    # Vector + string similarity
-                    if p1.vector_norm != 0 and p2.vector_norm != 0 and (
-                            p1.similarity(p2) > 0.80 and difflib.SequenceMatcher(None, kw, fq_l).ratio() > 0.40):
-                        keywords_mentioned.append(kw.title())
-                        if kw.lower() == "average":
-                            operands_mentioned.append("+")
-                        elif kw.lower() == "out of":
-                            if word_num_surrounded:
+                        # Vector + string similarity
+                        if p1.vector_norm != 0 and p2.vector_norm != 0 and (
+                                p1.similarity(p2) > 0.80 and difflib.SequenceMatcher(None, kw, fq_l).ratio() > 0.40):
+                            keywords_mentioned.append(kw.title())
+                            if kw.lower() == "average":
+                                operands_mentioned.append("+")
+                            elif kw.lower() == "out of":
+                                if word_num_surrounded:
+                                    operands_mentioned.append(operand)
+                                    found_operand = True
+                                    break
+                                continue
+                            else:
                                 operands_mentioned.append(operand)
                                 found_operand = True
                                 break
-                            continue
-                        else:
-                            operands_mentioned.append(operand)
-                            found_operand = True
-                            break
 
-                    # Fallback: high string similarity
-                    elif difflib.SequenceMatcher(None, kw, fq_l).ratio() > 0.80:
-                        keywords_mentioned.append(kw.title())
-                        if kw.lower() == "average":
-                            operands_mentioned.append("+")
-                        elif kw.lower() == "out of":
-                            if word_num_surrounded:
+                        # Fallback: high string similarity
+                        elif difflib.SequenceMatcher(None, kw, fq_l).ratio() > 0.80:
+                            keywords_mentioned.append(kw.title())
+                            if kw.lower() == "average":
+                                operands_mentioned.append("+")
+                            elif kw.lower() == "out of":
+                                if word_num_surrounded:
+                                    operands_mentioned.append(operand)
+                                    found_operand = True
+                                    break
+                                continue
+                            else:
                                 operands_mentioned.append(operand)
                                 found_operand = True
                                 break
-                            continue
-                        else:
-                            operands_mentioned.append(operand)
-                            found_operand = True
-                            break
-
-                if found_operand:
-                    found_operand = False
-                    break
 
-        # If no operands were found in the main pass, check ending phrases as a last resort
-        if not operands_mentioned:
-            for fq in filtered_query.split():
-                p_fq = self.__nlp(fq)
-
-                # Replace exact matching with a spaCy similarity check against ending_phrases
-                matched_ep = None
-                for ep in arithmetic_ending_phrases:
-                    p_ep = self.__nlp(ep)
-                    if p_ep.vector_norm != 0 and p_fq.vector_norm != 0 and p_ep.similarity(p_fq) > 0.50:
-                        matched_ep = ep
+                    if found_operand:
+                        found_operand = False
                         break
 
-                if not matched_ep:
-                    continue
+            # If no operands were found in the main pass, check ending phrases as a last resort
+            if not operands_mentioned:
+                for fq in filtered_query.split():
+                    p_fq = self.__nlp(fq)
+
+                    # Replace exact matching with a spaCy similarity check against ending_phrases
+                    matched_ep = None
+                    for ep in arithmetic_ending_phrases:
+                        p_ep = self.__nlp(ep)
+                        if p_ep.vector_norm != 0 and p_fq.vector_norm != 0 and p_ep.similarity(p_fq) > 0.50:
+                            matched_ep = ep
+                            break
 
-                # Now matched_ep roughly corresponds to an ending phrase; find its operand via spaCy
-                for operand, keywords in self.__computation_identifiers.items():
-                    for kw in keywords:
-                        p_kw = self.__nlp(kw)
-                        if p_kw.vector_norm != 0 and p_fq.vector_norm != 0 and p_kw.similarity(p_fq) > 0.70:
-                            keywords_mentioned.append(kw.title())
-                            operands_mentioned.append(operand)
+                    if not matched_ep:
+                        continue
+
+                    # Now matched_ep roughly corresponds to an ending phrase; find its operand via spaCy
+                    for operand, keywords in self.__computation_identifiers.items():
+                        for kw in keywords:
+                            p_kw = self.__nlp(kw)
+                            if p_kw.vector_norm != 0 and p_fq.vector_norm != 0 and p_kw.similarity(p_fq) > 0.70:
+                                keywords_mentioned.append(kw.title())
+                                operands_mentioned.append(operand)
+                                break
+                        if operands_mentioned:
                             break
                     if operands_mentioned:
                         break
-                if operands_mentioned:
-                    break
-        keywords_mentioned = list(dict.fromkeys(keywords_mentioned))
-
-        # Now have the bot pick out numbers (in order)
-        # additionally, "double", "triple", "quadruple", "half", "an" and "a" also count as numbers, in addition to text numbers (e.g. "three")
-        text_nums = ["a", "an", "half", "double", "triple", "quadruple"]
-        a_an_detected = False
-
-        # Combined regex and word match pass
-        tokens = filtered_query.lower().split()
-        for token in tokens:
-            # Check if it's a digit-based number (e.g. 600, 20.5)
-            if re.fullmatch(r"\d+(\.\d+)?", token):
-                num_mentioned.append(str(float(token)))
-                continue
-
-            # Check if it's a word-based number (e.g. 'three', 'double', 'a')
-            try:
-                num = w2n.word_to_num(token)
-                num_mentioned.append(str(float(num)))
-                continue
-            except ValueError:
-                pass  # not a word2num-recognized word
-
-            # Check if it's in our custom list (a, an, half, double, etc.)
-            for t in text_nums:
-                p1 = self.__nlp(token)
-                p2 = self.__nlp(t)
-                if p1[0].lemma_ == p2[0].lemma_:
-                    if t == "double":
-                        num_mentioned.append(float(2).__str__())
-                    elif t == "triple":
-                        num_mentioned.append(float(3).__str__())
-                    elif t == "half":
-                        num_mentioned.append(float(0.5).__str__())
-                    elif ("=" in operands_mentioned) and (t == "a" or t == "an"):
-                        a_an_detected = True
-                        num_mentioned.append(float(1.0).__str__())
-                    elif t == "quadruple":
-                        num_mentioned.append(float(4).__str__())
-
-        # Remove "1.0" if 'a'/'an' was used in an invalid context (like not following "=")
-        if a_an_detected and (num_mentioned.count("1.0") > 1 or len(num_mentioned) > 1):
-            num_mentioned.remove("1.0")
-
-        if ('=' in operands_mentioned) and (len(num_mentioned) < 2):
-            operands_mentioned.clear()
-            operands_mentioned.append('=')
-        else:
-            if '=' in operands_mentioned:
-                operands_mentioned = [op for op in operands_mentioned if op != '=']
+            keywords_mentioned = list(dict.fromkeys(keywords_mentioned))
+
+            # Now have the bot pick out numbers (in order)
+            # additionally, "double", "triple", "quadruple", "half", "an" and "a" also count as numbers, in addition to text numbers (e.g. "three")
+            text_nums = ["a", "an", "half", "double", "triple", "quadruple"]
+            a_an_detected = False
+
+            # Combined regex and word match pass
+            tokens = filtered_query.lower().split()
+            for token in tokens:
+                # Check if it's a digit-based number (e.g. 600, 20.5)
+                if re.fullmatch(r"\d+(\.\d+)?", token):
+                    num_mentioned.append(str(float(token)))
+                    continue
 
-        print("\n")
-        if any(not lst for lst in (num_mentioned, operands_mentioned)) or (
-                '=' not in operands_mentioned and num_mentioned.__len__() < 2):  # don't compute if parts are missing
-            print(
-                f"{self.__loadingAnimation('Hmm', 0.8) or ''}{'\033[34m'}It looks like some essential details are missing, so I can’t complete this calculation right now.{'\033[0m'}")
+                # Check if it's a word-based number (e.g. 'three', 'double', 'a')
+                try:
+                    num = w2n.word_to_num(token)
+                    num_mentioned.append(str(float(num)))
+                    continue
+                except ValueError:
+                    pass  # not a word2num-recognized word
+
+                # Check if it's in our custom list (a, an, half, double, etc.)
+                for t in text_nums:
+                    p1 = self.__nlp(token)
+                    p2 = self.__nlp(t)
+                    if p1[0].lemma_ == p2[0].lemma_:
+                        if t == "double":
+                            num_mentioned.append(float(2).__str__())
+                        elif t == "triple":
+                            num_mentioned.append(float(3).__str__())
+                        elif t == "half":
+                            num_mentioned.append(float(0.5).__str__())
+                        elif ("=" in operands_mentioned) and (t == "a" or t == "an"):
+                            a_an_detected = True
+                            num_mentioned.append(float(1.0).__str__())
+                        elif t == "quadruple":
+                            num_mentioned.append(float(4).__str__())
+
+            # Remove "1.0" if 'a'/'an' was used in an invalid context (like not following "=")
+            if a_an_detected and (num_mentioned.count("1.0") > 1 or len(num_mentioned) > 1):
+                num_mentioned.remove("1.0")
+
+            if ('=' in operands_mentioned) and (len(num_mentioned) < 2):
+                operands_mentioned.clear()
+                operands_mentioned.append('=')
+            else:
+                if '=' in operands_mentioned:
+                    operands_mentioned = [op for op in operands_mentioned if op != '=']
+
+        # verify and possibly print thoughts
+        if (not is_geometric_query) and (any(not lst for lst in (num_mentioned, operands_mentioned)) or ('=' not in operands_mentioned and num_mentioned.__len__() < 2)):  # don't compute if parts are missing
+            print(f"{self.__loadingAnimation('Hmm', 0.8) or '' if display_thought else ''}{'\033[34m'}It looks like some essential details are missing, so I can’t complete this calculation right now.{'\033[0m'}")
+            print(f"\033[34mIf you are asking a geometric query, try including geometric identifiers like \"{'\", \"'.join(geo_types)}\" in your query.\033[0m")
+            print(f"\033[34mCurrently, I can only compute those identifiers aforementioned, but more geometric features are coming soon!\033[0m")
         else:  # else, the bot needs to explain what it has tokenized
             if display_thought:
-                self.__loadingAnimation(
-                    f"1.) I see {', '.join(persons_mentioned) if persons_mentioned.__len__() >= 1 else 'no one'} mentioned as a person name; "
+                self.__loadingAnimation(f"1.) I see {', '.join(persons_mentioned) if persons_mentioned.__len__() >= 1 else 'no one'} mentioned as a person name; "
                     f"{'they’re likely key to this problem' if persons_mentioned.__len__() >= 1 else 'moving on'}", 0.2)
-                self.__loadingAnimation(
-                    f"2.) Moreover, I see {', '.join(items_mentioned) if items_mentioned.__len__() >= 1 else 'no items'} mentioned as proper nouns; "
+                self.__loadingAnimation(f"2.) Moreover, I see {', '.join(items_mentioned) if items_mentioned.__len__() >= 1 else 'no items'} mentioned as proper nouns; "
                     f"{'this might be a key thing to this problem' if items_mentioned.__len__() >= 1 else 'moving on'}",
                     0.2)
-                self.__loadingAnimation(
-                    f"3.) I’ve also identified the numbers {' and '.join(num_mentioned)} that I need to compute with",
-                    0.2)
-                self.__loadingAnimation(
-                    f"4.) I see the keywords \"{'\" and \"'.join(keywords_mentioned)}\", meaning I need to perform a \"{'\" and \"'.join(operands_mentioned)}\" operation for this query; I’ll use that to guide my calculation",
-                    0.2)
-                self.__loadingAnimation("Now I have the parts, so let me put it all together and solve", 0.3)
+                if is_geometric_query:
+                    self.__loadingAnimation(f"3.) This is a geometric problem and I have already computed the answer", 0.2)
+                else:
+                    self.__loadingAnimation(f"3.) I’ve also identified the numbers {' and '.join(num_mentioned)} that I need to compute with", 0.2)
+                    self.__loadingAnimation(f"4.) I see the keywords \"{'\" and \"'.join(keywords_mentioned)}\", meaning I need to perform a \"{'\" and \"'.join(operands_mentioned)}\" operation for this query; I’ll use that to guide my calculation", 0.2)
+                    self.__loadingAnimation("Now I have the parts, so let me put it all together and solve", 0.3)
 
             # Finally compute it and then give the response (if there is any)
             # move "originally" numbers to the front
@@ -801,8 +973,11 @@ class DLM:
                     num_mentioned.remove(str(float(temp)))
                 num_mentioned.insert(0, str(float(temp)))
 
+            # geometric problem
+            if is_geometric_query:
+                print(f"{'\033[34m'}Geometric Answer: {geometric_ans}{'\033[0m'}")
             # conversion problem
-            if len(num_mentioned) == 1 and len(operands_mentioned) == 1:
+            elif len(num_mentioned) == 1 and len(operands_mentioned) == 1:
                 try:
                     tokens = filtered_query.lower().split()
                     num0 = float(num_mentioned[0])

{dynamic_learning_model-1.2.6 → dynamic_learning_model-1.3/dynamic_learning_model.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dynamic-learning-model
-Version: 1.2.6
+Version: 1.3
 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-1.2.6 → dynamic_learning_model-1.3}/setup.py

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