_fields_ = [

("cb", ctypes.wintypes.DWORD),

("PageFaultCount", ctypes.wintypes.DWORD),

("PeakWorkingSetSize", ctypes.wintypes.ctypes.c_size_t),

("WorkingSetSize", ctypes.wintypes.ctypes.c_size_t),

("QuotaPeakPagedPoolUsage", ctypes.wintypes.ctypes.c_size_t),

("QuotaPagedPoolUsage", ctypes.wintypes.ctypes.c_size_t),

("QuotaPeakNonPagedPoolUsage", ctypes.wintypes.ctypes.c_size_t),

("QuotaNonPagedPoolUsage", ctypes.wintypes.ctypes.c_size_t),

("PagefileUsage", ctypes.wintypes.ctypes.c_size_t),

("PeakPagefileUsage", ctypes.wintypes.ctypes.c_size_t),

"""Get the memory usage of the current process (Windows)"""

ctypes.windll.psapi.GetProcessMemoryInfo(

process_handle, ctypes.byref(counters), ctypes.sizeof(counters)

)

# Return memory usage in bytes (WorkingSetSize = physical memory

# currently used by the process)

"""Get the memory usage of the current process (Unix)"""

usage = resource.getrusage(resource.RUSAGE_SELF)

if platform.system() == "Darwin":

return usage.ru_maxrss / 1048576 # Convert B to MB

else:

cpu_count = 1 # os.cpu_count()

start_time = 0

cpu_start = 0

cpu_usage = 0

memory_usage = 0

per_second = int(1000 / var.refresh_rate)

if Variables.usage_count >= per_second:

# Comes here 1 time every second

current_time = time.time()

current_cpu = os.times()

if Variables.start_time != 0:

# Calculate elapsed real and user times

elapsed_real_time = current_time - Variables.start_time

elapsed_user_time = current_cpu.user - Variables.cpu_start.user

elapsed_sys_time = current_cpu.system - Variables.cpu_start.system

# Calculate CPU usage percentage

Variables.cpu_usage = int(

round(

((elapsed_user_time + elapsed_sys_time) / elapsed_real_time)

* 100

/ Variables.cpu_count,

0,

)

)

# Calculate memory usage in MB

Variables.memory_usage = int(round(get_memory_usage(), 0))

# print(f"s={current_time}, f={time.time()}, e={time.time() - current_time}")

Variables.start_time = current_time

Variables.cpu_start = current_cpu

Variables.usage_count = 0

"""

Rounds the price depending on the tickSize value.

"""

arg = 1 / ticksize

res = round(price * arg, 0) / arg

"""

Rounds a number to the specified precision.

"""

if not isinstance(number, float):

return number

number = "{:.{precision}f}".format(number, precision=precision)

for num, char in enumerate(reversed(number)):

if char != "0":

break

number = number[: len(number) - num]

if number[-1] == ".":

number = number[:-1]

time: Union[int, float, str, datetime], usec=False

) -> Union[datetime, int]:

"""

The datetime always corresponds to utc time, the timestamp always

corresponds to local time.

int, float -> datetime (utc)

datetime utc -> Unix timestamp (local time)

str utc -> datetime (utc)

"""

if isinstance(time, int) or isinstance(time, float):

return datetime.fromtimestamp(time, tz=timezone.utc)

elif isinstance(time, datetime):

return int(time.timestamp() * 1000)

elif isinstance(time, str):

time = time.replace("T", " ")

time = time.replace("Z", "")

f = time.find("+")

if f > 0:

time = time[:f]

if usec:

try:

dt = datetime.strptime(time, "%Y-%m-%d %H:%M:%S.%f")

except Exception:

dt = datetime.strptime(time, "%Y-%m-%d %H:%M:%S")

else:

dt = datetime.strptime(time[:19], "%Y-%m-%d %H:%M:%S")

dt = dt.replace(tzinfo=timezone.utc)

return dt

else:

r = str(number)

if "e" in r:

r = r.replace("e", "")

r = r.replace(".", "")

r = r.split("-")

precision = len(r[0]) - 1 + int(r[1])

