TargetPrograms.py_March3rd

#!/usr/bin/python

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



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()


with open('/Users/King/Spy_current.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
        Paway = round(100*((M_Price - Close_Price) / Close_Price), 3)


        SumVol += f_Vol
        SumFlow += Money_Flow
        ValuePrice = round(SumFlow / SumVol, 2)


        if ref_Num >=2:
            prevPrice1 = Close_Price

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


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


        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 = abs(Liq_change / Money_Flow)

        if MIV_Index >= .25:
            MIV_Spike += MIV_Index
            MIV_Spike_Count += 1
            Avg_MIV_Spike = MIV_Spike / MIV_Spike_Count


        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:

            diff = abs(M_Price - Close_Price)
            Range_Clause = True
            range_identifier_all = 'All'

            if Range_Clause == True:
                t_price = M_Price
                found_Price = Close_Price
                range_ref_String = ''
                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 == 'LOW TARGET':
                    if LiqFlowPriceClone >= .039:
                        if LiqFlowPrice <= 2.6 and LiqFlowPrice >= 2.45:
                                Program = 'MODERATE CONFIDENCE'
                        if LiqFlowPrice < 2.45:
                                Program = 'HIGH CONFIDENCE'
                    else:
                        Program = 'LOW CONFIDENCE / LIQUIDITY SEARCH'

                if LiqFlowPriceClone >= .04:
                    if range_ref_String == 'HIGH TARGET':
                        if LiqFlowPrice > 2.6:
                            oppRange = str(Low_Range)
                            oppTarget = str(Low_Target)
                            Program = 'SCALP OPPOSITE'+' $'+oppTarget+'-$'+oppRange
                        else:
                            Program = 'LOW CONFIDENCE'
                    if range_ref_String == 'LOW TARGET':
                        if LiqFlowPrice < 2.45:
                            oppTarget = str(High_Target)
                            oppRange = str(High_Range)
                            Program = 'VOLATILE LOW (HIGH CONFIDENCE)'

                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:
                        Program = 'MODERATE CONFIDENCE'

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

                    if range_ref_String == 'LOW TARGET':
                        if LiqFlowPrice >= 2.75:
                            Program = 'BUY THE FUCKING DIP'
                        if LiqFlowPrice <= 2.75:
                            Program = 'POTENTIAL BOTTOM'



                if LiqFlowPriceClone >= .043 and LiqFlowPrice <= 2.40:
                    if range_ref_String == 'HIGH TARGET':
                        oppRangeStr = str(High_Range)
                        Program = 'TOUCH N GO (SELL %s)' % oppRangeStr
                elif LiqFlowPriceClone >= .04 and LiqFlowPrice <= 2.46:
                    if range_ref_String == 'LOW TARGET':
                        Program = 'AGGRESSIVE LOW TARGET'+' $ '+str(Low_Target)
                    if range_ref_String == 'HIGH TARGET':
                        Program = 'BULL TRAP RESISTANCE'+' $'+str(High_Target)



                if range_ref_String == 'LOW TARGET':
                    if MIV_Index >= Avg_MIV_Spike * 2.5:
                        Program = 'WALL OF CHINA OVERHEAD'

                    if LiqFlowPrice < .037:
                        Program = 'BOTTOM SIDE 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:
                                Program = 'MMs IN CONTROL (BULLISH)'
                        if MIV_Index >= Avg_MIV_Spike and LiqFlowPrice <= 2.7:
                            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,']')
                time.sleep(2.5)

            else:
                Range_Clause = 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)

        SignalList.append(Signal)
        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)+'%'


        print(DateStr, TimeStr,'  Current Liquidity:'+LiqStr,'  Liq Change:'+LiqChangeStr,'  Last Price:',Close_Price, SignalStr+Style.RESET_ALL+'         ['+PLString+Style.RESET_ALL+']')