Program „KRYPTO”

Program „KRYPTO”, to jeden z pierwszych moich programów napisanych w języku Python. Jego zadaniem jest wyświetlenie niewielkiego okna na pulpicie komputera z cenami kryptowalut.

Okno programu „KRYPTO” wyświetlane jest w lewym górnym rogu monitora o rozmiarach: 290X180 pixeli. Wyświetla ceny czterech kryptowalut (btc, eth, dash, ltc) pobieranych z giełdy Binance w interwale co 30 sekund. Ceny zmieniają kolory, w przypadku wzrostu kolor zielony, spadku kolor czerwony, bez zmian kolor biały.

Okno programu Krypto.py

Program jest w fazie rozwoju, w przyszłości przewiduje rozwój o kilka przydatnych opcji. W chwili obecnej program pracuje na platformie Linux. Testowany na Ubuntu 21 działa bez zarzutu. Program korzysta z bazy sqLite3. Wszystkie wyniki wyświetlane na ekranie zapisywane są do bazy. W przyszłości bazę będzie można wyczyścić oraz wyświetlić na ekranie wszystkie wyniki lub z poszczególnych miesięcy.

W planach jest dodanie menu w którym będzie można wybrać kilka opcji, między innymi graficzne wykresy pokazujące skoki cen krypto z podziałem na kryptowaluty i miesiące.

W najbliższym czasie program będzie dostępny również na system Windows. Aktualizacje programu przewidywane są co dwa tygodnie. Aktualną wersję będzie można pobrać ze strony GibHub.

Kod programu dla Python:

#!/usr/bin/env python3
# -*- coding: utf-8 -*-                      

"""
Created on Fri Aug 13 11:08:06 2021

@author: slavo
"""

import json
import requests
# import datetime as dt  # dla obsługi daty i czasu
import tkinter as tk
import sqlite3
from time import strftime


class Application:
    def __init__(self):
        self.window = tk.Tk()

# %% deklaracja zmiennych
        self.btcUsd = tk.StringVar()
        self.ethUsd = tk.StringVar()
        self.dashUsd = tk.StringVar()
        self.ltcUsd = tk.StringVar()
        self.btcSql = tk.StringVar()
        self.ethSql = tk.StringVar()
        self.dashSql = tk.StringVar()
        self.ltcSql = tk.StringVar()
        self.kolorBtcOdczyt = tk.StringVar()
        self.kolorEthOdczyt = tk.StringVar()
        self.kolorDashOdczyt = tk.StringVar()
        self.kolorLtcOdczyt = tk.StringVar()
        self.dataOdczyt = tk.StringVar()
        self.godzinaOdczyt = tk.StringVar()
        self.btcOdczyt = tk.StringVar()
        self.ethOdczyt = tk.StringVar()
        self.dashOdczyt = tk.StringVar()
        self.ltcOdczyt = tk.StringVar()
        self.kryptoKolorBtc = tk.StringVar()

        self.window.geometry("290x180+10+10")
        self.window.configure(background="black")
        self.window.title("Kryptowaluty - ceny USD")

        self.krojCzcionki = "Comic Sans"  # Times New Roman, Tahoma, Comic Sans
        self.rozmiarCzcionki = 15
        self.red = "red"
        self.green = "green"
        self.white = "white"
        self.black = "black"

        self.data = strftime("%d-%m-%Y")
        self.godzina = strftime("%H:%M:%S")


