def _build_frequency_map(self, content: bytes) -> dict[int, int]:
        """
            Build the frequency map by counting how many times each byte appears in the content. 
        :param content: The source content bytes.
        :return: A frequency map dictionary.
        """
        with utils.Timer(name="Build frequency map", logger=self._logger):
            frequency_map = defaultdict(lambda: 0)
            for byte in content:
                frequency_map[byte] += 1
            return frequency_map

import abc
import heapq
import typing
from functools import total_ordering


class BaseTreeNode(abc.ABC):
    """
    Abstract base tree class that models a huffman tree.
    """

    def __init__(self, weight: int, is_leaf: bool = False):
        self._weight: int = weight
        self._is_leaf: bool = is_leaf

    def weight(self) -> int:
        return self._weight

    def is_leaf(self) -> bool:
        return self._is_leaf


@total_ordering
class LeafNode(BaseTreeNode):
    def __init__(self, byte_element: int, weight: int):
        super().__init__(weight, is_leaf=True)
        self._element: int = byte_element

    def value(self) -> int:
        return self._element

    def __lt__(self, other):
        if not issubclass(other.__class__, BaseTreeNode):
            return NotImplemented
        return self.weight() < other.weight()


class InternalNode(BaseTreeNode):
    def __init__(self, left: BaseTreeNode, right: BaseTreeNode):
        weight = left.weight() + right.weight()
        super().__init__(weight, is_leaf=False)
        self._weight = weight
        self._left = left
        self._right = right

    def left(self):
        return self._left

    def right(self):
        return self._right

    def __lt__(self, other):
        if not issubclass(other.__class__, BaseTreeNode):
            return NotImplemented
        return self.weight() < other.weight()

    @staticmethod
    def from_frequency_map(
        frequency_map: dict[int, int],
    ) -> typing.Optional["InternalNode"]:
        """
            Builds the huffman tree from a given frequency map.
        :param frequency_map: The frequency map.
        :return: An internal node representing the root of the tree.
        """
        if not frequency_map:
            return None
        # Create a heap
        binary_heap = []
        for item in frequency_map.items():
            # push item into the heap by frequency and character
            heapq.heappush(binary_heap, LeafNode(byte_element=item[0], weight=item[1]))

        # Build the Huffman tree
        while len(binary_heap) > 1:
            left = heapq.heappop(binary_heap)
            right = heapq.heappop(binary_heap)
            #  internal node by frequency, in order to be traversed
            heapq.heappush(binary_heap, InternalNode(left, right))
        return binary_heap[0]

    def _build_encoding_table(self):
        """
        Builds the encoding table for huffman using a Depth First Search algorithm on the tree.
        """
        with utils.Timer(name="Build encoding table", logger=self._logger):
            stack = []
            root = self._huffman_tree_root
            stack.append([root, []])
            while len(stack) > 0:
                element, encoding = stack.pop()
                if element.is_leaf():
                    self._encoding_table[element.value()] = "".join(encoding)
                else:
                    if (left := element.left()) is not None:
                        stack.append([left, [*encoding, "0"]])
                    if (right := element.right()) is not None:
                        stack.append([right, [*encoding, "1"]])

    def _get_encoded_file_contents(self, content: bytes) -> BitArray:
        """
            Given unencoded contents it encodes them with huffman codes.
        :param content: The raw content bytes.
        :return: The encoded content bytes.
        """
        with utils.Timer(name="Encode source file", logger=self._logger):
            buffer = []
            for byte in content:
                buffer.append(self._encode_byte(byte))
            bit_array = BitArray(bin="".join(buffer))
            return bit_array

    def _encode_byte(self, byte: int) -> str:
        """
        Encode the given byte using the huffman tree.
        """
        if byte in self._encoding_table:
            return self._encoding_table[byte]
        raise Exception(
            f"Can't encode byte {byte}. It is not found in the encoding table."
        )

    def encode(self, file_name: str, destination: str):
        """
            Encodes a given file into huffman bytes and writes it to disk..
        :param file_name: The path to the file name.
        :param destination: The path to the destination file name.
        """
        with open(file_name, "rb") as fh:
            content = fh.read()

        frequency_map = self._build_frequency_map(content)

        self._build_huffman_tree(frequency_map)
        self._build_encoding_table()

        bit_array = BitArray()
        encoding_table = pickle.dumps(self._encoding_table)
        # 2 bytes unsigned integer for the encoding table length
        bit_array.append(pack("<H", len(encoding_table)))
        # the whole encoding table pickled
        bit_array.append(encoding_table)
        # the huffman encoded file contents
        encoded_content = self._get_encoded_file_contents(content)
        if len(encoded_content) % 8 == 0:
            encoded_content_padding_bits = 0
        else:
            encoded_content_padding_bits = 8 - (len(encoded_content) % 8)
        bit_array.append(pack("<B", encoded_content_padding_bits))
        bit_array.append(encoded_content)

        self._write_to_destination_file(bit_array, destination)
        self._logger.info(f"Done encoding {file_name}.")

#...

    def _write_to_destination_file(self, content: BitArray, destination: str):
        """
            Writes the bytes to the destination file.
        :param content: The content bytes.
        :param destination: The destination file name
        """
        with utils.Timer(name="Write to destination", logger=self._logger):
            with open(destination, "wb") as fh:
                content.tofile(fh)
            self._logger.debug(
                f"Wrote {content.len} bits to destination file: {destination}"
            )