huff_unzip.py
===================================

from make_tree import *

def str_to_int(s, n):
	i = n - 1
	sum = 0 
	j = 1
	while i >= 0:
		sum = sum + j * ord(s[i])
		i = i - 1
		j = j * 256
	return sum

def ascii_to_bin(s):
	k = ord(s)
	sp = ''
	saras = []
	while k > 0:
		p = k % 2 
		k = k / 2
		sp = sp + str(p)
		saras.append(p)

		
	k = 7 - len(saras) + 1
	while k > 0:
		saras.append(0)
		k = k - 1

	saras.reverse()

	sk = ''
	for i in saras:
		sk = sk + str(i)

	return sk

global eilute

eilute = ''

def tree_reverse(m, s):
	if m.left == None and m.right == None:
		global eilute
		eilute = eilute +  chr(m.freq)
		return
	if len(s) > 0: 
		x = s[0]
		del s[0]
		if x == '0': tree_reverse(m.left, s)
		if x == '1': tree_reverse(m.right, s) 
		
f = open('failas.krf', 'r')

p = f.read(2)
k = str_to_int(p,2)

p = f.read(k + k*2)

i = 0

medis = {} 

while i < (k+k*2):	
	s = ''
	s = p[i+1] + p[i+2]
	j = str_to_int(s,2)
	medis[ord(p[i])] = j	
	i = i + 3

l = f.read(1)

print 'l=' + l 
sp = ''

if l == '|':
	c = 't'
	sp = ''
	while c != '|':
		c = f.read(1)
		if c != '|': sp = sp + c
 
print 'l= ' + sp


	

m = make_tree(medis)
code = ''

print_tree(m, None, code)


ptr = f.read()

p = ''
for i in ptr:
	p = p + ascii_to_bin(i)	
	

ptr = list(l)

print p 
for i in sp:
	p = p + str(i)

p = list(p)

print p 

while len(p) > 0:
	tree_reverse(m, p)

print eilute


make_tree.py
=======================

'''
    simple huffman tree
    gives binary codes
    written by kestaz   
'''

from copy import deepcopy

class tree:
    def __init__(self,freq,value):
        self.value = value
        self.freq = freq
        self.right = None
        self.left = None

def make_simple_tree(m):
    l = []
    for i in m:
        l.append(i.freq)
        l.sort()
    x = l[0]
    del l[0]
    y = l[0]
    for v,i in enumerate(m):
        if x == i.freq:
            t = 1
            p1 = deepcopy(i)
            v1 = v
    if t == 1:
        t = 0
        del m[v1]
        for v,i in enumerate(m):
            if y == i.freq:
                t = 1
                p2 = deepcopy(i)
                v2 = v
        if t == 1:
            del m[v2]
            f = tree(p1.freq+p2.freq,'*')
            f.right = p1
            f.left = p2
            m.append(f)

array = {}

def print_tree(d, c, code):
    global array
    if d != None:
        if c != None: code = code + str(c)
    if d.left == None and d.right == None: 
        print str(d.freq) + ' ' + str(d.value)
        array[d.freq] = [d.value, code]
        print code
        code = ''
        return
    print_tree(d.right,1, code)
    print_tree(d.left, 0, code)


def tree_print(d):
    if d == None: return 
    print str(d.freq) + ' ' + str(d.value)
    tree_print(d.left)
    tree_print(d.right)
    
d = { 5: 1, 7: 2, 10: 3, 15: 4, 20: 5, 45:6}

m = []
def make_tree(d):
    for i in d.keys():
        k = d[i]
        m.append(tree(i,k))
    while len(m)>1:
        make_simple_tree(m)

    code = ''
    return m[0]

#make_tree(d)
#code = ''
#print_tree(m[0], None, code)
#print ''
#tree_print(m[0])

huff.py
=========================


from make_tree import *

from copy import deepcopy
from string import split


def bin_str_convert_to_int(bin_code):
	i = 7
	j = 1	
	sum = 0
	while i >= 0:
		if bin_code[i] == '1': sum = sum + j * 1
		j = j * 2
		i = i - 1
	return sum

def insert_ascii(num,num_len):
	s = ''
	while num > 0:
		k = num % 256
		num = num / 256
		s = s + chr(k)

	p = num_len - len(s) + 1

	if p > 0:
		s_tr = ''
 
		while p > 1:
			s_tr = s_tr + chr(0)
			p = p - 1
		s_tr = s_tr + s
		return s_tr
	if p == 0: return s
	return s
	
file_name = 'failas.txt'

f = open('failas.txt')

text = f.read()

freq = {}

for i in text:
    p = ord(i)
    freq[p] = 0

for i in text:
    p = ord(i)
    k = freq[p]
    k = k + 1
    freq[p] = k

print freq
m = make_tree(freq)
code = ''
print_tree(m, None, code)

output = ''

print array

p = 0 

for i in text:
    t = 0
    for k in array:
        if i == chr(k):
            t = 1
    if t != 1:
	p = 1

if p == 0:
	print 'Tree created'
	huffcode = ''
	for i in text:
		t = 0 
		for k in array:
			if i == chr(k):
				huffcode = huffcode + array[k][1]
	print huffcode
	print 'huffcode binary code length ' + str(len(huffcode))
		
	huff_list = list(huffcode)
	
	ascii_code = ''

	while len(huff_list) > 8:
		one_byte = ''
		for i in range(8):
			x = huff_list[0]
			one_byte = one_byte + x
			del huff_list[0]
		k = bin_str_convert_to_int(one_byte)
		ascii_code = ascii_code + chr(k)	
	
	print ascii_code
	print 'last elements: ' + str(huff_list)
	
	name, ext = split(file_name, '.')	

	f = open(name + '.krf', 'w')
	f.write(insert_ascii(len(array),2 ))
	for i in array.keys():
		f.write(insert_ascii(i,1) + insert_ascii(array[i][0],2))
	
	i = 7 - len(huff_list) + 1
	
	s = ''
	#while i > 0:
	#	s = s + '0'
	#	i = i - 1
	
	for i in huff_list:
		s = s + str(i)

	#k = bin_str_convert_to_int(s)
	 

	f.write('|' + s + '|')
	
	f.write(ascii_code)

	f.close()
else:
	print 'make tree error'