tcopy.py_March5th

#!/usr/bin/python

import csv
from datetime import datetime
import time
from colorama import Back, Fore, Style
import statistics



Liquidity = float()
ref_Num = int()
prevVol = float(1)
prevPrice = float(1)
prevFlow = float(1)
ValuePrice = float()

SumFlow = float()
SumVol = float()
Bearish = bool
Bullish = bool

Price1 = float()
Price2 = float()
prevPrice1 = float()

Last = float()
PL = float()
PLString = str()
Chg = float()
SignalList = []

MIV_Spike = float()
MIV_Spike_Count = int()

SpreadList = []
TotalSpread = float()
ThreeHourSpreadAvg = float()
OneHourSpreadAvg = float()

SpreadRatio = float()


Mark = int()

with open('/Users/King/data.csv', 'r') as csv_file:
    reader = csv.reader(csv_file)
    header = next(reader)
    for row in reader:
        ref_Num += 1
        dTime = str(datetime.strptime(row[0], '%a %b %d %H:%M'))
        Time = dTime[-14:]
        Open_Price = float(row[1])
        Close_Price = float(row[2])
        High_Price = float(row[3])
        Low_Price = float(row[4])
        Money_Flow = float(row[6])
        last = Close_Price
        Vol = row[5]
        f_Vol = float(Vol[:-1])
        m_Vol = str(Vol[-1:])
        if m_Vol == "K":
            f_Vol = f_Vol * 1000
        if m_Vol == "M":
            f_Vol = f_Vol * 1000000
        if m_Vol != "K" and m_Vol != "M":
            f_Vol = float(row[5])
        if f_Vol < 1:
            M_Price = HLCC
        else:
            M_Price = round(float(Money_Flow) / f_Vol, 2)
        HLCC = float(High_Price + Low_Price + Close_Price + Close_Price) / 4
        Diff = round(HLCC - M_Price, 2)
        MMM = float(f_Vol * HLCC)
        Liq_change = float(Money_Flow - MMM)
        Liquidity += Liq_change
        Date = str(Time[:5])
        military_time = str(Time[-8:])
        criteria = abs(.0035 * HLCC)
        HLC3 = float(High_Price+ Low_Price + Close_Price + Close_Price + Close_Price) / 5
        Mid = High_Price - abs(High_Price - Low_Price)
        Paway = round(100*((M_Price - Close_Price) / Close_Price), 3)


        SumVol += f_Vol
        SumFlow += Money_Flow
        ValuePrice1 = round(SumFlow / SumVol, 2)
        MidValPrice = [ValuePrice1,Close_Price]
        ValuePrice = round(statistics.median(MidValPrice), 2)

        Spread = round(abs(Close_Price - ValuePrice), 2)
        SpreadList.append(Spread)

        criteria2 = abs(.003 * HLCC)








        if ref_Num >=2:
            prevPrice1 = Close_Price

        if HLCC <= ValuePrice:
            Bearish = True
            Bullish = False
            Signal = 'SELL'
            SignalStr = Fore.RED+Signal+Style.RESET_ALL
            SignalList.append(Signal)





        if HLCC >= ValuePrice:
            Bearish = False
            Bullish = True
            Signal = 'BUY'
            SignalStr = Fore.CYAN+Signal+Style.RESET_ALL
            SignalList.append(Signal)





        if Liq_change > 0:
            liqchgstr = '{:20,.2f}'.format(Liq_change)+Style.RESET_ALL
            LiqChangeStr = Fore.CYAN+liqchgstr+Style.RESET_ALL

        if Liq_change < 0:
            liqchgstr = '{:20,.2f}'.format(Liq_change)+Style.RESET_ALL
            LiqChangeStr = Fore.RED+liqchgstr+Style.RESET_ALL

        DateStr = Fore.YELLOW+str(Date)+Style.RESET_ALL
        TimeStr = Fore.YELLOW+str(military_time)+Style.RESET_ALL

        if Liquidity > 0:
            Liqstr = '{:20,.2f}'.format(Liquidity)
            LiqStr = Fore.CYAN+Liqstr+Style.RESET_ALL

        if Liquidity < 0:
            Liqstr = '{:20,.2f}'.format(Liquidity)
            LiqStr = Fore.WHITE+Liqstr+Style.RESET_ALL




        if Money_Flow > 0:
            MIV_Index = round(100 * (f_Vol / prevVol) - 100 * ((Money_Flow * HLCC) / (prevFlow * prevPrice)), 3)
            prevPrice = Close_Price
            prevFlow = Money_Flow
            prevVol = f_Vol
            MIV_Index_String = str(MIV_Index)
            LiqFlowPrice = round(abs(Liq_change / Money_Flow), 4)

        if MIV_Index >= .25:
            MIV_Spike += abs(MIV_Index)
            MIV_Spike_Count += 1
            Avg_MIV_Spike = round(MIV_Spike / MIV_Spike_Count, 3)


        if abs(Liq_change) > 0:
            LiqFlowPrice = .01*round(Money_Flow / abs(Liq_change), 3)
            VolLiqPrice = round(f_Vol / abs(Liq_change), 2)
            LiqFlowPriceClone = round(1000 * (abs(Liq_change) / Money_Flow), 4) * .01
