{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "sData = []  # sinhala data tuple\n",
    "eData = []  # english data tuple\n",
    "\n",
    "lstword = []\n",
    "final = []\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "import pickle\n",
    "import TranslaterLogic\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "def clearlstword():\n",
    "    global lstword\n",
    "    lstword = []\n",
    "\n",
    "\n",
    "def translate(txt,t):\n",
    "    global lstword\n",
    "    lstword.clear()\n",
    "    if len(txt)==0:\n",
    "        return lstword\n",
    "    else:\n",
    "        l=t.printAutoSuggestions(txt, 2)\n",
    "    #if len(txt) >= 5:\n",
    "       # t.printAutoSuggestions(txt, 1)\n",
    "    #else:\n",
    "       # t.printAutoSuggestions(txt, 2)\n",
    "    #print(lstword)\n",
    "        return l\n",
    "\n",
    "\n",
    "class TrieNode():\n",
    "    def __init__(self):\n",
    "        # Initialising one node for trie\n",
    "        self.children = {}\n",
    "        self.last = False\n",
    "\n",
    "\n",
    "class Trie():\n",
    "\n",
    "    def __init__(self):\n",
    "\n",
    "        # Initialising the trie structure.\n",
    "        self.root = TrieNode()\n",
    "\n",
    "    def formTrie(self, keys):\n",
    "\n",
    "        # Forms a trie structure with the given set of strings\n",
    "        # if it does not exists already else it merges the key\n",
    "        # into it by extending the structure as required\n",
    "        for key in keys:\n",
    "            self.insert(key)  # inserting one key to the trie.\n",
    "\n",
    "    def insert(self, key):\n",
    "\n",
    "        # Inserts a key into trie if it does not exist already.\n",
    "        # And if the key is a prefix of the trie node, just\n",
    "        # marks it as leaf node.\n",
    "        node = self.root\n",
    "\n",
    "        for a in key:\n",
    "            if not node.children.get(a):\n",
    "                node.children[a] = TrieNode()\n",
    "\n",
    "            node = node.children[a]\n",
    "\n",
    "        node.last = True\n",
    "\n",
    "    def suggestionsRec(self, node, word):\n",
    "\n",
    "        # Method to recursively traverse the trie\n",
    "        # and return a whole word.\n",
    "        lstword=[]\n",
    "        \n",
    "        if node.last:\n",
    "            sin_indexes = [n for n, x in enumerate(eData) if x == word]\n",
    "            for i in sin_indexes:\n",
    "                y = int(i)\n",
    "                if sData[y] not in lstword:\n",
    "                    # print(sData[y])\n",
    "                    lstword.append(sData[y])\n",
    "        #adding the rule\n",
    "        #txt=str(TranslaterLogic.convertText(word))\n",
    "       # print(txt)\n",
    "        #lstword.append(txt)\n",
    "        return lstword\n",
    "                    \n",
    "    def suggestionsRecsuffix(self, node, word):\n",
    "\n",
    "        # Method to recursively traverse the trie\n",
    "        # and return a whole word.\n",
    "        if node.last:\n",
    "            sin_indexes = [n for n, x in enumerate(eData) if x == word]\n",
    "            for i in sin_indexes:\n",
    "                y = int(i)\n",
    "                if sData[y] not in lstword:\n",
    "                    # print(sData[y])\n",
    "                    lstword.append(sData[y])\n",
    "\n",
    "        for a, n in node.children.items():\n",
    "            self.suggestionsRec(n, word + a)\n",
    "\n",
    "    def printAutoSuggestions(self, key, para):\n",
    "\n",
    "        # adding text using rule\n",
    "        # lstword.append(str(TranslaterLogic.convertText(key)))\n",
    "\n",
    "        # Returns all the words in the trie whose common\n",
    "        # prefix is the given key thus listing out all\n",
    "        # the suggestions for autocomplete.\n",
    "\n",
    "        node = self.root\n",
    "\n",
    "        for a in key:\n",
    "            # no string in the Trie has this prefix\n",
    "            if not node.children.get(a):\n",
    "                return 0\n",
    "            node = node.children[a]\n",
    "\n",
    "        # If prefix is present as a word, but\n",
    "        # there is no subtree below the last\n",
    "        # matching node.\n",
    "        if not node.children:\n",
    "            return -1\n",
    "        if para == 1:\n",
    "            lst=self.suggestionsRecsuffix(node, key)\n",
    "            return lst\n",
    "        else:\n",
    "            lst=self.suggestionsRec(node, key)\n",
    "            return lst"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Code for creating trie\n",
    "\n",
    "textFile = open(\"singlishtrainsuggest.txt\",\n",
    "                mode='r', encoding='utf-8')\n",
    "for i in textFile:\n",
    "    txt = i.split(\"/\")\n",
    "    eData.append(txt[0])\n",
    "    sData.append(txt[1].strip('\\n'))\n",
    "\n",
    "keys = eData\n",
    "# keys to form the trie structure.\n",
    "# creating trie object\n",
    "t = Trie()\n",
    "\n",
    "# creating the trie structure with the\n",
    "# given set of strings.\n",
    "# t.formTrie(keys)\n",
    "# print(\"Trie generated .\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Trie saved.\n"
     ]
    }
   ],
   "source": [
    "# import pickle\n",
    "\n",
    "# # Saving the Trie object\n",
    "# with open('trie.pkl', 'wb') as f:\n",
    "#     pickle.dump(t, f)\n",
    "\n",
    "# print(\"Trie saved.\")\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Trie loaded.\n"
     ]
    }
   ],
   "source": [
    "import pickle\n",
    "# Loading the Trie object\n",
    "with open('trie.pkl', 'rb') as f:\n",
    "    loaded_t = pickle.load(f)\n",
    "\n",
    "print(\"Trie loaded.\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['ආදරය', 'ආදාරය', 'අදාරය', 'ආධාරය', 'අදරය']\n"
     ]
    }
   ],
   "source": [
    "print(translate(\"adaraya\",loaded_t))"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "llm",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.11.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}