# %% linie tekstowe

        self.rama = tk.LabelFrame(self.window, padx=5, pady=5)
        self.rama.configure(background="black")
        self.rama.pack(fill="both", expand="yes")
        # ramka pierwsza
        self.r1 = tk.LabelFrame(self.rama, padx=5, pady=5)
        self.r1.configure(background="black")
        self.r1.pack(fill="both", expand="yes")
        # linia btc
        self.liniaBtc = tk.Label(self.r1, text="BTC:", font=(self.krojCzcionki, self.rozmiarCzcionki,
                                 "bold"), bg="black", fg="white").grid(row=0, column=0, sticky="w")
        self.liniaBtc0 = tk.Label(self.r1, textvariable=self.btcOdczyt, font=(
            self.krojCzcionki, self.rozmiarCzcionki), bg="black")
        self.liniaBtc0.grid(row=0, column=1, sticky="w")

        # linia eth
        self.liniaEth = tk.Label(self.r1, text="ETH:", font=(self.krojCzcionki, self.rozmiarCzcionki,
                                 "bold"), bg="black", fg="white").grid(row=1, column=0, sticky="w")
        self.liniaEth0 = tk.Label(self.r1, textvariable=self.ethOdczyt, font=(
            self.krojCzcionki, self.rozmiarCzcionki), bg="black")
        self.liniaEth0.grid(row=1, column=1, sticky="w")

        # linia dash
        self.liniaDash = tk.Label(self.r1, text="DASH:", font=(
            self.krojCzcionki, self.rozmiarCzcionki, "bold"), bg="black", fg="white").grid(row=2, column=0, sticky="w")
        self.liniaDash0 = tk.Label(self.r1, textvariable=self.dashOdczyt, font=(
            self.krojCzcionki, self.rozmiarCzcionki), bg="black")
        self.liniaDash0.grid(row=2, column=1, sticky="w")

        # linia ltc
        self.liniaLtc = tk.Label(self.r1, text="LTC:", font=(self.krojCzcionki, self.rozmiarCzcionki,
                                 "bold"), bg="black", fg="white").grid(row=3, column=0, sticky="w")
        self.liniaLtc0 = tk.Label(self.r1, textvariable=self.ltcOdczyt, font=(
            self.krojCzcionki, self.rozmiarCzcionki), bg="black")
        self.liniaLtc0.grid(row=3, column=1, sticky="w")
        # ramka druga
        self.r2 = tk.LabelFrame(self.rama, padx=5, pady=5)
        self.r2.configure(background="black")
        self.r2.pack(fill="both", expand="yes")
        # data aktualizacji
        self.aktualizacja = tk.Label(self.r2, text="aktualizacja: ", font=(
            "Arial", 8), bg="black", fg="white").grid(row=0, column=0)
        self.aktualizacjaData = tk.Label(self.r2, textvariable=self.dataOdczyt, font=(
            "Arial", 12), bg="black", fg="white").grid(row=0, column=1)
        self.aktualizacjaGodzina = tk.Label(self.r2, textvariable=self.godzinaOdczyt, font=(
            "Arial", 12), bg="black", fg="white").grid(row=0, column=2)

# %% wywołanie definicji
        self.baza_sql()
        self.binance_krypto()
        self.odczyt_sql()

        self.window.mainloop()


# %% utwórz bazę jeśli nie istnieje i zapisz pierwszy rekord


    def baza_sql(self):
        conn = sqlite3.connect('btc_eth.db')
        c = conn.cursor()
        c.execute(
            """CREATE TABLE IF NOT EXISTS binance(
            id INTEGER PRIMARY KEY AUTOINCREMENT,
            data_wpisu text NOT NULL,
            godzina text NOT NULL,
            cena_btc text NOT NULL,
            cena_eth text NOT NULL,
            cena_dash text NOT NULL,
            cena_litecoin text NOT NULL,
            kolor_btc text NOT NULL,
            kolor_eth text NOT NULL,
            kolor_dash text NOT NULL,
            kolor_ltc text NOT NULL);"""
        )
        conn.commit()
        conn.close()
        # spradzanie czy baza jest pusta
        conn = sqlite3.connect('btc_eth.db')
        c = conn.cursor()
        c.execute("Select count(id) From binance")
        self.wynik = c.fetchone()[0]
        c.close()

        # Jeśli rekord nie istnieje dodaj
        if self.wynik == 0:
            self.readBTC = requests.get("https://api.binance.com/api/v3/ticker/price?symbol=BTCUSDT")
            self.taskBTC = self.readBTC.json()
            self.btcUsd.set(self.taskBTC["price"])
            self.btc = float(self.btcUsd.get())

            self.readEth = requests.get("https://api.binance.com/api/v3/ticker/price?symbol=ETHUSDT")
            self.taskEth = self.readEth.json()
            self.ethUsd.set(self.taskEth["price"])
            self.eth = float(self.ethUsd.get())

            self.readDash = requests.get("https://api.binance.com/api/v3/ticker/price?symbol=DASHUSDT")
            self.taskDash = self.readDash.json()
            self.dashUsd.set(self.taskDash["price"])
            self.dash = float(self.dashUsd.get())

            self.readLtc = requests.get("https://api.binance.com/api/v3/ticker/price?symbol=LTCUSDT")
            self.taskLtc = self.readLtc.json()
            self.ltcUsd.set(self.taskLtc["price"])
            self.ltc = float(self.ltcUsd.get())

            conn = sqlite3.connect('btc_eth.db')
            c = conn.cursor()
            c.execute("INSERT INTO binance VALUES(NULL, :data_wpisu, :godzina, :cena_btc, :cena_eth, :cena_dash, :cena_litecoin, :kolor_btc, :kolor_eth, :kolor_dash, :kolor_ltc)",
                      {
                          'data_wpisu': strftime("%d-%m-%Y"),
                          'godzina': strftime("%H:%M:%S"),
                          'cena_btc': self.btc,
                          'cena_eth': self.eth,
                          'cena_dash': self.dash,
                          'cena_litecoin': self.ltc,
                          'kolor_btc': self.white,
                          'kolor_eth': self.white,
                          'kolor_dash': self.white,
                          'kolor_ltc': self.white
                      })
            conn.commit()
            conn.close()
        else:
            return print(self.wynik)


