Prepare for v0.0.5 release

Author: Cipher

Janex.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: Janex
-Version: 0.0.4b0
+Version: 0.0.5
 Home-page: https://github.com/Cipher58
 Download-URL: https://github.com/Cipher58/Janex/archive/refs/tags/v0.0.2-beta.tar.gz
 Author: Cipher58

Janex.egg-info/SOURCES.txt

@@ -2,7 +2,6 @@ LICENSE
 README.md
 Setup.py
 setup.py
-Janex/Janex.py
 Janex/__init__.py
 Janex/chat.py
 Janex.egg-info/PKG-INFO

Janex/.DS_Store

@@ -0,0 +1,149 @@
+import json
+
+class IntentMatcher:
+    def __init__(self, intents_file_path):
+        self.intents_file_path = intents_file_path
+        self.intents = self.train()
+
+    def tokenize(self, input_string):
+        processed_string = input_string.lower().strip().replace(r"[^\w\s]|_", "").replace(r"\s+", " ")
+        words = processed_string.split(" ")
+
+        words = self.stem_list(words)
+
+        return words
+
+    def tokenize_list(self, input_list):
+        token_words = []
+        for word in input_list:
+            token = self.tokenize(word)
+            token_words.append(token)
+
+        return token_words
+
+    def train(self):
+        with open(self.intents_file_path, "r") as file:
+            intents = json.load(file)
+        return intents
+
+    def pattern_compare(self, input_string):
+        input_string_lower = input_string.lower()
+        highest_similarity = 0
+        most_similar_pattern = None
+        similarity_percentage = 0
+
+        for intent_class in self.intents["intents"]:
+            overall_word_list = []
+            similarity = 0
+
+            for pattern in intent_class["patterns"]:
+                word_list = []
+                pattern_lower = pattern.lower()
+                word_list = self.tokenize(pattern_lower)
+                overall_word_list.append(word_list)
+                new_list = []
+                new_bag = []
+
+                for word in word_list:
+                    word = self.stem(word)
+                    new_list.append(word)
+
+                word_list_2 = self.tokenize(input_string_lower)
+                for word in word_list_2:
+                    word = self.stem(word)
+                    new_bag.append(word)
+
+                word_list = new_list
+                word_list_2 = new_bag
+
+                for word in word_list_2:
+                    if word in word_list:
+                        similarity += 1
+
+                if similarity > highest_similarity:
+                    similarity_percentage = similarity / (len(overall_word_list) + len(word_list_2))
+                    highest_similarity = similarity
+                    most_similar_pattern = intent_class
+
+        print(f"Similarity: {similarity_percentage:.2%}")
+
+        if most_similar_pattern:
+            return most_similar_pattern
+        else:
+            raise ValueError("No matching intent class found.")
+
+    def response_compare(self, input_string, intent_class):
+        input_string_lower = input_string.lower()
+        highest_similarity = 0
+        similarity_percentage = 0
+        most_similar_response = None
+
+        responses = intent_class["responses"] if intent_class else []
+
+        for response in responses:
+            similarity = 0
+            response_lower = response.lower()
+            word_list = self.tokenize(response_lower)
+            new_list = []
+            new_bag = []
+
+            for word in word_list:
+                word = self.stem(word)
+                new_list.append(word)
+
+            word_list_2 = self.tokenize(input_string_lower)
+            for word in word_list_2:
+                word = self.stem(word)
+                new_bag.append(word)
+
+            word_list = new_list
+            word_list_2 = new_bag
+            overall_word_list = word_list + word_list_2
+
+            for word in word_list_2:
+                if word in word_list:
+                    similarity += 1
+
+            if similarity > highest_similarity:
+                similarity_percentage = similarity / (len(overall_word_list) + len(word_list_2))
+                highest_similarity = similarity
+                most_similar_response = response
+
+        print(f"Similarity: {similarity_percentage:.2%}")
+
+        # Convert most_similar_response back into the original string
+        for response in responses:
+            low_response_list = []
+            low_response = response.lower()
+            low_response_list = self.stem_sentence(low_response)
+
+            for low_response_word in low_response_list:
+                if low_response_word == most_similar_response:
+                    most_similar_response = response
+
+        return most_similar_response
+
+    def stem(self, input_word):
+        suffixes = ["ing", "ly", "ed", "es", "'s", "er", "est", "y", "ily", "able", "ful", "ness", "less", "ment", "ive", "ize", "ous"]
+        for suffix in suffixes:
+            if input_word.endswith(suffix):
+                input_word = input_word[:-len(suffix)]
+                break
+        return input_word
+
+    def stem_sentence(self, input_string):
+        word_list = input_string.split(" ")
+        stemmed_words = []
+        for input_word in word_list:
+            word = self.stem(input_word)
+            stemmed_words.append(word)
+
+        return stemmed_words
+
+    def stem_list(self, input_list):
+        stemmed_words = []
+        for word in input_list:
+            stemmed_word = self.stem(word)
+            stemmed_words.append(stemmed_word)
+
+        return stemmed_words

Janex/__init__.py

@@ -13,15 +13,15 @@ Released under the **new** Free Lily License 1.0, Janex will improve and become
 
 <h5> Adding to your project </h5>
 