elif "." in r:

r = r.split(".")

if int(r[1]) == 0:

precision = 0

else:

precision = len(r[1])

else:

precision = 0

n = max(map(lambda x: len(x), line))

lst = list()

for l in line:

lst.append((n - len(l)) * " " + l)

for bot_name in var.bot_thread_active:

var.bot_thread_active[bot_name] = False

for name in var.market_list:

ws = markets[name]

formated = "".join(

traceback.format_exception(type(exception), exception, exception.__traceback__)

)

if display == True:

print(formated)

err_locked = 0

while True:

try:

var.sql_lock.acquire(True)

var.cursor_sqlite.execute(query)

orig = var.cursor_sqlite.fetchall()

var.sql_lock.release()

data = []

if orig:

data = list(map(lambda x: dict(zip(orig[0].keys(), x)), orig))

return data

except Exception as e: # var.error_sqlite

if "database is locked" not in str(e):

print("_____query:", query)

var.logger.error("Sqlite Error: " + str(e) + ")")

var.sql_lock.release()

break

else:

err_locked += 1

var.logger.error(

"Sqlite Error: Database is locked (attempt: "

+ str(err_locked)

+ ")"

)

err_locked = 0

while True:

try:

var.sql_lock.acquire(True)

if table == "coins":

var.cursor_sqlite.execute(

"insert into coins (EXECID,EMI,REFER,CURRENCY,SYMBOL,"

+ "TICKER,CATEGORY,MARKET,SIDE,QTY,QTY_REST,PRICE,"

+ "THEOR_PRICE,TRADE_PRICE,SUMREAL,COMMISS,CLORDID,TTIME,"

+ "ACCOUNT) VALUES (?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?)",

values,

)

elif table == "robots":

var.cursor_sqlite.execute(

"insert into robots (EMI,STATE,TIMEFR) VALUES (?,?,?)",

values,

)

elif table in ["obsolete", "backtest"]:

qwr = (

"""insert into %s (SYMBOL,MARKET,CATEGORY,CURRENCY,

TICKER,MYMULTIPLIER,MULTIPLIER,TICKSIZE,

PRICE_PRECISION,MINORDERQTY,QTYSTEP,PRECISION,EXPIRE,

BASECOIN,QUOTECOIN,VALUEOFONECONTRACT,TAKERFEE,MAKERFEE)

VALUES (?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?)"""

% table

)

var.cursor_sqlite.execute(qwr, values)

else:

return "Sqlite Error: Unknown database table."

var.connect_sqlite.commit()

var.sql_lock.release()

return None

except Exception as ex: # var.error_sqlite

if "database is locked" not in str(ex):

err_str = f"Sqlite Error: {str(ex)} for: {values[0]}"

var.logger.error(err_str)

var.sql_lock.release()

return err_str

else:

err_locked += 1

var.logger.error(

"Sqlite Error: Database is locked (attempt: "

+ str(err_locked)

+ ")"

)

var.connect_sqlite.rollback()

err_locked = 0

while True:

try:

var.sql_lock.acquire(True)

var.cursor_sqlite.execute(query)

var.connect_sqlite.commit()

var.sql_lock.release()

return None

except Exception as e: # var.error_sqlite

if "database is locked" not in str(e):

err_str = f"Sqlite Error: {str(e)}"

var.logger.error(err_str)

var.sql_lock.release()

return err_str

else:

err_locked += 1

var.logger.error(

"Sqlite Error: Database is locked (attempt: "

+ str(err_locked)

+ ")"

)

var.connect_sqlite.rollback()

var.last_order += 1

clOrdID = f"{var.last_order}.{emi}"

if emi not in var.orders:

var.orders[emi] = OrderedDict()

if clOrdID not in var.orders[emi]:

var.orders[emi][clOrdID] = dict()

var.orders[emi][clOrdID]["emi"] = emi

var.orders[emi][clOrdID]["leavesQty"] = value["leavesQty"]

var.orders[emi][clOrdID]["transactTime"] = value["transactTime"]

var.orders[emi][clOrdID]["price"] = value["price"]