# %% Odczyt z api binance i zapis do bazy


    def binance_krypto(self):
        self.readBTC = requests.get("https://api.binance.com/api/v3/ticker/price?symbol=BTCUSDT")
        self.taskBTC = self.readBTC.json()
        self.btcUsd.set(self.taskBTC["price"])
        self.btc = float(self.btcUsd.get())

        self.readEth = requests.get("https://api.binance.com/api/v3/ticker/price?symbol=ETHUSDT")
        self.taskEth = self.readEth.json()
        self.ethUsd.set(self.taskEth["price"])
        self.eth = float(self.ethUsd.get())

        self.readDash = requests.get("https://api.binance.com/api/v3/ticker/price?symbol=DASHUSDT")
        self.taskDash = self.readDash.json()
        self.dashUsd.set(self.taskDash["price"])
        self.dash = float(self.dashUsd.get())

        self.readLtc = requests.get("https://api.binance.com/api/v3/ticker/price?symbol=LTCUSDT")
        self.taskLtc = self.readLtc.json()
        self.ltcUsd.set(self.taskLtc["price"])
        self.ltc = float(self.ltcUsd.get())
        # odczyt z bazy
        conn = sqlite3.connect('btc_eth.db')
        c = conn.cursor()
        c.execute("SELECT * FROM binance ORDER BY id DESC LIMIT 1")
        wynik = c.fetchall()
        for row in wynik:
            self.btcSql.set(row[3])
            self.ethSql.set(row[4])
            self.dashSql.set(row[5])
            self.ltcSql.set(row[6])
        c.close()
        self.btcPorownaj = float(self.btcSql.get())
        self.ethPorownaj = float(self.ethSql.get())
        self.dashPorownaj = float(self.dashSql.get())
        self.ltcPorownaj = float(self.ltcSql.get())
        # porownanie wyników
        if self.btc > self.btcPorownaj:
            self.kolor_btc = "green"
        elif self.btc < self.btcPorownaj:
            self.kolor_btc = "red"
        else:
            self.kolor_btc = "white"

        if self.eth > self.ethPorownaj:
            self.kolor_eth = "green"
        elif self.eth < self.ethPorownaj:
            self.kolor_eth = "red"
        else:
            self.kolor_eth = "white"

        if self.dash > self.dashPorownaj:
            self.kolor_dash = "green"
        elif self.dash < self.dashPorownaj:
            self.kolor_dash = "red"
        else:
            self.kolor_dash = "white"

        if self.ltc > self.ltcPorownaj:
            self.kolor_ltc = "green"
        elif self.ltc < self.ltcPorownaj:
            self.kolor_ltc = "red"
        else:
            self.kolor_ltc = "white"

        # zapis wyników do bazy sql
        conn = sqlite3.connect('btc_eth.db')
        c = conn.cursor()
        c.execute("INSERT INTO binance VALUES(NULL, :data_wpisu, :godzina, :cena_btc, :cena_eth, :cena_dash, :cena_litecoin, :kolor_btc, :kolor_eth, :kolor_dash, :kolor_ltc)",
                  {
                      'data_wpisu': strftime("%d-%m-%Y"),
                      'godzina': strftime("%H:%M:%S"),
                      'cena_btc': self.btc,
                      'cena_eth': self.eth,
                      'cena_dash': self.dash,
                      'cena_litecoin': self.ltc,
                      'kolor_btc': self.kolor_btc,
                      'kolor_eth': self.kolor_eth,
                      'kolor_dash': self.kolor_dash,
                      'kolor_ltc': self.kolor_ltc
                  })
        conn.commit()
        conn.close()

        self.window.after(30000, self.binance_krypto)

    def odczyt_sql(self):
        conn = sqlite3.connect('btc_eth.db')
        c = conn.cursor()
        c.execute("SELECT * FROM binance ORDER BY id DESC LIMIT 1")
        wynik = c.fetchall()
        for row in wynik:
            self.dataOdczyt.set(row[1])
            self.godzinaOdczyt.set(row[2])
            self.btcOdczyt.set(row[3])
            self.ethOdczyt.set(row[4])
            self.dashOdczyt.set(row[5])
            self.ltcOdczyt.set(row[6])
            self.liniaBtc0.configure(fg=row[7])
            self.liniaEth0.configure(foreground=row[8])
            self.liniaDash0.configure(foreground=row[9])
            self.liniaLtc0.configure(foreground=row[10])

        c.close()

        self.window.after(30000, self.odczyt_sql)


apl = Application()

Dodaj komentarz

Twój adres e-mail nie zostanie opublikowany. Wymagane pola są oznaczone *

Related Post