Ejemplo n.º 1
0
 def test_dict_keys(self):
     self.assertEqual(
         min([{
             'name': 'Nina',
             'age': 27,
             'country': 'Czech Republic'
         }, {
             'name': 'Anna',
             'age': 25,
             'country': 'Japan'
         }, {
             'name': 'Alisa',
             'age': 25,
             'country': 'Kanada'
         }, {
             'name': 'Mila',
             'age': 26,
             'country': 'USA'
         }],
             key=lambda x: x['age']), {
                 'name': 'Anna',
                 'age': 25,
                 'country': 'Japan'
             })
Ejemplo n.º 2
0
 def test_digit(self):
     self.assertEqual(min(3, 4, 1, 9, 6, 0), 0)
Ejemplo n.º 3
0
 def test_empty_iter(self):
     self.assertRaises(ValueError, min([]))
Ejemplo n.º 4
0
 def test_strs_len(self):
     self.assertEqual(min('lliu', ' lliu', 'dmvfkvm', 'qwes', key=len),
                      'lliu')
Ejemplo n.º 5
0
 def test_letters(self):
     self.assertEqual(min('d', 'i', 'f', 'j', 'c', 'a', 'w', 'b'), 'a')
Ejemplo n.º 6
0
 def test_str(self):
     self.assertEqual(min('qwertyuipb'), 'b')
Ejemplo n.º 7
0
 def test_list_el(self):
     self.assertEqual(
         min([[3, 415], [1, 2, 9], [
             -6,
             0,
         ]], key=lambda x: x[1]), [-6, 0])
Ejemplo n.º 8
0
 def test_list_len(self):
     self.assertEqual(min([[3, 415], [1, 2, 9], []], key=len), [])
Ejemplo n.º 9
0
 def test_list(self):
     self.assertEqual(min([3, 415, 1, 2, 9, -6, 0]), -6)
Ejemplo n.º 10
0
    def update_label(self):
        texto = ''
        if self.count < 10000:
            gananciaTR = 0
            ganancia = 0
            #############################
            #############################
            #############################
            #Aqui solo pon tu funcion de ganancia y perdida

            klines = client.get_klines(symbol=symbolTicker,
                                       interval=Client.KLINE_INTERVAL_1MINUTE)
            klines_h = client.get_klines(
                symbol=symbolTicker, interval=Client.KLINE_INTERVAL_1MINUTE)

            min = func.min(klines)
            max = func.max(klines)

            media_min = func.media_min_klines(klines_h)
            media_max = func.media_max_klines(klines_h)

            # Encontrar el valor de la moneda
            if (self.precioCompra == 0):
                list_of_tickers = client.get_all_tickers()
                for tick_2 in list_of_tickers:
                    if tick_2["symbol"] == symbolTicker:
                        self.precioCompra = float(tick_2["price"])

            if ((self.precioCompra >= max * .991)
                    and ((self.precioCompra >=
                          ((media_max + max) / 2) * .991))):
                ws.MessageBeep(type=1)

                list_of_tickers = client.get_all_tickers()
                for tick_2 in list_of_tickers:
                    if tick_2["symbol"] == symbolTicker:
                        precioActual = float(tick_2["price"])

                self.lblPerdidaDinero.configure(text=round(precioActual, 3))

                comisionCompra = (inversion * porcentaje_comision)
                comisionVenta = (inversion +
                                 ((precioActual - self.precioCompra) /
                                  precioActual)) * porcentaje_comision

                gananciaTR = ((precioActual - self.precioCompra) *
                              (inversion / self.precioCompra) -
                              comisionCompra - comisionVenta)

                if (((comisionCompra + comisionVenta) <
                     ((precioActual - self.precioCompra) *
                      (inversion / self.precioCompra)))
                        or (gananciaTR <= (-inversion * .02))):
                    ws.MessageBeep(type=1)

                    ganancia += (precioActual - self.precioCompra) * (
                        inversion /
                        self.precioCompra) - comisionCompra - comisionVenta

                    texto = ('Se vendió a: ', precioActual, ' ganó: ',
                             gananciaTR)
                    self.precioCompra = 0

            self.lblGanaciasDinero.configure(text=gananciaTR)
            self.lblGanaciasDinero.after(2500, self.update_label)

            klines = client.get_klines(symbol=symbolTicker,
                                       interval=Client.KLINE_INTERVAL_1MINUTE)
            precio = [
                float(klines[len(klines) - 1][2]),
                float(klines[len(klines) - 2][2]),
                float(klines[len(klines) - 3][2]),
                float(klines[len(klines) - 4][2]),
                float(klines[len(klines) - 5][2]),
                float(klines[len(klines) - 6][2]),
                float(klines[len(klines) - 7][2]),
                float(klines[len(klines) - 8][2]),
                float(klines[len(klines) - 9][2]),
                float(klines[len(klines) - 10][2])
            ]
            tiempo = [10, 9, 8, 7, 6, 5, 4, 3, 2, 1]

            plt.clf()
            plt.plot(tiempo, precio)
            plt.title('Precio Vs tiempo')
            plt.xlabel('Tiempo')
            plt.ylabel('Precio')
            plt.savefig('grafica.png')

            self.img2 = Image.open("grafica.png")
            self.img2 = self.img2.resize((470, 275))
            self.tkimage = ImageTk.PhotoImage(self.img2)
            self.lblImg.configure(image=self.tkimage)

            #############################
            #############################
            #############################
            #Aqui pasele el string del detalle de las operaciones

            self.lblOperacionUno.configure(
                text='Se vendió a 270.898, ganó: 0.277806790')
            #self.lblOperacionUno.after(5000, self.update_label)
            self.lblOperacionDos.configure(text=texto)
            #self.lblOperacionDos.after(1000, self.update_label)

            self.lblOperacionTres.configure(text='------------------')
            #self.lblOperacionTres.after(1000, self.update_label)

            self.lblOperacionCuatro.configure(text='------------------')
            #self.lblOperacionCuatro.after(1000, self.update_label)

            self.count += 1