var.orders[emi][clOrdID]["symbol"] = value["symbol"]

var.orders[emi][clOrdID]["category"] = category

var.orders[emi][clOrdID]["market"] = value["symbol"][1]

var.orders[emi][clOrdID]["side"] = value["side"]

var.orders[emi][clOrdID]["orderID"] = value["orderID"]

var.orders[emi][clOrdID]["clOrdID"] = clOrdID

bot_name: str, symbol: tuple, instrument: Instrument, user_id: int

) -> None:

bot = Bots[bot_name]

bot.bot_positions[symbol] = {

"emi": bot_name,

"symbol": instrument.symbol,

"category": instrument.category,

"market": instrument.market,

"ticker": instrument.ticker,

"position": 0,

"volume": 0,

"sumreal": 0,

"commiss": 0,

"ltime": None,

"pnl": 0,

"lotSize": instrument.minOrderQty,

"currency": instrument.settlCurrency[0],

"limits": instrument.minOrderQty,

"max_position": 0,

}

# Checks if this bot has any records in the database on this instrument.

if not var.backtest:

qwr = (

"select MARKET, SYMBOL, sum(abs(QTY)) as SUM_QTY, "

+ "sum(SUMREAL) as SUM_SUMREAL, sum(COMMISS) as "

+ "SUM_COMMISS, TTIME from (select * from coins where EMI = '"

+ bot_name

+ "' and SYMBOL = '"

+ instrument.symbol

+ "' and MARKET = '"

+ instrument.market

+ "' and ACCOUNT = "

+ str(user_id)

+ " and SIDE <> 'Fund' order by ID desc) T;"

)

data = select_database(qwr)[0]

if data and data["SUM_QTY"]:

bot.bot_positions[symbol]["volume"] = float(data["SUM_QTY"])

bot.bot_positions[symbol]["sumreal"] = float(data["SUM_SUMREAL"])

"""

Converts a time interval in a string to seconds.

"""

timefr_minutes = var.timeframe_human_format[timefr]

if not bot.error_message:

error = "-"

else:

error = bot.error_message["error_type"]

"""

Updates the high and low values of kline data when websocket updates the

order book.

Parameters

----------

ws: Markets

Bitmex, Bybit, Deribit

symbol: tuple

Instrument symbol in (symbol, market name) format, e.g.

("BTCUSD", "Bybit").

instrument: Instrument

The Instrument instance for this symbol.

"""

if symbol in ws.klines:

ask = instrument.asks[0][0]

bid = instrument.bids[0][0]

for timefr, values in ws.klines[symbol].items():

if values["data"]:

if ask > values["data"][-1]["hi"]:

values["data"][-1]["hi"] = ask

if bid < values["data"][-1]["lo"]:

values["data"][-1]["lo"] = bid

if symbol in BreakDown.symbols:

if timefr in BreakDown.symbols[symbol]:

for parameters in BreakDown.symbols[symbol][timefr].values():

#print(Bots[parameters["bot_name"]].multitrade)

direct = parameters["first"] * (parameters["number"] % 2 * 2 - 1)

if direct >= 0 and ask > parameters["up"]:

parameters["number"] += 1

if parameters["first"] == 0:

parameters["first"] = -1

if direct <= 0 and bid < parameters["dn"]:

parameters["number"] += 1

if parameters["first"] == 0:

"""Temporarily created function for debugging"""

count = 0

for values in var.orders.values():

for _ in values.keys():

count += 1

r = ""

for _ in range(length - len(val)):

r = r + "0"

"""

Formats the message in the required format.

"""

if market:

market += ": "

if not tm:

tm = datetime.now(tz=timezone.utc)

text = (

noll(str(tm.hour), 2)

+ ":"

+ noll(str(tm.minute), 2)

+ ":"

+ noll(str(tm.second), 2)

+ "."

+ noll(str(int(tm.microsecond / 1000)), 3)

+ " "

+ market

+ message

+ "\n"

)

if isinstance(text, tuple):

text = text[0]

"""

Removes an exchange from the boot process if an error like "Host name is

invalid" occurs.

"""

