class SoundAlert:
def __init__(self):
self.logger = Logger().get_logger()
# TODO : sound sur windows avec winsound, sur linux... ?
def alert_buy(self):
# winsound.PlaySound('sounds/sound.wav', winsound.SND_FILENAME)
self.logger.info("ALERTE : BUY !")
def alert_sell(self):
# winsound.PlaySound('sounds/no.wav', winsound.SND_FILENAME)
self.logger.info("ALERTE : SELL !")
class MarketComparator:
def __init__(self):
self.logger = Logger().get_logger()
self.gdax = GdaxConnector()
self.kraken = KrakenConnector()
self.bithumb = BithumbConnector()
self.crypto_compare = CryptoCompareConnector()
def compare_bithumb_kraken(self, currency1, currency2):
"""
Compare la différence de prix entre bithumb et kraken
Retourne la différence entre les deux en %
:param currency1: devise à échanger
:param currency2: devise échangée
:return: le pourcentage (positif ou négatif) de différence
"""
price_bithumb = self.bithumb.get_best_bids_price(currency1, currency2)
price_kraken = self.kraken.get_best_bids_price(currency1, currency2)
if price_kraken is not None and price_bithumb is not None:
if price_bithumb > price_kraken:
return 100 - price_kraken / price_bithumb * 100
else:
return price_bithumb / price_kraken * 100 - 100
return 0
def compare_cryptocompare_kraken_in_euro(self, currency1):
# TODO : méthode générique de comparaison...
"""
Compare la différence de prix entre bithumb et kraken
Retourne la différence entre les deux en %
:param currency1: devise à échanger
:param currency2: devise échangée
:return: le pourcentage (positif ou négatif) de différence
"""
price_bithumb = self.bithumb.get_best_bids_price(currency1, "EUR")
price_crypto = self.crypto_compare.get_price_in_euro(currency1)
price_kraken = self.kraken.get_best_bids_price(currency1, "EUR")
if price_kraken is not None and price_crypto is not None and price_bithumb is not None:
price_average_markets = (price_bithumb + price_crypto) / 2
self.logger.info(
"Comparaison du prix kraken %s avec une moyenne de bithumb et cryptocompare %s",
price_kraken, price_average_markets)
if price_average_markets > price_kraken:
percentage = 100 - price_kraken / price_average_markets * 100
self.logger.info("%s %% de différence", percentage)
return percentage
else:
percentage = price_average_markets / price_kraken * 100 - 100
self.logger.info("%s %% de différence", percentage)
return percentage
return 0
class ComparatorSimulator:
THRESHOLD = 1
def __init__(self):
self.marketComparator = MarketComparator()
self.market = Market()
self.bithumb = BithumbConnector()
self.bithumb_coin_market = BithumbConnector2()
self.kraken = KrakenConnector()
self.crypto_compare = CryptoCompareConnector()
self.alert = SoundAlert()
self.logger = Logger().get_logger()
def simulate(self):
# On commence la simulation avec 1000 €
if not self.market.has_money_in_wallet():
self.market.add_euro_on_wallet(1000)
while True:
self.market.print_balance()
bithum_price = self.bithumb.get_best_bids_price("BCH", "EUR")
self.logger.info("bithumb : %s", bithum_price)
crypto_compare = self.crypto_compare.get_price_in_euro("BCH")
self.logger.info("crypto-compare : %s", crypto_compare)
kraken_price = self.kraken.get_best_bids_price("BCH", "EUR")
self.logger.info("kraken : %s", kraken_price)
comparaison_percentage = self.marketComparator.compare_cryptocompare_kraken_in_euro(
"BCH")
if comparaison_percentage > self.THRESHOLD and self.market.get_balance(
"EUR").amount > 0:
self.alert.alert_buy()
euro = Euro(kraken_price)
self.market.buy_all("BCH", euro)
elif comparaison_percentage < -self.THRESHOLD:
self.alert.alert_sell()
euro = Euro(kraken_price)
self.market.sell_all("BCH", euro)
time.sleep(5)
class Wallet:
def __init__(self, initial_eur_balance=0):
self.logger = Logger().get_logger()
self.storage = WalletStorage()
self._btc = Bitcoin(0)
self._bch = BitcoinCash(0)
self._eur = Euro(initial_eur_balance)
self._eth = Ethereum(0)
self._ltc = Litcoin(0)
# Construction d'une map pour gérer les monnaies plus facilement
self._moneys = {
self._btc.currency: self._btc,
self._bch.currency: self._bch,
self._eur.currency: self._eur,
self._eth.currency: self._eth,
self._ltc.currency: self._ltc
}
# Récupère toutes les monnaies de la BDD
self._retrieve_money_from_storage()
# Les enregistre pour sauvegarder les nouvelles qui ne sont pas encore présentes en BDD
self.storage.store_wallet(self)
def plus(self, money):
self.__operation_on_wallet(money)
def minus(self, money):
money.amount = -money.amount
self.__operation_on_wallet(money)
def get_balance(self, currency):
for money_in_wallet in self.get_money_list_in_wallet():
if currency == money_in_wallet.currency:
return copy.copy(money_in_wallet)
def has_enough_funds(self, money):
for money_in_wallet in self.get_money_list_in_wallet():
if money.currency == money_in_wallet.currency:
return money_in_wallet.amount >= money.amount or math.isclose(
money_in_wallet.amount, money.amount)
def get_money_list_in_wallet(self):
# TODO : utiliser la map "moneys" définie dans la classe
return [self._eur, self._btc, self._eth, self._ltc, self._bch]
def print_balance(self):
self.logger.info("==============")
for moneyInWallet in self.get_money_list_in_wallet():
self.logger.info(moneyInWallet)
self.logger.info("==============")
def has_moneys(self):
for money in self.get_money_list_in_wallet():
if money.amount > 0.1:
return True
return False
def __operation_on_wallet(self, money):
for money_in_wallet in self.get_money_list_in_wallet():
if money.currency == money_in_wallet.currency:
money_in_wallet.amount += money.amount
self.storage.store_money(money_in_wallet)
def _retrieve_money_from_storage(self):
for id, money in self._moneys.items():
stored_money = self.storage.get_money(money.currency)
if stored_money is not None:
#TODO: Comment faire ça proprement en python.... !?!
if stored_money.currency == "EUR":
self._eur = stored_money
if stored_money.currency == "BCH":
self._bch = stored_money
if stored_money.currency == "BTC":
self._btc = stored_money
if stored_money.currency == "ETH":
self._eth = stored_money
if stored_money.currency == "LTC":
self._ltc = stored_money
def main():
img_dir = r'/raid/lcq/dataset/crack/imgs'
label_dir = r'/raid/lcq/dataset/crack/labels'
save_path = './weights/result_without_pre.plt'
bach_size = 64
GPU_ID = 1
epoches = 400
lr = 0.001
lr_change = []
log_dir = './log'
logger = Logger(log_dir, '', 'crack')
logger.train()
if GPU_ID >= 0:
GPU = torch.device('cuda:{}'.format(GPU_ID))
else:
GPU = None
train_list, val_list, test_list = create_train_val_test_list(img_dir)
train_set = CrackDataSet(img_dir=img_dir,
imgs=train_list,
label_dir=label_dir)
train_data_loader = DataLoader(train_set, bach_size, shuffle=True)
len_train = len(train_set)
val_set = CrackDataSet(img_dir=img_dir, imgs=val_list, label_dir=label_dir)
val_data_loader = DataLoader(val_set, 32, False)
len_val = len(val_set)
model = Net(pretrained=True, num_classes=2)
opt = SGD(params=model.parameters(),
lr=lr,
momentum=0.9,
weight_decay=1e-5)
if GPU:
model = model.to(GPU)
criterion = nn.CrossEntropyLoss()
for epoch in range(epoches):
train_loss, train_acc, train_acc_cls, train_mean_iu, train_fwavacc, current_lr = train_one_epoch(
model,
train_data_loader,
criterion,
opt,
GPU,
epoch,
current_lr=lr,
lr_change=lr_change)
eval_loss, eval_acc, eval_acc_cls, eval_mean_iu, eval_fwavacc = val(
model, val_data_loader, criterion, GPU)
log = '[{}/{}] Train Loss:{:.5f},Train Acc:{:.5f},Train cls acc:{:.5f},Train Mean IU:{:.5f},Train fwavacc:{:.5f}'.format(
epoch, epoches, train_loss / len_train, train_acc / len_train,
eval_acc_cls / len_train, train_mean_iu / len_train,
train_fwavacc / len_train)
log2 = '[{}/{}] Val Loss:{:.5f},Val Acc:{:.5f},Val cls acc:{:.5f},Val mean iu:{:.5f},Val fwavacc:{:.5f}'.format(
epoch, epoches, eval_loss / len_val, eval_acc / len_val,
eval_acc_cls / len_val, eval_mean_iu / len_val,
eval_fwavacc / len_val)
logger.info(log)
logger.info(log2)
torch.save(model.state_dict(), save_path)
class Market:
def __init__(self):
self.logger = Logger().get_logger()
self.wallet = Wallet()
def add_euro_on_wallet(self, amount):
self.logger.info("[+] Ajout de %s euro dans le wallet", amount)
self.wallet.plus(Euro(amount))
def buy(self, money_amount, money_price):
"""
Achète money_amount au prix de money_price l'unité
:param money1: la Money à acheter
:param money2: prix de la Money avec laquelle faire l'échange
:return: void
"""
if money_amount.amount <= 0:
self.logger.error("Impossible d'acheter %s", money_amount)
return
if money_price.amount <= 0:
self.logger.error("Impossible d'acheter %s car le prix d'achat est trop faible", money_amount)
return
# Conversion
money_to_sell = ExchangeRateCalculator.convert(money_amount, money_price)
# Si le wallet a assez de fond pour acheter
if self.wallet.has_enough_funds(money_to_sell):
self.logger.info("J'achète %s au prix de %s l'unité", money_amount, money_price)
self.wallet.minus(money_to_sell)
self.wallet.plus(money_amount)
else:
self.logger.error("Impossible d'acheter %s. Seulement %s disponible dans le wallet.", money_amount,
self.wallet.get_balance(money_price.currency))
def buy_all(self, currency, money_price):
"""
Dépense toute la thune possible du wallet pour acheter la devise au prix indiqué
:param currency: devise à acheter
:param money_price: prix pour une unité
:return:
"""
total_money_in_wallet = self.get_balance(money_price.currency)
if total_money_in_wallet.amount > 0:
# TODO : Quelle est la bonne façon d'instancier un Money à partir de sa devise ???
money_to_buy = MoneyDeserializer.deserialize(currency)
money_to_buy.amount = total_money_in_wallet.amount / money_price.amount
self.buy(money_to_buy, money_price)
else:
self.logger.error("Fonds insufisant pour acheter.")
def sell(self, money_amount, money_price):
"""
Vend money_amount au prix de money_price l'unité
:param money1: la Money à vendre
:param money2: prix de la Money avec laquelle faire l'échange
:return: void
"""
if money_amount.amount <= 0:
self.logger.error("Impossible de vendre %s", money_amount)
return
if money_price.amount <= 0:
self.logger.error("Impossible de vendre %s car le prix d'achat est trop faible", money_amount)
return
# Si on a assez de fond de ce qu'on souhaite vendre dans le wallet
if self.wallet.has_enough_funds(money_amount):
self.logger.info("Je vends %s au prix de %s l'unité", money_amount, money_price)
# Conversion
money_to_buy = ExchangeRateCalculator.convert(money_amount, money_price)
self.wallet.minus(money_amount)
self.wallet.plus(money_to_buy)
else:
self.logger.error("Impossible de vendre %s . Seulement %s disponible dans le wallet.", money_amount,
self.wallet.get_balance(money_price.currency))
def sell_all(self, currency, money_price):
"""
Bazarde toutes les devises possibles du wallet pour vendre la devise au prix indiqué
:param currency: devise à vendre
:param money_price: prix pour une unité
:return:
"""
total_money_in_wallet = self.get_balance(currency)
if total_money_in_wallet.amount > 0:
self.sell(total_money_in_wallet, money_price)
else:
self.logger.warning("Rien à vendre.")
def print_balance(self):
self.wallet.print_balance()
def get_balance(self, currency):
return copy.copy(self.wallet.get_balance(currency))
def has_money_in_wallet(self):
return self.wallet.has_moneys()