Ejemplo n.º 11
0
    def run(self):
        client = Client(config.API_KEY, config.SECRET, tld='com')
        symbolTicker = 'BNBUSDT'
        precioCompra = 0
        quantityOrders = 0
        compra = False
        ganancia = 0
        inversion = 1000
        porcentaje_comision = .00075

        while 1:

            time.sleep(1)

            klines = client.get_klines(symbol=symbolTicker,
                                       interval=Client.KLINE_INTERVAL_1MINUTE)
            klines_h = client.get_klines(
                symbol=symbolTicker, interval=Client.KLINE_INTERVAL_1MINUTE)

            min = func.min(klines)
            max = func.max(klines)

            media_min = func.media_min_klines(klines_h)
            media_max = func.media_max_klines(klines_h)

            precio = [
                float(klines[len(klines) - 1][2]),
                float(klines[len(klines) - 2][2]),
                float(klines[len(klines) - 3][2]),
                float(klines[len(klines) - 4][2]),
                float(klines[len(klines) - 5][2]),
                float(klines[len(klines) - 6][2]),
                float(klines[len(klines) - 7][2]),
                float(klines[len(klines) - 8][2]),
                float(klines[len(klines) - 9][2]),
                float(klines[len(klines) - 10][2])
            ]
            tiempo = [10, 9, 8, 7, 6, 5, 4, 3, 2, 1]

            plt.plot(tiempo, precio)
            plt.title('Precio Vs tiempo')
            plt.xlabel('Tiempo')
            plt.ylabel('Precio')

            # Encontrar el valor de la moneda
            list_of_tickers = client.get_all_tickers()
            for tick_2 in list_of_tickers:
                if tick_2["symbol"] == symbolTicker:
                    precioCompra = float(tick_2["price"])

            if ((precioCompra >= max * .991)
                    and ((precioCompra >= ((media_max + max) / 2) * .991))):
                '(precioCompra <= ((media_min+min)/2)*1.007) or '
                'or ((precioCompra <= (float(klines[len(klines)-1][3]))) + (float(klines[len(klines)-1][3])*.01)'
                ws.MessageBeep(type=1)
                print("*** Compra inicial ***")
                print("Se compro a: ", precioCompra)
                # order = client.order_market_buy(
                #    symbol = symbolTicker,
                #   quantity = quantityOrders
                # )
                break
            else:
                print("\nPrecio actual", precioCompra)
                print("\nPrecio máximo de 1hr min", max)
                print("\nPrecio mínimo de 1hr min", min)
                print("\nMedia de precio máximo de 30 mins", media_max)
                print("\nMedia de precio mínimo de 30 mins", media_min)
                print("\nEsa wea max", ((media_max + max) / 2) * .993)
                print("\nEsa wea min", ((media_min + min) / 2) * 1.007)
                print("\nbuscando precio..")

        while 1:
            time.sleep(1)
            # Encontrar el valor de la moneda
            list_of_tickers = client.get_all_tickers()
            for tick_2 in list_of_tickers:
                if tick_2["symbol"] == symbolTicker:
                    precioActual = float(tick_2["price"])

            klines = client.get_klines(symbol=symbolTicker,
                                       interval=Client.KLINE_INTERVAL_5MINUTE)

            comisionCompra = (inversion * porcentaje_comision)
            comisionVenta = (inversion + ((precioActual - precioCompra) /
                                          precioActual)) * porcentaje_comision

            print("***********")
            print("Se desea comprar a: ",
                  (precioCompra + comisionCompra + comisionVenta))

            gananciaTR = ((precioActual - precioCompra) *
                          (inversion / precioCompra) - comisionCompra -
                          comisionVenta)

            print("Ganancia tiempo real:", gananciaTR)

            if (((comisionCompra + comisionVenta) <
                 ((precioActual - precioCompra) * (inversion / precioCompra)))
                    or (gananciaTR <= (-inversion * .02))):
                print("Se vendio a: ", precioActual)
                ws.MessageBeep(type=1)

                texto = ("Se vendió a: ", precioActual, " ganó: ", ganancia)

                ganancia += (precioActual - precioCompra) * (
                    inversion / precioCompra) - comisionCompra - comisionVenta
                # order = client.order_market_sell(
                #    symbol = symbolTicker,
                #    quantity = 0.00022
                # )
                compra = True
                precioCompra = precioActual

                time.sleep(2)

                while 1:
                    klines = client.get_klines(
                        symbol=symbolTicker,
                        interval=Client.KLINE_INTERVAL_1MINUTE)

                    klines_h = client.get_klines(
                        symbol=symbolTicker,
                        interval=Client.KLINE_INTERVAL_1MINUTE)

                    min = func.min(klines)
                    max = func.max(klines)

                    media_min = func.media_min_klines(klines_h)
                    media_max = func.media_max_klines(klines_h)

                    list_of_tickers = client.get_all_tickers()
                    for tick_2 in list_of_tickers:
                        if tick_2["symbol"] == symbolTicker:
                            precioCompra = float(tick_2["price"])

                    print("\nPrecio actual", precioCompra)
                    print("\nPrecio máximo de 1hr min", max)
                    print("\nPrecio mínimo de 1hr min", min)
                    print("\nMedia de precio máximo de 1 hr", media_max)
                    print("\nMedia de precio mínimo de 1 hr", media_min)
                    print("\nEsa wea max", ((media_max + max) / 2) * .993)
                    print("\nEsa wea min", ((media_min + min) / 2) * 1.007)
                    print("\nbuscando precio..")

                    if ((precioCompra >= max * .991)
                            and ((precioCompra >=
                                  ((media_max + max) / 2) * .991))):
                        print("Se compra a: ", precioCompra)
                        ws.MessageBeep(type=1)
                        # order = client.order_market_buy(
                        #symbol = symbolTicker,
                        #quantity = quantityOrders
                        # )

                        break

                    time.sleep(1)

            else:
                print("El precio es menor, paso")
                print("El precio al que se compro es: ", precioCompra)
                print("La suma de comisiones es: ",
                      (comisionCompra + comisionVenta))
                print("El precio es de: ", precioActual)
                print("Ganancia: ", ganancia)