if market in var.market_list:

"""

Checks if the symbols in the symbol_list of a given market are valid for

further websocket subscription. Removes misspelled or expired symbols

from the symbol_list. If symbol_list is empty after removal, adds a

default symbol.

Parameters

----------

symbols: list

List of symbols of all available active instruments, which is

received from the exchange.

market: str

Exchange name.

symbol_list: list

Symbols for subscription.

Returns

-------

list

Corrected symbol_list.

"""

def put_default(symbol_list: list):

if not symbol_list:

default = var.default_symbol[market]

symbol_list = var.default_symbol[market]

message = Message.DEFAULT_SYMBOL_ADDED.format(

SYMBOL=default[0], MARKET=market

)

var.queue_info.put(

{

"market": market,

"message": message,

"time": datetime.now(tz=timezone.utc),

"warning": "warning",

}

)

var.logger.info(message)

return symbol_list

if symbols:

for symbol in symbol_list.copy():

if symbol not in symbols:

message = ErrorMessage.UNKNOWN_SYMBOL.format(

SYMBOL=symbol[0], MARKET=market

)

var.queue_info.put(

{

"market": market,

"message": message,

"time": datetime.now(tz=timezone.utc),

"warning": "error",

}

)

var.logger.error(message)

symbol_list.remove(symbol)

symbol_list = put_default(symbol_list=symbol_list)

else:

symbol_list = put_default(symbol_list=symbol_list)

"""

if the http request produces an error, or if it is correct but the data

received does not match the expected data, and this error is assumed to

be FATAL.

"""

if not ws.logNumFatal:

ws.logNumFatal = "FATAL"

"""

Adds an instrument to the instrument_index dictionary.

Parameters

----------

index: dict

The instrument_index is used for the Instrument Menu. It ranks

instruments by category, currency.

instrument: Instrument

An Instrument instance, which belongs to a particular exchange.

ws: Markets

Bitmex, Bybit or Deribit object.

Returns

-------

dict

The instrument_index dictionary.

"""

category = instrument.category

if "spot" in category:

currency = instrument.baseCoin

else:

currency = instrument.settlCurrency[0]

if category not in index:

index[category] = OrderedDict()

if currency not in index[category]:

index[category][currency] = OrderedDict()

symb = instrument.symbol

if "option" in category and "combo" not in category:

parts = symb.split("-")

option_series = "-".join(parts[:2]) + var._series

if option_series not in index[category][currency]:

index[category][currency][option_series] = OrderedDict()

index[category][currency][option_series]["CALLS"] = list()

index[category][currency][option_series]["PUTS"] = list()

index[category][currency][option_series]["sort"] = option_series

if parts[-1] == "C":

index[category][currency][option_series]["CALLS"].append(symb)

else:

index[category][currency][option_series]["PUTS"].append(symb)

# Add a series of options.

symbol = (option_series, instrument.market)

series: Instrument = ws.Instrument.add(symbol)

series.market = instrument.market

series.symbol = option_series

series.ticker = "option!"

series.category = instrument.category

series.settlCurrency = instrument.settlCurrency

series.quoteCoin = instrument.quoteCoin

series.currentQty = "-"

series.avgEntryPrice = "-"

series.unrealisedPnl = "-"

series.marginCallPrice = "-"

series.state = instrument.state

series.volume24h = "-"

series.expire = instrument.expire

series.fundingRate = "-"

series.baseCoin = instrument.baseCoin

series.precision = instrument.precision

series.asks = [["-", "-"]]

series.bids = [["-", "-"]]

series.price_precision = 1

series.isInverse = instrument.isInverse

else:

if symb not in index[category][currency]:

index[category][currency][symb] = {"sort": symb}

"""

Updates dotenv file.

"""

