Huffman Coding.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "913fbf5c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "jhsjh\n"
     ]
    }
   ],
   "source": [
    "print(\"jhsjh\")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "66859730",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "ENTER THE PATH OF YOUR FILE....hghjgj.txt\n",
      "Compressed\n"
     ]
    }
   ],
   "source": [
    "import heapq\n",
    "import os\n",
    "class BinaryTree:\n",
    "    def __init__(self,value,frequ):\n",
    "        self.value = value\n",
    "        self.frequ = frequ\n",
    "        self.left = None\n",
    "        self.right = None\n",
    "       \n",
    "    def __lt__(self,other):\n",
    "        return self.frequ < other.frequ\n",
    "   \n",
    "    def __eq__(self,other):\n",
    "        return self.frequ == other.frequ        \n",
    "\n",
    "class Huffmancode:\n",
    "   \n",
    "    def __init__(self,path):\n",
    "        self.path = path\n",
    "        self.__heap = []\n",
    "        self.__code = {}\n",
    "        self.__reversecode = {}\n",
    "       \n",
    "    def __frequency_from_text(self,text):\n",
    "        frequ_dict = {}\n",
    "        for char in text:\n",
    "            if char not in frequ_dict:\n",
    "                frequ_dict[char] = 0\n",
    "            frequ_dict[char] +=1\n",
    "        return frequ_dict    \n",
    "   \n",
    "    def __Build_heap(self,frequency_dict):\n",
    "        for key in frequency_dict:\n",
    "            frequency = frequency_dict[key]\n",
    "            binary_tree_node = BinaryTree(key,frequency)\n",
    "            heapq.heappush(self.__heap , binary_tree_node)\n",
    "   \n",
    "    def __Build_Binary_Tree(self):\n",
    "        while len(self.__heap) > 1:\n",
    "            binary_tree_node_1 = heapq.heappop(self.__heap)\n",
    "            binary_tree_node_2 = heapq.heappop(self.__heap)\n",
    "            sum_of_freq = binary_tree_node_1.frequ + binary_tree_node_2.frequ\n",
    "            newnode = BinaryTree(None,sum_of_freq)\n",
    "            newnode.left = binary_tree_node_1\n",
    "            newnode.right = binary_tree_node_2\n",
    "            heapq.heappush(self.__heap,newnode)\n",
    "        return\n",
    "    def __Build_Tree_Code_Helper(self,root,curr_bits):\n",
    "        if root is None:\n",
    "            return\n",
    "        if root.value is not None:\n",
    "            self.__code[root.value] = curr_bits\n",
    "            self.__reversecode[curr_bits] = root.value\n",
    "            return\n",
    "        self.__Build_Tree_Code_Helper(root.left,curr_bits+'0')\n",
    "        self.__Build_Tree_Code_Helper(root.right,curr_bits+'1')\n",
    "   \n",
    "    def __Build_Tree_Code(self):\n",
    "        root = heapq.heappop(self.__heap)\n",
    "        self.__Build_Tree_Code_Helper(root,'')\n",
    "       \n",
    "\n",
    "    def __Build_Encoded_Text(self,text):\n",
    "        encoded_text = ''\n",
    "        for char in text:\n",
    "            encoded_text += self.__code[char]\n",
    "           \n",
    "        return encoded_text  \n",
    "   \n",
    "   \n",
    "    def __Build_Padded_Text(self,encoded_text):\n",
    "        padding_value = 8 - (len(encoded_text) % 8)\n",
    "        for i in range(padding_value):\n",
    "            encoded_text += '0'\n",
    "           \n",
    "        padded_info = \"{0:08b}\".format(padding_value)\n",
    "        padded_encoded_text = padded_info + encoded_text\n",
    "        return padded_encoded_text\n",
    "   \n",
    "    def __Build_Byte_Array(self, padded_text):\n",
    "        array = []\n",
    "        for i in range(0,len(padded_text) , 8):\n",
    "            byte = padded_text[i:i+8]\n",
    "            array.append(int(byte,2))\n",
    "        return array    \n",
    "   \n",
    "    def compression(self):\n",
    "       \n",
    "        #To access the file and extract text from that file.\n",
    "        filename,file_extension = os.path.splitext(self.path)\n",
    "        output_path = filename + '.bin'\n",
    "        with open (self.path,'r+') as file , open(output_path,'wb') as output:\n",
    "            text = file.read()\n",
    "            text = text.rstrip()\n",
    "           \n",
    "            frequency_dict = self.__frequency_from_text(text)\n",
    "\n",
    "            #Calculate frequency of each text and store it in freq. dictionary\n",
    "\n",
    "            build_heap = self.__Build_heap(frequency_dict)\n",
    "\n",
    "            # Min heap for two minimum frquency.\n",
    "\n",
    "            #Construct binary tree from Heap .\n",
    "\n",
    "            self.__Build_Binary_Tree()\n",
    "\n",
    "            #construct code from binary tree and stored it in dictionary.\n",
    "\n",
    "            self.__Build_Tree_Code()\n",
    "\n",
    "            #Construct encoded text.\n",
    "\n",
    "            encoded_text = self.__Build_Encoded_Text(text)\n",
    "\n",
    "            #padding of text\n",
    "\n",
    "            padded_text = self.__Build_Padded_Text(encoded_text)\n",
    "\n",
    "            #We have to return that binary file as an output.\n",
    "\n",
    "            bytes_array = self.__Build_Byte_Array(padded_text)\n",
    "\n",
    "            final_bytes = bytes(bytes_array)\n",
    "            output.write(final_bytes)\n",
    "        print(\"Compressed\")\n",
    "        return output_path\n",
    "   \n",
    "    def __Remove_Padding(self,text):\n",
    "        padded_info = text[:8]\n",
    "        extra_padding = int(padded_info,2)\n",
    "        text = text[8:]\n",
    "        padding_removed_text = text[:-1*extra_padding]\n",
    "        return padding_removed_text\n",
    "       \n",
    "    def __Decompress_Text(self,text):    \n",
    "        decoded_text = ''\n",
    "        current_bits = ''\n",
    "        for bit in text:\n",
    "            current_bits += bit\n",
    "            if current_bits in self.__reversecode:\n",
    "                character = self.__reversecode[current_bits]\n",
    "                decoded_text += character\n",
    "                current_bits = \"\"\n",
    "        return decoded_text\n",
    "   \n",
    "   \n",
    "    def decompress(self,input_path):\n",
    "        filename,file_extension = os.path.splitext(input_path)\n",
    "        output_path = filename + '_decompressed' + '.txt'\n",
    "        with open(input_path,'rb') as file , open(output_path,'w') as output:\n",
    "            bit_string = ''\n",
    "            byte = file.read(1)\n",
    "            while byte:\n",
    "                byte = ord(byte)\n",
    "                bits = bin(byte)[2:].rjust(8,'0')\n",
    "                bit_string += bits\n",
    "                byte = file.read(1)\n",
    "               \n",
    "            actual_text = self.__Remove_Padding(bit_string)    \n",
    "            decompressed_text = self.__Decompress_Text(actual_text)\n",
    "            output.write(decompressed_text)\n",
    "        return    \n",
    "           \n",
    "path = input(\"ENTER THE PATH OF YOUR FILE....\")  \n",
    "h = Huffmancode(path)\n",
    "output_path = h.compression()\n",
    "h.decompress(output_path)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "9fc66e00",
   "metadata": {},
   "outputs": [],
   "source": [
    "import heapq\n",
    "import os\n",
    "class BinaryTree:\n",
    "    def __init__(self,value,frequ):\n",
    "        self.value = value\n",
    "        self.frequ = frequ\n",
    "        self.left = None\n",
    "        self.right = None\n",
    "       \n",
    "    def __lt__(self,other):\n",
    "        return self.frequ < other.frequ\n",
    "   \n",
    "    def __eq__(self,other):\n",
    "        return self.frequ == other.frequ        \n",
    "\n",
    "class Huffmancode:\n",
    "   \n",
    "    def __init__(self,path):\n",
    "        self.path = path\n",
    "        self.__heap = []\n",
    "        self.__code = {}\n",
    "        self.__reversecode = {}\n",
    "       \n",
    "    def __frequency_from_text(self,text):\n",
    "        frequ_dict = {}\n",
    "        for char in text:\n",
    "            if char not in frequ_dict:\n",
    "                frequ_dict[char] = 0\n",
    "            frequ_dict[char] +=1\n",
    "        return frequ_dict    \n",
    "   \n",
    "    def __Build_heap(self,frequency_dict):\n",
    "        for key in frequency_dict:\n",
    "            frequency = frequency_dict[key]\n",
    "            binary_tree_node = BinaryTree(key,frequency)\n",
    "            heapq.heappush(self.__heap , binary_tree_node)\n",
    "   \n",
    "    def __Build_Binary_Tree(self):\n",
    "        while len(self.__heap) > 1:\n",
    "            binary_tree_node_1 = heapq.heappop(self.__heap)\n",
    "            binary_tree_node_2 = heapq.heappop(self.__heap)\n",
    "            sum_of_freq = binary_tree_node_1.frequ + binary_tree_node_2.frequ\n",
    "            newnode = BinaryTree(None,sum_of_freq)\n",
    "            newnode.left = binary_tree_node_1\n",
    "            newnode.right = binary_tree_node_2\n",
    "            heapq.heappush(self.__heap,newnode)\n",
    "        return\n",
    "    def __Build_Tree_Code_Helper(self,root,curr_bits):\n",
    "        if root is None:\n",
    "            return\n",
    "        if root.value is not None:\n",
    "            self.__code[root.value] = curr_bits\n",
    "            self.__reversecode[curr_bits] = root.value\n",
    "            return\n",
    "        self.__Build_Tree_Code_Helper(root.left,curr_bits+'0')\n",
    "        self.__Build_Tree_Code_Helper(root.right,curr_bits+'1')\n",
    "   \n",
    "    def __Build_Tree_Code(self):\n",
    "        root = heapq.heappop(self.__heap)\n",
    "        self.__Build_Tree_Code_Helper(root,'')\n",
    "       \n",
    "\n",
    "    def __Build_Encoded_Text(self,text):\n",
    "        encoded_text = ''\n",
    "        for char in text:\n",
    "            encoded_text += self.__code[char]\n",
    "           \n",
    "        return encoded_text  \n",
    "   \n",
    "   \n",
    "    def __Build_Padded_Text(self,encoded_text):\n",
    "        padding_value = 8 - (len(encoded_text) % 8)\n",
    "        for i in range(padding_value):\n",
    "            encoded_text += '0'\n",
    "           \n",
    "        padded_info = \"{0:08b}\".format(padding_value)\n",
    "        padded_encoded_text = padded_info + encoded_text\n",
    "        return padded_encoded_text\n",
    "   \n",
    "    def __Build_Byte_Array(self, padded_text):\n",
    "        array = []\n",
    "        for i in range(0,len(padded_text) , 8):\n",
    "            byte = padded_text[i:i+8]\n",
    "            array.append(int(byte,2))\n",
    "        return array    \n",
    "   \n",
    "    def compression(self):\n",
    "       \n",
    "        #To access the file and extract text from that file.\n",
    "        filename,file_extension = os.path.splitext(self.path)\n",
    "        output_path = filename + '.bin'\n",
    "        with open (self.path,'r+') as file , open(output_path,'wb') as output:\n",
    "            text = file.read()\n",
    "            text = text.rstrip()\n",
    "           \n",
    "            frequency_dict = self.__frequency_from_text(text)\n",
    "\n",
    "            #Calculate frequency of each text and store it in freq. dictionary\n",
    "\n",
    "            build_heap = self.__Build_heap(frequency_dict)\n",
    "\n",
    "            # Min heap for two minimum frquency.\n",
    "\n",
    "            #Construct binary tree from Heap .\n",
    "\n",
    "            self.__Build_Binary_Tree()\n",
    "\n",
    "            #construct code from binary tree and stored it in dictionary.\n",
    "\n",
    "            self.__Build_Tree_Code()\n",
    "\n",
    "            #Construct encoded text.\n",
    "\n",
    "            encoded_text = self.__Build_Encoded_Text(text)\n",
    "\n",
    "            #padding of text\n",
    "\n",
    "            padded_text = self.__Build_Padded_Text(encoded_text)\n",
    "\n",
    "            #We have to return that binary file as an output.\n",
    "\n",
    "            bytes_array = self.__Build_Byte_Array(padded_text)\n",
    "\n",
    "            final_bytes = bytes(bytes_array)\n",
    "            output.write(final_bytes)\n",
    "        print(\"Compressed\")\n",
    "        return output_path\n",
    "   \n",
    "    def __Remove_Padding(self,text):\n",
    "        padded_info = text[:8]\n",
    "        extra_padding = int(padded_info,2)\n",
    "        text = text[8:]\n",
    "        padding_removed_text = text[:-1*extra_padding]\n",
    "        return padding_removed_text\n",
    "       \n",
    "    def __Decompress_Text(self,text):    \n",
    "        decoded_text = ''\n",
    "        current_bits = ''\n",
    "        for bit in text:\n",
    "            current_bits += bit\n",
    "            if current_bits in self.__reversecode:\n",
    "                character = self.__reversecode[current_bits]\n",
    "                decoded_text += character\n",
    "                current_bits = \"\"\n",
    "        return decoded_text\n",
    "   \n",
    "   \n",
    "    def decompress(self,input_path):\n",
    "        filename,file_extension = os.path.splitext(input_path)\n",
    "        output_path = filename + '_decompressed' + '.txt'\n",
    "        with open(input_path,'rb') as file , open(output_path,'w') as output:\n",
    "            bit_string = ''\n",
    "            byte = file.read(1)\n",
    "            while byte:\n",
    "                byte = ord(byte)\n",
    "                bits = bin(byte)[2:].rjust(8,'0')\n",
    "                bit_string += bits\n",
    "                byte = file.read(1)\n",
    "               \n",
    "            actual_text = self.__Remove_Padding(bit_string)    \n",
    "            decompressed_text = self.__Decompress_Text(actual_text)\n",
    "            output.write(decompressed_text)\n",
    "        return    \n",
    "           \n",
    "path = input(\"ENTER THE PATH OF YOUR FILE....\")  \n",
    "h = Huffmancode(path)\n",
    "output_path = h.compression()\n",
    "h.decompress(output_path)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "0d349367",
   "metadata": {},
   "outputs": [],
   "source": [
    "import heapq\n",
    "import os\n",
    "class BinaryTree:\n",
    "    def __init__(self,value,frequ):\n",
    "        self.value = value\n",
    "        self.frequ = frequ\n",
    "        self.left = None\n",
    "        self.right = None\n",
    "       \n",
    "    def __lt__(self,other):\n",
    "        return self.frequ < other.frequ\n",
    "   \n",
    "    def __eq__(self,other):\n",
    "        return self.frequ == other.frequ        \n",
    "\n",
    "class Huffmancode:\n",
    "   \n",
    "    def __init__(self,path):\n",
    "        self.path = path\n",
    "        self.__heap = []\n",
    "        self.__code = {}\n",
    "        self.__reversecode = {}\n",
    "       \n",
    "    def __frequency_from_text(self,text):\n",
    "        frequ_dict = {}\n",
    "        for char in text:\n",
    "            if char not in frequ_dict:\n",
    "                frequ_dict[char] = 0\n",
    "            frequ_dict[char] +=1\n",
    "        return frequ_dict    \n",
    "   \n",
    "    def __Build_heap(self,frequency_dict):\n",
    "        for key in frequency_dict:\n",
    "            frequency = frequency_dict[key]\n",
    "            binary_tree_node = BinaryTree(key,frequency)\n",
    "            heapq.heappush(self.__heap , binary_tree_node)\n",
    "   \n",
    "    def __Build_Binary_Tree(self):\n",
    "        while len(self.__heap) > 1:\n",
    "            binary_tree_node_1 = heapq.heappop(self.__heap)\n",
    "            binary_tree_node_2 = heapq.heappop(self.__heap)\n",
    "            sum_of_freq = binary_tree_node_1.frequ + binary_tree_node_2.frequ\n",
    "            newnode = BinaryTree(None,sum_of_freq)\n",
    "            newnode.left = binary_tree_node_1\n",
    "            newnode.right = binary_tree_node_2\n",
    "            heapq.heappush(self.__heap,newnode)\n",
    "        return\n",
    "    def __Build_Tree_Code_Helper(self,root,curr_bits):\n",
    "        if root is None:\n",
    "            return\n",
    "        if root.value is not None:\n",
    "            self.__code[root.value] = curr_bits\n",
    "            self.__reversecode[curr_bits] = root.value\n",
    "            return\n",
    "        self.__Build_Tree_Code_Helper(root.left,curr_bits+'0')\n",
    "        self.__Build_Tree_Code_Helper(root.right,curr_bits+'1')\n",
    "   \n",
    "    def __Build_Tree_Code(self):\n",
    "        root = heapq.heappop(self.__heap)\n",
    "        self.__Build_Tree_Code_Helper(root,'')\n",
    "       \n",
    "\n",
    "    def __Build_Encoded_Text(self,text):\n",
    "        encoded_text = ''\n",
    "        for char in text:\n",
    "            encoded_text += self.__code[char]\n",
    "           \n",
    "        return encoded_text  \n",
    "   \n",
    "   \n",
    "    def __Build_Padded_Text(self,encoded_text):\n",
    "        padding_value = 8 - (len(encoded_text) % 8)\n",
    "        for i in range(padding_value):\n",
    "            encoded_text += '0'\n",
    "           \n",
    "        padded_info = \"{0:08b}\".format(padding_value)\n",
    "        padded_encoded_text = padded_info + encoded_text\n",
    "        return padded_encoded_text\n",
    "   \n",
    "    def __Build_Byte_Array(self, padded_text):\n",
    "        array = []\n",
    "        for i in range(0,len(padded_text) , 8):\n",
    "            byte = padded_text[i:i+8]\n",
    "            array.append(int(byte,2))\n",
    "        return array    \n",
    "   \n",
    "    def compression(self):\n",
    "       \n",
    "        #To access the file and extract text from that file.\n",
    "        filename,file_extension = os.path.splitext(self.path)\n",
    "        output_path = filename + '.bin'\n",
    "        with open (self.path,'r+') as file , open(output_path,'wb') as output:\n",
    "            text = file.read()\n",
    "            text = text.rstrip()\n",
    "           \n",
    "            frequency_dict = self.__frequency_from_text(text)\n",
    "\n",
    "            #Calculate frequency of each text and store it in freq. dictionary\n",
    "\n",
    "            build_heap = self.__Build_heap(frequency_dict)\n",
    "\n",
    "            # Min heap for two minimum frquency.\n",
    "\n",
    "            #Construct binary tree from Heap .\n",
    "\n",
    "            self.__Build_Binary_Tree()\n",
    "\n",
    "            #construct code from binary tree and stored it in dictionary.\n",
    "\n",
    "            self.__Build_Tree_Code()\n",
    "\n",
    "            #Construct encoded text.\n",
    "\n",
    "            encoded_text = self.__Build_Encoded_Text(text)\n",
    "\n",
    "            #padding of text\n",
    "\n",
    "            padded_text = self.__Build_Padded_Text(encoded_text)\n",
    "\n",
    "            #We have to return that binary file as an output.\n",
    "\n",
    "            bytes_array = self.__Build_Byte_Array(padded_text)\n",
    "\n",
    "            final_bytes = bytes(bytes_array)\n",
    "            output.write(final_bytes)\n",
    "        print(\"Compressed\")\n",
    "        return output_path\n",
    "   \n",
    "    def __Remove_Padding(self,text):\n",
    "        padded_info = text[:8]\n",
    "        extra_padding = int(padded_info,2)\n",
    "        text = text[8:]\n",
    "        padding_removed_text = text[:-1*extra_padding]\n",
    "        return padding_removed_text\n",
    "       \n",
    "    def __Decompress_Text(self,text):    \n",
    "        decoded_text = ''\n",
    "        current_bits = ''\n",
    "        for bit in text:\n",
    "            current_bits += bit\n",
    "            if current_bits in self.__reversecode:\n",
    "                character = self.__reversecode[current_bits]\n",
    "                decoded_text += character\n",
    "                current_bits = \"\"\n",
    "        return decoded_text\n",
    "   \n",
    "   \n",
    "    def decompress(self,input_path):\n",
    "        filename,file_extension = os.path.splitext(input_path)\n",
    "        output_path = filename + '_decompressed' + '.txt'\n",
    "        with open(input_path,'rb') as file , open(output_path,'w') as output:\n",
    "            bit_string = ''\n",
    "            byte = file.read(1)\n",
    "            while byte:\n",
    "                byte = ord(byte)\n",
    "                bits = bin(byte)[2:].rjust(8,'0')\n",
    "                bit_string += bits\n",
    "                byte = file.read(1)\n",
    "               \n",
    "            actual_text = self.__Remove_Padding(bit_string)    \n",
    "            decompressed_text = self.__Decompress_Text(actual_text)\n",
    "            output.write(decompressed_text)\n",
    "        return    \n",
    "           \n",
    "path = input(\"ENTER THE PATH OF YOUR FILE....\")  \n",
    "h = Huffmancode(path)\n",
    "output_path = h.compression()\n",
    "h.decompress(output_path)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "fde18d7e",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "5bb927b9",
   "metadata": {},
   "outputs": [],
   "source": [
    "import heapq\n",
    "import os\n",
    "class BinaryTree:\n",
    "    def __init__(self,value,frequ):\n",
    "        self.value = value\n",
    "        self.frequ = frequ\n",
    "        self.left = None\n",
    "        self.right = None\n",
    "       \n",
    "    def __lt__(self,other):\n",
    "        return self.frequ < other.frequ\n",
    "   \n",
    "    def __eq__(self,other):\n",
    "        return self.frequ == other.frequ        \n",
    "\n",
    "class Huffmancode:\n",
    "   \n",
    "    def __init__(self,path):\n",
    "        self.path = path\n",
    "        self.__heap = []\n",
    "        self.__code = {}\n",
    "        self.__reversecode = {}\n",
    "       \n",
    "    def __frequency_from_text(self,text):\n",
    "        frequ_dict = {}\n",
    "        for char in text:\n",
    "            if char not in frequ_dict:\n",
    "                frequ_dict[char] = 0\n",
    "            frequ_dict[char] +=1\n",
    "        return frequ_dict    \n",
    "   \n",
    "    def __Build_heap(self,frequency_dict):\n",
    "        for key in frequency_dict:\n",
    "            frequency = frequency_dict[key]\n",
    "            binary_tree_node = BinaryTree(key,frequency)\n",
    "            heapq.heappush(self.__heap , binary_tree_node)\n",
    "   \n",
    "    def __Build_Binary_Tree(self):\n",
    "        while len(self.__heap) > 1:\n",
    "            binary_tree_node_1 = heapq.heappop(self.__heap)\n",
    "            binary_tree_node_2 = heapq.heappop(self.__heap)\n",
    "            sum_of_freq = binary_tree_node_1.frequ + binary_tree_node_2.frequ\n",
    "            newnode = BinaryTree(None,sum_of_freq)\n",
    "            newnode.left = binary_tree_node_1\n",
    "            newnode.right = binary_tree_node_2\n",
    "            heapq.heappush(self.__heap,newnode)\n",
    "        return\n",
    "    def __Build_Tree_Code_Helper(self,root,curr_bits):\n",
    "        if root is None:\n",
    "            return\n",
    "        if root.value is not None:\n",
    "            self.__code[root.value] = curr_bits\n",
    "            self.__reversecode[curr_bits] = root.value\n",
    "            return\n",
    "        self.__Build_Tree_Code_Helper(root.left,curr_bits+'0')\n",
    "        self.__Build_Tree_Code_Helper(root.right,curr_bits+'1')\n",
    "   \n",
    "    def __Build_Tree_Code(self):\n",
    "        root = heapq.heappop(self.__heap)\n",
    "        self.__Build_Tree_Code_Helper(root,'')\n",
    "       \n",
    "\n",
    "    def __Build_Encoded_Text(self,text):\n",
    "        encoded_text = ''\n",
    "        for char in text:\n",
    "            encoded_text += self.__code[char]\n",
    "           \n",
    "        return encoded_text  \n",
    "   \n",
    "   \n",
    "    def __Build_Padded_Text(self,encoded_text):\n",
    "        padding_value = 8 - (len(encoded_text) % 8)\n",
    "        for i in range(padding_value):\n",
    "            encoded_text += '0'\n",
    "           \n",
    "        padded_info = \"{0:08b}\".format(padding_value)\n",
    "        padded_encoded_text = padded_info + encoded_text\n",
    "        return padded_encoded_text\n",
    "   \n",
    "    def __Build_Byte_Array(self, padded_text):\n",
    "        array = []\n",
    "        for i in range(0,len(padded_text) , 8):\n",
    "            byte = padded_text[i:i+8]\n",
    "            array.append(int(byte,2))\n",
    "        return array    \n",
    "   \n",
    "    def compression(self):\n",
    "       \n",
    "        #To access the file and extract text from that file.\n",
    "        filename,file_extension = os.path.splitext(self.path)\n",
    "        output_path = filename + '.bin'\n",
    "        with open (self.path,'r+') as file , open(output_path,'wb') as output:\n",
    "            text = file.read()\n",
    "            text = text.rstrip()\n",
    "           \n",
    "            frequency_dict = self.__frequency_from_text(text)\n",
    "\n",
    "            #Calculate frequency of each text and store it in freq. dictionary\n",
    "\n",
    "            build_heap = self.__Build_heap(frequency_dict)\n",
    "\n",
    "            # Min heap for two minimum frquency.\n",
    "\n",
    "            #Construct binary tree from Heap .\n",
    "\n",
    "            self.__Build_Binary_Tree()\n",
    "\n",
    "            #construct code from binary tree and stored it in dictionary.\n",
    "\n",
    "            self.__Build_Tree_Code()\n",
    "\n",
    "            #Construct encoded text.\n",
    "\n",
    "            encoded_text = self.__Build_Encoded_Text(text)\n",
    "\n",
    "            #padding of text\n",
    "\n",
    "            padded_text = self.__Build_Padded_Text(encoded_text)\n",
    "\n",
    "            #We have to return that binary file as an output.\n",
    "\n",
    "            bytes_array = self.__Build_Byte_Array(padded_text)\n",
    "\n",
    "            final_bytes = bytes(bytes_array)\n",
    "            output.write(final_bytes)\n",
    "        print(\"Compressed\")\n",
    "        return output_path\n",
    "   \n",
    "    def __Remove_Padding(self,text):\n",
    "        padded_info = text[:8]\n",
    "        extra_padding = int(padded_info,2)\n",
    "        text = text[8:]\n",
    "        padding_removed_text = text[:-1*extra_padding]\n",
    "        return padding_removed_text\n",
    "       \n",
    "    def __Decompress_Text(self,text):    \n",
    "        decoded_text = ''\n",
    "        current_bits = ''\n",
    "        for bit in text:\n",
    "            current_bits += bit\n",
    "            if current_bits in self.__reversecode:\n",
    "                character = self.__reversecode[current_bits]\n",
    "                decoded_text += character\n",
    "                current_bits = \"\"\n",
    "        return decoded_text\n",
    "   \n",
    "   \n",
    "    def decompress(self,input_path):\n",
    "        filename,file_extension = os.path.splitext(input_path)\n",
    "        output_path = filename + '_decompressed' + '.txt'\n",
    "        with open(input_path,'rb') as file , open(output_path,'w') as output:\n",
    "            bit_string = ''\n",
    "            byte = file.read(1)\n",
    "            while byte:\n",
    "                byte = ord(byte)\n",
    "                bits = bin(byte)[2:].rjust(8,'0')\n",
    "                bit_string += bits\n",
    "                byte = file.read(1)\n",
    "               \n",
    "            actual_text = self.__Remove_Padding(bit_string)    \n",
    "            decompressed_text = self.__Decompress_Text(actual_text)\n",
    "            output.write(decompressed_text)\n",
    "        return    \n",
    "           \n",
    "path = input(\"ENTER THE PATH OF YOUR FILE....\")  \n",
    "h = Huffmancode(path)\n",
    "output_path = h.compression()\n",
    "h.decompress(output_path)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f54c4332",
   "metadata": {},
   "outputs": [],
   "source": [
    "import heapq\n",
    "import os\n",
    "class BinaryTree:\n",
    "    def __init__(self,value,frequ):\n",
    "        self.value = value\n",
    "        self.frequ = frequ\n",
    "        self.left = None\n",
    "        self.right = None\n",
    "       \n",
    "    def __lt__(self,other):\n",
    "        return self.frequ < other.frequ\n",
    "   \n",
    "    def __eq__(self,other):\n",
    "        return self.frequ == other.frequ        \n",
    "\n",
    "class Huffmancode:\n",
    "   \n",
    "    def __init__(self,path):\n",
    "        self.path = path\n",
    "        self.__heap = []\n",
    "        self.__code = {}\n",
    "        self.__reversecode = {}\n",
    "       \n",
    "    def __frequency_from_text(self,text):\n",
    "        frequ_dict = {}\n",
    "        for char in text:\n",
    "            if char not in frequ_dict:\n",
    "                frequ_dict[char] = 0\n",
    "            frequ_dict[char] +=1\n",
    "        return frequ_dict    \n",
    "   \n",
    "    def __Build_heap(self,frequency_dict):\n",
    "        for key in frequency_dict:\n",
    "            frequency = frequency_dict[key]\n",
    "            binary_tree_node = BinaryTree(key,frequency)\n",
    "            heapq.heappush(self.__heap , binary_tree_node)\n",
    "   \n",
    "    def __Build_Binary_Tree(self):\n",
    "        while len(self.__heap) > 1:\n",
    "            binary_tree_node_1 = heapq.heappop(self.__heap)\n",
    "            binary_tree_node_2 = heapq.heappop(self.__heap)\n",
    "            sum_of_freq = binary_tree_node_1.frequ + binary_tree_node_2.frequ\n",
    "            newnode = BinaryTree(None,sum_of_freq)\n",
    "            newnode.left = binary_tree_node_1\n",
    "            newnode.right = binary_tree_node_2\n",
    "            heapq.heappush(self.__heap,newnode)\n",
    "        return\n",
    "    def __Build_Tree_Code_Helper(self,root,curr_bits):\n",
    "        if root is None:\n",
    "            return\n",
    "        if root.value is not None:\n",
    "            self.__code[root.value] = curr_bits\n",
    "            self.__reversecode[curr_bits] = root.value\n",
    "            return\n",
    "        self.__Build_Tree_Code_Helper(root.left,curr_bits+'0')\n",
    "        self.__Build_Tree_Code_Helper(root.right,curr_bits+'1')\n",
    "   \n",
    "    def __Build_Tree_Code(self):\n",
    "        root = heapq.heappop(self.__heap)\n",
    "        self.__Build_Tree_Code_Helper(root,'')\n",
    "       \n",
    "\n",
    "    def __Build_Encoded_Text(self,text):\n",
    "        encoded_text = ''\n",
    "        for char in text:\n",
    "            encoded_text += self.__code[char]\n",
    "           \n",
    "        return encoded_text  \n",
    "   \n",
    "   \n",
    "    def __Build_Padded_Text(self,encoded_text):\n",
    "        padding_value = 8 - (len(encoded_text) % 8)\n",
    "        for i in range(padding_value):\n",
    "            encoded_text += '0'\n",
    "           \n",
    "        padded_info = \"{0:08b}\".format(padding_value)\n",
    "        padded_encoded_text = padded_info + encoded_text\n",
    "        return padded_encoded_text\n",
    "   \n",
    "    def __Build_Byte_Array(self, padded_text):\n",
    "        array = []\n",
    "        for i in range(0,len(padded_text) , 8):\n",
    "            byte = padded_text[i:i+8]\n",
    "            array.append(int(byte,2))\n",
    "        return array    \n",
    "   \n",
    "    def compression(self):\n",
    "       \n",
    "        #To access the file and extract text from that file.\n",
    "        filename,file_extension = os.path.splitext(self.path)\n",
    "        output_path = filename + '.bin'\n",
    "        with open (self.path,'r+') as file , open(output_path,'wb') as output:\n",
    "            text = file.read()\n",
    "            text = text.rstrip()\n",
    "           \n",
    "            frequency_dict = self.__frequency_from_text(text)\n",
    "\n",
    "            #Calculate frequency of each text and store it in freq. dictionary\n",
    "\n",
    "            build_heap = self.__Build_heap(frequency_dict)\n",
    "\n",
    "            # Min heap for two minimum frquency.\n",
    "\n",
    "            #Construct binary tree from Heap .\n",
    "\n",
    "            self.__Build_Binary_Tree()\n",
    "\n",
    "            #construct code from binary tree and stored it in dictionary.\n",
    "\n",
    "            self.__Build_Tree_Code()\n",
    "\n",
    "            #Construct encoded text.\n",
    "\n",
    "            encoded_text = self.__Build_Encoded_Text(text)\n",
    "\n",
    "            #padding of text\n",
    "\n",
    "            padded_text = self.__Build_Padded_Text(encoded_text)\n",
    "\n",
    "            #We have to return that binary file as an output.\n",
    "\n",
    "            bytes_array = self.__Build_Byte_Array(padded_text)\n",
    "\n",
    "            final_bytes = bytes(bytes_array)\n",
    "            output.write(final_bytes)\n",
    "        print(\"Compressed\")\n",
    "        return output_path\n",
    "   \n",
    "    def __Remove_Padding(self,text):\n",
    "        padded_info = text[:8]\n",
    "        extra_padding = int(padded_info,2)\n",
    "        text = text[8:]\n",
    "        padding_removed_text = text[:-1*extra_padding]\n",
    "        return padding_removed_text\n",
    "       \n",
    "    def __Decompress_Text(self,text):    \n",
    "        decoded_text = ''\n",
    "        current_bits = ''\n",
    "        for bit in text:\n",
    "            current_bits += bit\n",
    "            if current_bits in self.__reversecode:\n",
    "                character = self.__reversecode[current_bits]\n",
    "                decoded_text += character\n",
    "                current_bits = \"\"\n",
    "        return decoded_text\n",
    "   \n",
    "   \n",
    "    def decompress(self,input_path):\n",
    "        filename,file_extension = os.path.splitext(input_path)\n",
    "        output_path = filename + '_decompressed' + '.txt'\n",
    "        with open(input_path,'rb') as file , open(output_path,'w') as output:\n",
    "            bit_string = ''\n",
    "            byte = file.read(1)\n",
    "            while byte:\n",
    "                byte = ord(byte)\n",
    "                bits = bin(byte)[2:].rjust(8,'0')\n",
    "                bit_string += bits\n",
    "                byte = file.read(1)\n",
    "               \n",
    "            actual_text = self.__Remove_Padding(bit_string)    \n",
    "            decompressed_text = self.__Decompress_Text(actual_text)\n",
    "            output.write(decompressed_text)\n",
    "        return    \n",
    "           \n",
    "path = input(\"ENTER THE PATH OF YOUR FILE....\")  \n",
    "h = Huffmancode(path)\n",
    "output_path = h.compression()\n",
    "h.decompress(output_path)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "10e1a1e2",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "44b82fae",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}