##################################################################################################################################################################
        if abs(M_Price - HLCC) >= criteria:
            Range_Clause = True
            diff = abs(M_Price - Close_Price)
            if Range_Clause == True:
                found_Price = Close_Price
                range_ref_String = str()
                Low_Range = round(HLCC - abs(float(M_Price - HLCC)), 2)
                High_Range = round(HLCC + abs(float(M_Price - HLCC)), 2)
                Low_Target = round(Low_Range - abs(float(M_Price - HLCC)), 2)
                High_Target = round(High_Range + abs(float(M_Price - HLCC)), 2)
                if M_Price >= High_Range:
                        r_Price = M_Price
                        t_Price = High_Target
                        oppRange = Low_Range
                        oppTarget = Low_Target
                        tHigh = True
                        found_Price = Close_Price
                        tLow = False
                        range_ref_String = 'HIGH TARGET'
                        if MIV_Index > 0:
                            range_ref_String = 'FALSE HIGH TARGET (CAPPER)'
                elif M_Price <= Low_Range:
                    r_Price = M_Price
                    t_Price = Low_Target
                    oppRange = High_Range
                    oppTarget = High_Target
                    tLow = True
                    tHigh = False
                    found_Price = Close_Price
                    range_ref_String = 'LOW TARGET'


                if range_ref_String == 'FALSE HIGH TARGET (CAPPER)':
                        Program = 'HIGH CONFIDENCE'

                if range_ref_String == 'LOW TARGET':
                    if LiqFlowPriceClone >= .039:
                        if LiqFlowPrice <= 2.65 and LiqFlowPrice >= 2.5:
                            Program = 'MODERATE CONFIDENCE'
                        if LiqFlowPrice <= 2.5 and LiqFlowPrice >= 2.45:
                            Program = 'HIGH CONFIDENCE'
                        if LiqFlowPrice <= 2.45:
                            Program = 'VOLATILE LOW (HIGH CONFIDENCE)'
                    else:
                        Program = 'LOW CONFIDENCE / LIQUIDITY SEARCH'



                if LiqFlowPriceClone >=.039 and range_ref_String == 'HIGH TARGET':
                    if LiqFlowPrice < 2.6:
                        Program = 'VOLATILE BULL TRAP (MODERATE CONFIDENCE)'
                    if LiqFlowPrice > 2.6 and LiqFlowPrice < 2.8:
                        if abs(MIV_Index) >= Avg_MIV_Spike * .75:
                            HighRangeStr = str(High_Target)
                            Program = 'HIGH CONFIDENCE (IMMEDIATE PRESSURE: %s)' % HighRangeStr
                            Program = 'MODERATE CONFIDENCE'

                if LiqFlowPrice >= 2.81 and range_ref_String == 'HIGH TARGET':
                    Program = 'BIG BULLISH'


                if LiqFlowPriceClone <= .037:
                    if range_ref_String == 'HIGH TARGET':
                        if LiqFlowPrice >= 2.75:
                            oppTargetStr = str(oppTarget)
                            if abs(MIV_Index) >= Avg_MIV_Spike * 3:
                                Program = '<<LONG TERM>> BULLISH (BTMFD)'+oppTargetStr
                        if LiqFlowPrice <= 2.75 and LiqFlowPrice >= 2.75:
                            Program = 'VERY HIGH CONFIDENCE'




                if LiqFlowPriceClone <= .036 and LiqFlowPrice > 2.8:
                    if tLow == True:
                        if MIV_Index < 0:
                            LowRangePT = round(Close_Price - abs(oppTarget - Low_Target), 2)
                            LowRangePL = round(-1*(Close_Price - LowRangePT) / Close_Price, 2)
                            Program = 'EXTREMELY HIGH CONFIDENCE (PT [%s])' % LowRangePL
                        elif MIV_Index > 0:
                            HighRangeStr = str(High_Range)
                            Program = 'EXTREMELY HIGH CONFIDENCE (SELL %s)' % HighRangeStr
                    if tHigh == True:
                        if MIV_Index < 0 and abs(MIV_Index) > Avg_MIV_Spike:
                            HighRangePT = round(Close_Price + (High_Target - Low_Target), 2)
                            HighRangePL = round((HighRangePT - Close_Price) / Close_Price, 2)
                            HighRangePTStr = str(HighRangePT)
                            HighRangePLStr = str(HighRangePL)+'%'
                            if HighRangePT > Close_Price:
                                Program = 'MAXIMUM CONFIDENCE PT [$ %s]' % HighRangePT
                            else:
                                Program = 'SELL THE FUCKING RIP (<<IMMEDIATE TERM ONLY>>)'

                        if abs(MIV_Index) < Avg_MIV_Spike:
                            HighRangeStr = str(High_Range)
                            Program = 'BULLS FULLA SHIT [RIP] (SELL %s)' % HighRangeStr






                if tHigh == True and MIV_Index < 0:
                    if abs(MIV_Index) >= Avg_MIV_Spike * 3:
                        Program = 'EXTREMELY HIGH CONFIDENCE'

                if LiqFlowPriceClone >= .042 and LiqFlowPrice <= 2.40:
                    if range_ref_String == 'LOW TARGET':
                        HR_String = str(High_Range)
                        HT_String = str(High_Target)
                        Program = 'FALSE LOW (BULLISH TERRITORY %s - %s)' % (HR_String, HT_String)
                    if range_ref_String == 'HIGH TARGET':
                        LR_String = str(Low_Range)
                        LT_String = str(Low_Target)
                        Program = 'FALSE HIGH (BEARISH TERRITORY %s -%s)' % (LR_String, LT_String)





                if range_ref_String == 'LOW TARGET' and tLow == True:
                    if abs(MIV_Index) >= Avg_MIV_Spike * 3:
                        Program = 'WALL OF CHINA OVERHEAD'

                    if abs(MIV_Index) >= Avg_MIV_Spike * 1.5 and LiqFlowPriceClone >= .39:
                        Program = 'IMMEDIATE SELLOFF (HIGH CONFIDENCE)'

                    if LiqFlowPriceClone <= .038:
                        if LiqFlowPrice >= 2.82:
                            Program = 'EXTREMELY HIGH CONFIDENCE'
                        if LiqFlowPrice >= 2.70 and LiqFlowPrice <= 2.82:
                            Program = 'VOLATILITY COMING (HIGH CONFIDENCE <LONG TERM>)'
                        if LiqFlowPrice <= 2.70:
                            Program = 'POTENTIAL BOTTOM'

                    if LiqFlowPriceClone < .037 and LiqFlowPrice < 2.8:
                        Program = 'BOTTOM REVERSAL TARGET [$',Low_Target,']'

                    if LiqFlowPrice >= 2.6 and MIV_Index >= 0:
                        if MIV_Index < Avg_MIV_Spike and LiqFlowPriceClone <= .038:
                            if LiqFlowPrice >= 2.7 and LiqFlowPrice < 2.81:
                                Program = 'MMs IN CONTROL (BULLISH)'
                                if LiqFlowPrice >= 2.81:
                                    Program = 'MMs IN CONTROL (EXTREMELY BEARISH)'
                            if LiqFlowPrice <= 2.7 and LiqFlowPrice >= 2.6:
                                Program = 'MMs IN CONTROL'
                        if MIV_Index >= Avg_MIV_Spike and LiqFlowPrice <= 2.6:
                            if LiqFlowPriceClone >= .04:
                                Program = 'MMs IN CONTROL (BEARISH)'




                print(Date, military_time,'  Current Liquidity:', '{:20,.2f}'.format(Liquidity), '  Liq Change:','{:20,.2f}'.format(Liq_change), '  Last Price:', Close_Price, range_ref_String+'   Type: '+Program+'  MIV [',MIV_Index,'%]',' LFP [',LiqFlowPrice,']',' LFP Clone [',LiqFlowPriceClone,']','   Avg MIV:',Avg_MIV_Spike)
                time.sleep(2.5)
        else:
            Range_Clause = False
            tHigh = False
            tLow = False

        if abs(M_Price - HLCC) >= criteria2 and Range_Clause == False:
            Mark_The_Maker = True
            diff = abs(M_Price - Close_Price)
            if Mark_The_Maker == True:

                if M_Price > Close_Price:
                    MMLow = True
                    MMHigh = False

                elif M_Price < Close_Price:
                    MMLow = False
                    MMHigh = True


                if LiqFlowPriceClone <= .02 and LiqFlowPrice >= 5:
                    Mark_Says = 'WHO NEEDS LIQUIDITY ANYWAY? (SELL)'


                if LiqFlowPriceClone >= .03 and LiqFlowPrice <= 3.4:
                    Mark_Says = 'IMA TRAP THIS MF ~ Mark'

                if LiqFlowPriceClone >= .025 and LiqFlowPrice <= 4:
                    if MIV_Index < 0 and M_Price > Close_Price:
                        if MMHigh == True:
                            Mark_Says = 'IM FUCKIN SELLING ~ Mark'
                        elif MMLow == True:
                            Mark_Says = 'IM FUCKIN BUYING ~ Mark'


                print(Date, military_time,'  Current Liquidity:', '{:20,.2f}'.format(Liquidity), '  Liq Change:','{:20,.2f}'.format(Liq_change), '  Last Price:', Close_Price, range_ref_String+'   Type: '+Mark_Says+'  MIV [',MIV_Index,'%]',' LFP [',LiqFlowPrice,']',' LFP Clone [',LiqFlowPriceClone,']','   Avg MIV:',Avg_MIV_Spike)
                time.sleep(1.5)

        else:
            Mark_The_Maker = False



        time.sleep(.0075)

        if ref_Num % 2 != 0:
            Price1 = Close_Price

        if ref_Num % 2 == 0:
            Price2 = Close_Price


        if ref_Num % 2 != 0 and ref_Num > 2:
            Last = Price2
            Chg = 100*round((Close_Price - Last) / Last, 4)

        if ref_Num % 2 == 0 and ref_Num >= 2:
            Last = Price1
            Chg = 100*round((Close_Price - Last) / Last, 4)


        for i in SignalList[-2:-1]:
            if i == 'BUY':
                PL += Chg
            if i == 'SELL':
                PL += Chg*-1
        # if Bullish == True:
        #     PL += Chg
        # if Bearish == True:
        #     PL += Chg*-1

        PLR = round(PL, 3)
        if PL > 0:
            PLString = Fore.CYAN+str(PLR)+'%'
        if PL < 0:
            PLString = Fore.RED+str(PLR)+'%'

        if Range_Clause == False and Mark_The_Maker == False:
            '''if abs(Liq_change) >= 1000000:
                print(DateStr, TimeStr,'  Current Liquidity:'+LiqStr,'  Liq Change:'+LiqChangeStr,'  Last Price:',Close_Price, SignalStr+Style.RESET_ALL+'         ['+PLString+Style.RESET_ALL+']','        ',MIV_Index,'  LFP: [',LiqFlowPrice,']',' LFPClone:[',LiqFlowPriceClone,']','   MIV: ',MIV_Index,'  Avg MIV: ',Avg_MIV_Spike, '$Price: ',M_Price)
            else:'''
            print(DateStr, TimeStr,'  Current Liquidity:'+LiqStr,'  Liq Change:'+LiqChangeStr,'  Last Price:',Close_Price, SignalStr+Style.RESET_ALL+'         ['+PLString+Style.RESET_ALL+']','        ',ValuePrice,'  Spread: [$',Spread,']', M_Price)