data_get_store

"""
I need the data stored in txt file's format is

date            value
20161010        1.123
20161011        1.211

I get the fund data from internet web resources, and write to txt file daily.
And I will check the data order to place the latest data in front, and long time ago data in last.
If the already exist data is ordered, I will only add new data to the file,
if not, I will add new data and reorder all the data and write into a new file.

test xxx.txt in same dir
20161010 	1.21444
20161002 	1.41444
20161005 	1.31444
20161003 	1.81444
20161007 	1.51444
"""

def TransDataToDict(file_handle):
    from collections import OrderedDict
    import decimal
    raw_data = OrderedDict()
    line_num = 0
    for line in file_handle:
        try:
            [key,value] = line.split()
        except ValueError:
            return ("Please check line %0d, the data format may be not correct!" % (line_num))
        # raw_data[int(key)] = ("%.4f" % float(value)) # string not float type
        raw_data[int(key)] = decimal.Decimal("%.4f" % float(value))
        line_num = line_num + 1
    file_handle.close()
    return raw_data

def GetDataFromTxt(txt_str=""):
    raw_data = {}
    try:
        datafile = open(txt_str, "r")
    except FileNotFoundError:
        return ("Oops! the file %s does not exist, Pleade have a check!" % (txt_str))
    return TransDataToDict(datafile)

def GetIndexToList(ord_dict,index="key"):
    key_list = []
    for key in ord_dict:
        if index == "key":
            key_list.append(key)
        else:
            key_list.append(ord_dict[key])
    return key_list

def CompareTwoElements(x,y,order=0):    # 0 means left smaller than right, 1 means opposite.
        return x>=y if order else x<=y     

def JudgeOrderForArray(array,order=0):  # order 0 means small to large, 1 means large to small
    i = 0
    if(len(array)==0):
        return 1
    last_index = len(array)-1
    while(i<last_index and CompareTwoElements(array[i],array[i+1],order)):
        i = i+1
    return i==last_index

'''
given a array, use following function to judge it is a ordered array or not
if it is ordered, gives its order:
0 represent small to large, 1 means large to small
if it it not ordered, the order is None
'''
def JudgeAndGiveOrderForArray(array):
    i=0
    while((i<len(array)-1) and array[i]==array[i+1]):
        i = i+1
    remain_arr=array[i:]
    order = (0 if (i==(len(array)-1) or len(array)==0) else (array[i]>array[i+1]))
    is_order = JudgeOrderForArray(remain_arr,order)
    order_val = int(order) if is_order else None
    return bool(is_order),order_val

def OrderedDictReorder(ord_dict,index="key",rev=False):
    from collections import OrderedDict
    return OrderedDict(sorted(ord_dict.items(), key=lambda t:t[0] if index=="key" else t[1],reverse=rev))

def WriteNewDictDataToFile(ord_dict,txt_str=""):
    from collections import OrderedDict
    datafile = open(txt_str, "w")
    for index in ord_dict:
        datafile.write("%d\t%.4f\n" % (index, ord_dict[index]))
    datafile.close()

'''
before call this function, use above functions to reorder the new_data
to a new txt file, and the old txt file has been reordred,
so this function only need to judge the order and decide to merge or add
the new txt data to old txt from which position(start or end)
'''
def AddNewDataToFile(old_data_txt="",add_data_txt="",new_data_txt=""):
    from collections import OrderedDict
    old_key_list = GetIndexToList(GetDataFromTxt(old_data_txt))
    add_key_list = GetIndexToList(GetDataFromTxt(add_data_txt))
    old_is_order,old_order_val = JudgeAndGiveOrderForArray(old_key_list)
    add_is_order,add_order_val = JudgeAndGiveOrderForArray(add_key_list)
    if(old_is_order==False):
        return ("Please check the data in %s, it is not ordered!" %s (old_data_txt))
    if(add_is_order==False):
        return ("Please check the data in %s, it is not ordered!" %s (add_data_txt))
    if(old_order_val!=1):
        return ("I hope the data in %s order is larger to small for date key!" %s (old_data_txt))
    if(add_order_val!=1):
        return ("I hope the data in %s order is larger to small for date key!" %s (add_data_txt))
    
if __name__ == "__main__":   
    raw_data = GetDataFromTxt("xxx.txt")
    print(raw_data)    
    key_list = GetIndexToList(raw_data,"key")
    val_list = GetIndexToList(raw_data,"val")
    print(key_list)
    print(val_list)
    key_order_or_not_s = JudgeOrderForArray(key_list)
    val_order_or_not_s = JudgeOrderForArray(val_list)
    key_order_or_not_l = JudgeOrderForArray(key_list,1)
    val_order_or_not_l = JudgeOrderForArray(val_list,1)    
    print(key_order_or_not_s)
    print(val_order_or_not_s)
    print(key_order_or_not_l)
    print(val_order_or_not_l)
    key_ordered_data_s = OrderedDictReorder(raw_data,"key")   # raw_data not changed     
    key_ordered_data_l = OrderedDictReorder(raw_data,"key",True)
    val_ordered_data_s = OrderedDictReorder(raw_data,"val")
    val_ordered_data_l = OrderedDictReorder(raw_data,"val",True)    
    print(key_ordered_data_s)
    print(key_ordered_data_l)   
    print(val_ordered_data_s)
    print(val_ordered_data_l)
    WriteNewDictDataToFile(key_ordered_data_s,txt_str="key_ordered_data_s.txt")
    WriteNewDictDataToFile(key_ordered_data_l,txt_str="key_ordered_data_l.txt")
    WriteNewDictDataToFile(val_ordered_data_s,txt_str="val_ordered_data_s.txt")
    WriteNewDictDataToFile(val_ordered_data_l,txt_str="val_ordered_data_l.txt")


#order_data = OrderedDict()
#order_data = OrderedDict(raw_data)

#print(GetDataFromTxt("xxx.txt"))
#print(GetIndexToList(GetDataFromTxt("xxx.txt"),))
#print(GetIndexToList(GetDataFromTxt("xxx.txt"),"val"))

#print(CompareTwoElements(1,1,0))
#print(JudgeOrderForArray([4,3,3,2],1))

print(JudgeAndGiveOrderForArray([4,3,2,1,1,1]))
print(JudgeAndGiveOrderForArray([1]))