-Firstly, clone the git repository to the local directory of your project.
+Firstly, if you want to use this from source, clone the git repository to the local directory of your project.
 
 ```
 cd /path/to/your/project/directory
 
 gh repo clone Cipher58/Janex
 ```
 
-Secondly, import the Janex toolkit into your code by adding this line
+Secondly, even if you are just using the library, import the Janex toolkit into your code by adding this line
 
 ```
 from Janex import *
@@ -84,7 +84,7 @@ print(output)
 
 <h3> Functionality </h3>
 
-<h4>Version 0.0.2-Gamma</h4>
+<h4>Version 0.0.5</h4>
 
 - Word tokenizer ✓
 - Intent classifier ✓

README.md

@@ -8,7 +8,7 @@
     name="Janex",
 
     # version of the module
-    version="0.0.4.beta",
+    version="0.0.5",
 
     # Name of Author
     author="Cipher58",

Setup.py

@@ -0,0 +1,149 @@
+import json
+
+class IntentMatcher:
+    def __init__(self, intents_file_path):
+        self.intents_file_path = intents_file_path
+        self.intents = self.train()
+
+    def tokenize(self, input_string):
+        processed_string = input_string.lower().strip().replace(r"[^\w\s]|_", "").replace(r"\s+", " ")
+        words = processed_string.split(" ")
+
+        words = self.stem_list(words)
+
+        return words
+
+    def tokenize_list(self, input_list):
+        token_words = []
+        for word in input_list:
+            token = self.tokenize(word)
+            token_words.append(token)
+
+        return token_words
+
+    def train(self):
+        with open(self.intents_file_path, "r") as file:
+            intents = json.load(file)
+        return intents
+
+    def pattern_compare(self, input_string):
+        input_string_lower = input_string.lower()
+        highest_similarity = 0
+        most_similar_pattern = None
+        similarity_percentage = 0
+
+        for intent_class in self.intents["intents"]:
+            overall_word_list = []
+            similarity = 0
+
+            for pattern in intent_class["patterns"]:
+                word_list = []
+                pattern_lower = pattern.lower()
+                word_list = self.tokenize(pattern_lower)
+                overall_word_list.append(word_list)
+                new_list = []
+                new_bag = []
+
+                for word in word_list:
+                    word = self.stem(word)
+                    new_list.append(word)
+
+                word_list_2 = self.tokenize(input_string_lower)
+                for word in word_list_2:
+                    word = self.stem(word)
+                    new_bag.append(word)
+
+                word_list = new_list
+                word_list_2 = new_bag
+
+                for word in word_list_2:
+                    if word in word_list:
+                        similarity += 1
+
+                if similarity > highest_similarity:
+                    similarity_percentage = similarity / (len(overall_word_list) + len(word_list_2))
+                    highest_similarity = similarity
+                    most_similar_pattern = intent_class
+
+        print(f"Similarity: {similarity_percentage:.2%}")
+
+        if most_similar_pattern:
+            return most_similar_pattern
+        else:
+            raise ValueError("No matching intent class found.")
+
+    def response_compare(self, input_string, intent_class):
+        input_string_lower = input_string.lower()
+        highest_similarity = 0
+        similarity_percentage = 0
+        most_similar_response = None
+
+        responses = intent_class["responses"] if intent_class else []
+
+        for response in responses:
+            similarity = 0
+            response_lower = response.lower()
+            word_list = self.tokenize(response_lower)
+            new_list = []
+            new_bag = []
+
+            for word in word_list:
+                word = self.stem(word)
+                new_list.append(word)
+
+            word_list_2 = self.tokenize(input_string_lower)
+            for word in word_list_2:
+                word = self.stem(word)
+                new_bag.append(word)
+
+            word_list = new_list
+            word_list_2 = new_bag
+            overall_word_list = word_list + word_list_2
+
+            for word in word_list_2:
+                if word in word_list:
+                    similarity += 1
+
+            if similarity > highest_similarity:
+                similarity_percentage = similarity / (len(overall_word_list) + len(word_list_2))
+                highest_similarity = similarity
+                most_similar_response = response
+
+        print(f"Similarity: {similarity_percentage:.2%}")
+
+        # Convert most_similar_response back into the original string
+        for response in responses:
+            low_response_list = []
+            low_response = response.lower()
+            low_response_list = self.stem_sentence(low_response)
+
+            for low_response_word in low_response_list:
+                if low_response_word == most_similar_response:
+                    most_similar_response = response
+
+        return most_similar_response
+
+    def stem(self, input_word):
+        suffixes = ["ing", "ly", "ed", "es", "'s", "er", "est", "y", "ily", "able", "ful", "ness", "less", "ment", "ive", "ize", "ous"]
+        for suffix in suffixes:
+            if input_word.endswith(suffix):
+                input_word = input_word[:-len(suffix)]
+                break
+        return input_word
+
+    def stem_sentence(self, input_string):
+        word_list = input_string.split(" ")
+        stemmed_words = []
+        for input_word in word_list:
+            word = self.stem(input_word)
+            stemmed_words.append(word)
+
+        return stemmed_words
+
+    def stem_list(self, input_list):
+        stemmed_words = []
+        for word in input_list:
+            stemmed_word = self.stem(word)
+            stemmed_words.append(stemmed_word)
+
+        return stemmed_words