1
+ from __future__ import annotations
2
+
1
3
import sys
2
4
3
5
4
6
class Letter :
5
- def __init__ (self , letter , freq ):
6
- self .letter = letter
7
- self .freq = freq
8
- self .bitstring = {}
7
+ def __init__ (self , letter : str , freq : int ):
8
+ self .letter : str = letter
9
+ self .freq : int = freq
10
+ self .bitstring : dict [ str , str ] = {}
9
11
10
- def __repr__ (self ):
12
+ def __repr__ (self ) -> str :
11
13
return f"{ self .letter } :{ self .freq } "
12
14
13
15
14
16
class TreeNode :
15
- def __init__ (self , freq , left , right ):
16
- self .freq = freq
17
- self .left = left
18
- self .right = right
17
+ def __init__ (self , freq : int , left : Letter | TreeNode , right : Letter | TreeNode ):
18
+ self .freq : int = freq
19
+ self .left : Letter | TreeNode = left
20
+ self .right : Letter | TreeNode = right
19
21
20
22
21
- def parse_file (file_path ) :
23
+ def parse_file (file_path : str ) -> list [ Letter ] :
22
24
"""
23
25
Read the file and build a dict of all letters and their
24
26
frequencies, then convert the dict into a list of Letters.
25
27
"""
26
- chars = {}
28
+ chars : dict [ str , int ] = {}
27
29
with open (file_path ) as f :
28
30
while True :
29
31
c = f .read (1 )
@@ -33,36 +35,38 @@ def parse_file(file_path):
33
35
return sorted ((Letter (c , f ) for c , f in chars .items ()), key = lambda l : l .freq )
34
36
35
37
36
- def build_tree (letters ) :
38
+ def build_tree (letters : list [ Letter ]) -> Letter | TreeNode :
37
39
"""
38
40
Run through the list of Letters and build the min heap
39
41
for the Huffman Tree.
40
42
"""
41
- while len (letters ) > 1 :
42
- left = letters .pop (0 )
43
- right = letters .pop (0 )
43
+ response : list [Letter | TreeNode ] = letters # type: ignore
44
+ while len (response ) > 1 :
45
+ left = response .pop (0 )
46
+ right = response .pop (0 )
44
47
total_freq = left .freq + right .freq
45
48
node = TreeNode (total_freq , left , right )
46
- letters .append (node )
47
- letters .sort (key = lambda l : l .freq )
48
- return letters [0 ]
49
+ response .append (node )
50
+ response .sort (key = lambda l : l .freq )
51
+ return response [0 ]
49
52
50
53
51
- def traverse_tree (root , bitstring ) :
54
+ def traverse_tree (root : Letter | TreeNode , bitstring : str ) -> list [ Letter ] :
52
55
"""
53
56
Recursively traverse the Huffman Tree to set each
54
57
Letter's bitstring dictionary, and return the list of Letters
55
58
"""
56
59
if type (root ) is Letter :
57
60
root .bitstring [root .letter ] = bitstring
58
61
return [root ]
62
+ treenode : TreeNode = root # type: ignore
59
63
letters = []
60
- letters += traverse_tree (root .left , bitstring + "0" )
61
- letters += traverse_tree (root .right , bitstring + "1" )
64
+ letters += traverse_tree (treenode .left , bitstring + "0" )
65
+ letters += traverse_tree (treenode .right , bitstring + "1" )
62
66
return letters
63
67
64
68
65
- def huffman (file_path ) :
69
+ def huffman (file_path : str ) -> None :
66
70
"""
67
71
Parse the file, build the tree, then run through the file
68
72
again, using the letters dictionary to find and print out the
0 commit comments