set_key(

dotenv_path=dotenv_path,

key_to_set=key,

value_to_set=value,

"""

Categories and currencies are sorted by name, instruments by the `sort`

parameter, options are additionally sorted by ascending strike price.

"""

res = OrderedDict(sorted(index.items(), key=lambda x: x[0]))

for category, values_category in index.items():

res[category] = OrderedDict(sorted(values_category.items(), key=lambda x: x[0]))

for currency, values_currency in res[category].items():

res[category][currency] = OrderedDict(

sorted(values_currency.items(), key=lambda x: x[1]["sort"])

)

for series, values in res[category][currency].items():

for key, value in values.items():

if key in ["CALLS", "PUTS"]:

try:

value.sort(

key=lambda x: float(x.split("-")[-2].replace("d", "."))

)

except Exception:

try:

value.sort(

key=lambda x: float(x.split("-")[-1].split("_")[0])

)

except Exception:

value.sort()

res[category][currency][series][key] = value

"""

Extracts all strikes from a series of options.

"""

series = index[instrument.category][instrument.settlCurrency[0]][instrument.symbol]

"""

Load the last remembered params to be used for the terminal appearance

"""

if not os.path.isfile(var.preferences):

set_dotenv(

dotenv_path=var.preferences,

key="ROOT_WIDTH",

value=str(width),

)

set_dotenv(

dotenv_path=var.preferences,

key="ROOT_HEIGHT",

value=str(height),

)

set_dotenv(

dotenv_path=var.preferences,

key="ROOT_X_POS",

value=str(root.winfo_x()),

)

set_dotenv(

dotenv_path=var.preferences,

key="ROOT_Y_POS",

value=str(root.winfo_y()),

)

if len(var.symbol[0]) > 22:

return var.symbol[0][:22] + "\n" + var.symbol[0][22:]

else:

values = [

instrument.symbol,

instrument.market,

instrument.category,

instrument.settlCurrency[0],

instrument.ticker,

instrument.myMultiplier,

instrument.multiplier,

instrument.tickSize,

instrument.price_precision,

instrument.minOrderQty,

instrument.qtyStep,

instrument.precision,

instrument.expire,

instrument.baseCoin,

instrument.quoteCoin,

instrument.valueOfOneContract,

instrument.takerFee,

instrument.makerFee,

]

res = insert_database(values=values, table=table)

instrument.symbol = data["SYMBOL"]

instrument.market = data["MARKET"]

instrument.category = data["CATEGORY"]

instrument.settlCurrency = (data["CURRENCY"], data["MARKET"])

instrument.ticker = data["TICKER"]

instrument.myMultiplier = data["MYMULTIPLIER"]

instrument.multiplier = data["MULTIPLIER"]

instrument.tickSize = data["TICKSIZE"]

instrument.price_precision = data["PRICE_PRECISION"]

instrument.minOrderQty = data["MINORDERQTY"]

instrument.qtyStep = data["QTYSTEP"]

instrument.precision = data["PRECISION"]

if data["EXPIRE"] == "Perpetual":

instrument.expire = data["EXPIRE"]

else:

instrument.expire = time_converter(time=data["EXPIRE"])

instrument.baseCoin = data["BASECOIN"]

instrument.quoteCoin = data["QUOTECOIN"]

instrument.valueOfOneContract = data["VALUEOFONECONTRACT"]

instrument.takerFee = data["TAKERFEE"]

instrument.makerFee = data["MAKERFEE"]

symbols = ""

for symbol in var.backtest_symbols:

symbols += "\n " + str(symbol)

text = (

"Backtesting\n\nBot parameters:\n- name: "

+ bot.name

+ "\n- timeframe: "

+ bot.timefr

+ "\n- used instruments: "

+ symbols

)

bot: BotData,

symbol: tuple,

instrument: Instrument,

user_id: int,

qty: float,

calc: dict,

ttime: Union[datetime, str],

):

if symbol not in bot.bot_positions:

fill_bot_position(

bot_name=bot.name,

symbol=symbol,

instrument=instrument,

user_id=user_id,

)

position = bot.bot_positions[symbol]

if "spot" not in instrument.category:

position["position"] += qty

position["position"] = round(

position["position"],

instrument.precision,

)

position["volume"] += abs(qty)

position["commiss"] += calc["commiss"]

position["sumreal"] += calc["sumreal"]

position["ltime"] = ttime

if abs(position["position"]) > position["max_position"]: