From 5dbcd6abb6246cd06bde785615076d5fd7ad315b Mon Sep 17 00:00:00 2001 From: Matheus Tura Date: Fri, 13 Jan 2023 17:55:42 -0300 Subject: [PATCH] Add docstring, Change mercado_bitcoin precision format --- symbols/binance.py | 23537 +++++++++++++++++++++++++++++++---- symbols/bitfinex.py | 4958 +++++++- symbols/coinbase.py | 6344 +++++++++- symbols/mercado_bitcoin.py | 5120 +++++--- 4 files changed, 35221 insertions(+), 4738 deletions(-) diff --git a/symbols/binance.py b/symbols/binance.py index 57eb8c8..8a996b2 100644 --- a/symbols/binance.py +++ b/symbols/binance.py @@ -1,8 +1,22 @@ from dataclasses import dataclass + + +ONEINCHBTC = ONEINCHBTC() + + @dataclass(slots=True, frozen=True) class ONEINCHBTC: + """ + name: 1INCHBTC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 90000000.00000000 + margin: True + """ name: str = "1INCHBTC" precision: int = 8 minimum_margin: float = None @@ -21,11 +35,20 @@ def __call__(self): return "1INCHBTC" -ONEINCHBTC = ONEINCHBTC() +ONEINCHBUSD = ONEINCHBUSD() @dataclass(slots=True, frozen=True) class ONEINCHBUSD: + """ + name: 1INCHBUSD + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 900000.00000000 + margin: False + """ name: str = "1INCHBUSD" precision: int = 8 minimum_margin: float = None @@ -44,11 +67,20 @@ def __call__(self): return "1INCHBUSD" -ONEINCHBUSD = ONEINCHBUSD() +ONEINCHDOWNUSDT = ONEINCHDOWNUSDT() @dataclass(slots=True, frozen=True) class ONEINCHDOWNUSDT: + """ + name: 1INCHDOWNUSDT + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 2999958.00000000 + margin: False + """ name: str = "1INCHDOWNUSDT" precision: int = 8 minimum_margin: float = None @@ -67,11 +99,20 @@ def __call__(self): return "1INCHDOWNUSDT" -ONEINCHDOWNUSDT = ONEINCHDOWNUSDT() +ONEINCHUPUSDT = ONEINCHUPUSDT() @dataclass(slots=True, frozen=True) class ONEINCHUPUSDT: + """ + name: 1INCHUPUSDT + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 300000.00000000 + margin: False + """ name: str = "1INCHUPUSDT" precision: int = 8 minimum_margin: float = None @@ -90,11 +131,20 @@ def __call__(self): return "1INCHUPUSDT" -ONEINCHUPUSDT = ONEINCHUPUSDT() +ONEINCHUSDT = ONEINCHUSDT() @dataclass(slots=True, frozen=True) class ONEINCHUSDT: + """ + name: 1INCHUSDT + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 900000.00000000 + margin: True + """ name: str = "1INCHUSDT" precision: int = 8 minimum_margin: float = None @@ -113,11 +163,20 @@ def __call__(self): return "1INCHUSDT" -ONEINCHUSDT = ONEINCHUSDT() +AAVEBKRW = AAVEBKRW() @dataclass(slots=True, frozen=True) class AAVEBKRW: + """ + name: AAVEBKRW + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.00100000 + maximum_order_size: 9000.00000000 + margin: False + """ name: str = "AAVEBKRW" precision: int = 8 minimum_margin: float = None @@ -136,11 +195,20 @@ def __call__(self): return "AAVEBKRW" -AAVEBKRW = AAVEBKRW() +AAVEBNB = AAVEBNB() @dataclass(slots=True, frozen=True) class AAVEBNB: + """ + name: AAVEBNB + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.00100000 + maximum_order_size: 900000.00000000 + margin: False + """ name: str = "AAVEBNB" precision: int = 8 minimum_margin: float = None @@ -159,11 +227,20 @@ def __call__(self): return "AAVEBNB" -AAVEBNB = AAVEBNB() +AAVEBRL = AAVEBRL() @dataclass(slots=True, frozen=True) class AAVEBRL: + """ + name: AAVEBRL + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.00100000 + maximum_order_size: 92233.00000000 + margin: False + """ name: str = "AAVEBRL" precision: int = 8 minimum_margin: float = None @@ -182,11 +259,20 @@ def __call__(self): return "AAVEBRL" -AAVEBRL = AAVEBRL() +AAVEBTC = AAVEBTC() @dataclass(slots=True, frozen=True) class AAVEBTC: + """ + name: AAVEBTC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.00100000 + maximum_order_size: 92141578.00000000 + margin: True + """ name: str = "AAVEBTC" precision: int = 8 minimum_margin: float = None @@ -205,11 +291,20 @@ def __call__(self): return "AAVEBTC" -AAVEBTC = AAVEBTC() +AAVEBUSD = AAVEBUSD() @dataclass(slots=True, frozen=True) class AAVEBUSD: + """ + name: AAVEBUSD + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.00100000 + maximum_order_size: 900000.00000000 + margin: True + """ name: str = "AAVEBUSD" precision: int = 8 minimum_margin: float = None @@ -228,11 +323,20 @@ def __call__(self): return "AAVEBUSD" -AAVEBUSD = AAVEBUSD() +AAVEDOWNUSDT = AAVEDOWNUSDT() @dataclass(slots=True, frozen=True) class AAVEDOWNUSDT: + """ + name: AAVEDOWNUSDT + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 100000000.00000000 + margin: False + """ name: str = "AAVEDOWNUSDT" precision: int = 8 minimum_margin: float = None @@ -251,11 +355,20 @@ def __call__(self): return "AAVEDOWNUSDT" -AAVEDOWNUSDT = AAVEDOWNUSDT() +AAVEETH = AAVEETH() @dataclass(slots=True, frozen=True) class AAVEETH: + """ + name: AAVEETH + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.00100000 + maximum_order_size: 9000000.00000000 + margin: False + """ name: str = "AAVEETH" precision: int = 8 minimum_margin: float = None @@ -274,11 +387,20 @@ def __call__(self): return "AAVEETH" -AAVEETH = AAVEETH() +AAVEUPUSDT = AAVEUPUSDT() @dataclass(slots=True, frozen=True) class AAVEUPUSDT: + """ + name: AAVEUPUSDT + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 920000.00000000 + margin: False + """ name: str = "AAVEUPUSDT" precision: int = 8 minimum_margin: float = None @@ -297,11 +419,20 @@ def __call__(self): return "AAVEUPUSDT" -AAVEUPUSDT = AAVEUPUSDT() +AAVEUSDT = AAVEUSDT() @dataclass(slots=True, frozen=True) class AAVEUSDT: + """ + name: AAVEUSDT + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.00100000 + maximum_order_size: 900000.00000000 + margin: True + """ name: str = "AAVEUSDT" precision: int = 8 minimum_margin: float = None @@ -320,11 +451,20 @@ def __call__(self): return "AAVEUSDT" -AAVEUSDT = AAVEUSDT() +ACABTC = ACABTC() @dataclass(slots=True, frozen=True) class ACABTC: + """ + name: ACABTC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 92141578.00000000 + margin: False + """ name: str = "ACABTC" precision: int = 8 minimum_margin: float = None @@ -343,11 +483,20 @@ def __call__(self): return "ACABTC" -ACABTC = ACABTC() +ACABUSD = ACABUSD() @dataclass(slots=True, frozen=True) class ACABUSD: + """ + name: ACABUSD + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 92141578.00000000 + margin: False + """ name: str = "ACABUSD" precision: int = 8 minimum_margin: float = None @@ -366,11 +515,20 @@ def __call__(self): return "ACABUSD" -ACABUSD = ACABUSD() +ACAUSDT = ACAUSDT() @dataclass(slots=True, frozen=True) class ACAUSDT: + """ + name: ACAUSDT + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 92141578.00000000 + margin: False + """ name: str = "ACAUSDT" precision: int = 8 minimum_margin: float = None @@ -389,11 +547,20 @@ def __call__(self): return "ACAUSDT" -ACAUSDT = ACAUSDT() +ACHBTC = ACHBTC() @dataclass(slots=True, frozen=True) class ACHBTC: + """ + name: ACHBTC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 92141578.00000000 + margin: False + """ name: str = "ACHBTC" precision: int = 8 minimum_margin: float = None @@ -412,11 +579,20 @@ def __call__(self): return "ACHBTC" -ACHBTC = ACHBTC() +ACHBUSD = ACHBUSD() @dataclass(slots=True, frozen=True) class ACHBUSD: + """ + name: ACHBUSD + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 92141578.00000000 + margin: True + """ name: str = "ACHBUSD" precision: int = 8 minimum_margin: float = None @@ -435,11 +611,20 @@ def __call__(self): return "ACHBUSD" -ACHBUSD = ACHBUSD() +ACHUSDT = ACHUSDT() @dataclass(slots=True, frozen=True) class ACHUSDT: + """ + name: ACHUSDT + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 92141578.00000000 + margin: True + """ name: str = "ACHUSDT" precision: int = 8 minimum_margin: float = None @@ -458,11 +643,20 @@ def __call__(self): return "ACHUSDT" -ACHUSDT = ACHUSDT() +ACMBTC = ACMBTC() @dataclass(slots=True, frozen=True) class ACMBTC: + """ + name: ACMBTC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 90000000.00000000 + margin: False + """ name: str = "ACMBTC" precision: int = 8 minimum_margin: float = None @@ -481,11 +675,20 @@ def __call__(self): return "ACMBTC" -ACMBTC = ACMBTC() +ACMBUSD = ACMBUSD() @dataclass(slots=True, frozen=True) class ACMBUSD: + """ + name: ACMBUSD + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 90000.00000000 + margin: False + """ name: str = "ACMBUSD" precision: int = 8 minimum_margin: float = None @@ -504,11 +707,20 @@ def __call__(self): return "ACMBUSD" -ACMBUSD = ACMBUSD() +ACMUSDT = ACMUSDT() @dataclass(slots=True, frozen=True) class ACMUSDT: + """ + name: ACMUSDT + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 90000.00000000 + margin: False + """ name: str = "ACMUSDT" precision: int = 8 minimum_margin: float = None @@ -527,11 +739,20 @@ def __call__(self): return "ACMUSDT" -ACMUSDT = ACMUSDT() +ADAAUD = ADAAUD() @dataclass(slots=True, frozen=True) class ADAAUD: + """ + name: ADAAUD + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 9222449.00000000 + margin: False + """ name: str = "ADAAUD" precision: int = 8 minimum_margin: float = None @@ -550,11 +771,20 @@ def __call__(self): return "ADAAUD" -ADAAUD = ADAAUD() +ADABIDR = ADABIDR() @dataclass(slots=True, frozen=True) class ADABIDR: + """ + name: ADABIDR + precision: 2 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 184467.00000000 + margin: False + """ name: str = "ADABIDR" precision: int = 2 minimum_margin: float = None @@ -573,11 +803,20 @@ def __call__(self): return "ADABIDR" -ADABIDR = ADABIDR() +ADABKRW = ADABKRW() @dataclass(slots=True, frozen=True) class ADABKRW: + """ + name: ADABKRW + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 922327.00000000 + margin: False + """ name: str = "ADABKRW" precision: int = 8 minimum_margin: float = None @@ -596,11 +835,20 @@ def __call__(self): return "ADABKRW" -ADABKRW = ADABKRW() +ADABNB = ADABNB() @dataclass(slots=True, frozen=True) class ADABNB: + """ + name: ADABNB + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 9000000.00000000 + margin: False + """ name: str = "ADABNB" precision: int = 8 minimum_margin: float = None @@ -619,11 +867,20 @@ def __call__(self): return "ADABNB" -ADABNB = ADABNB() +ADABRL = ADABRL() @dataclass(slots=True, frozen=True) class ADABRL: + """ + name: ADABRL + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 9222449.00000000 + margin: False + """ name: str = "ADABRL" precision: int = 8 minimum_margin: float = None @@ -642,11 +899,20 @@ def __call__(self): return "ADABRL" -ADABRL = ADABRL() +ADABTC = ADABTC() @dataclass(slots=True, frozen=True) class ADABTC: + """ + name: ADABTC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 90000000.00000000 + margin: True + """ name: str = "ADABTC" precision: int = 8 minimum_margin: float = None @@ -665,11 +931,20 @@ def __call__(self): return "ADABTC" -ADABTC = ADABTC() +ADABUSD = ADABUSD() @dataclass(slots=True, frozen=True) class ADABUSD: + """ + name: ADABUSD + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 900000.00000000 + margin: True + """ name: str = "ADABUSD" precision: int = 8 minimum_margin: float = None @@ -688,11 +963,20 @@ def __call__(self): return "ADABUSD" -ADABUSD = ADABUSD() +ADADOWNUSDT = ADADOWNUSDT() @dataclass(slots=True, frozen=True) class ADADOWNUSDT: + """ + name: ADADOWNUSDT + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 100000000.00000000 + margin: False + """ name: str = "ADADOWNUSDT" precision: int = 8 minimum_margin: float = None @@ -711,11 +995,20 @@ def __call__(self): return "ADADOWNUSDT" -ADADOWNUSDT = ADADOWNUSDT() +ADAETH = ADAETH() @dataclass(slots=True, frozen=True) class ADAETH: + """ + name: ADAETH + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 90000000.00000000 + margin: True + """ name: str = "ADAETH" precision: int = 8 minimum_margin: float = None @@ -734,11 +1027,20 @@ def __call__(self): return "ADAETH" -ADAETH = ADAETH() +ADAEUR = ADAEUR() @dataclass(slots=True, frozen=True) class ADAEUR: + """ + name: ADAEUR + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 900000.00000000 + margin: False + """ name: str = "ADAEUR" precision: int = 8 minimum_margin: float = None @@ -757,11 +1059,20 @@ def __call__(self): return "ADAEUR" -ADAEUR = ADAEUR() +ADAGBP = ADAGBP() @dataclass(slots=True, frozen=True) class ADAGBP: + """ + name: ADAGBP + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 900000.00000000 + margin: False + """ name: str = "ADAGBP" precision: int = 8 minimum_margin: float = None @@ -780,11 +1091,20 @@ def __call__(self): return "ADAGBP" -ADAGBP = ADAGBP() +ADAPAX = ADAPAX() @dataclass(slots=True, frozen=True) class ADAPAX: + """ + name: ADAPAX + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 9000000.00000000 + margin: False + """ name: str = "ADAPAX" precision: int = 8 minimum_margin: float = None @@ -803,11 +1123,20 @@ def __call__(self): return "ADAPAX" -ADAPAX = ADAPAX() +ADARUB = ADARUB() @dataclass(slots=True, frozen=True) class ADARUB: + """ + name: ADARUB + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 922327.00000000 + margin: False + """ name: str = "ADARUB" precision: int = 8 minimum_margin: float = None @@ -826,11 +1155,20 @@ def __call__(self): return "ADARUB" -ADARUB = ADARUB() +ADATRY = ADATRY() @dataclass(slots=True, frozen=True) class ADATRY: + """ + name: ADATRY + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 9222449.00000000 + margin: False + """ name: str = "ADATRY" precision: int = 8 minimum_margin: float = None @@ -849,11 +1187,20 @@ def __call__(self): return "ADATRY" -ADATRY = ADATRY() +ADATUSD = ADATUSD() @dataclass(slots=True, frozen=True) class ADATUSD: + """ + name: ADATUSD + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 900000.00000000 + margin: False + """ name: str = "ADATUSD" precision: int = 8 minimum_margin: float = None @@ -872,11 +1219,20 @@ def __call__(self): return "ADATUSD" -ADATUSD = ADATUSD() +ADAUPUSDT = ADAUPUSDT() @dataclass(slots=True, frozen=True) class ADAUPUSDT: + """ + name: ADAUPUSDT + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 920000.00000000 + margin: False + """ name: str = "ADAUPUSDT" precision: int = 8 minimum_margin: float = None @@ -895,11 +1251,20 @@ def __call__(self): return "ADAUPUSDT" -ADAUPUSDT = ADAUPUSDT() +ADAUSDC = ADAUSDC() @dataclass(slots=True, frozen=True) class ADAUSDC: + """ + name: ADAUSDC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 900000.00000000 + margin: False + """ name: str = "ADAUSDC" precision: int = 8 minimum_margin: float = None @@ -918,11 +1283,20 @@ def __call__(self): return "ADAUSDC" -ADAUSDC = ADAUSDC() +ADAUSDT = ADAUSDT() @dataclass(slots=True, frozen=True) class ADAUSDT: + """ + name: ADAUSDT + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 900000.00000000 + margin: True + """ name: str = "ADAUSDT" precision: int = 8 minimum_margin: float = None @@ -941,11 +1315,20 @@ def __call__(self): return "ADAUSDT" -ADAUSDT = ADAUSDT() +ADXBNB = ADXBNB() @dataclass(slots=True, frozen=True) class ADXBNB: + """ + name: ADXBNB + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 9000000.00000000 + margin: False + """ name: str = "ADXBNB" precision: int = 8 minimum_margin: float = None @@ -964,11 +1347,20 @@ def __call__(self): return "ADXBNB" -ADXBNB = ADXBNB() +ADXBTC = ADXBTC() @dataclass(slots=True, frozen=True) class ADXBTC: + """ + name: ADXBTC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 90000000.00000000 + margin: False + """ name: str = "ADXBTC" precision: int = 8 minimum_margin: float = None @@ -987,11 +1379,20 @@ def __call__(self): return "ADXBTC" -ADXBTC = ADXBTC() +ADXBUSD = ADXBUSD() @dataclass(slots=True, frozen=True) class ADXBUSD: + """ + name: ADXBUSD + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 92141578.00000000 + margin: False + """ name: str = "ADXBUSD" precision: int = 8 minimum_margin: float = None @@ -1010,11 +1411,20 @@ def __call__(self): return "ADXBUSD" -ADXBUSD = ADXBUSD() +ADXETH = ADXETH() @dataclass(slots=True, frozen=True) class ADXETH: + """ + name: ADXETH + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 90000000.00000000 + margin: False + """ name: str = "ADXETH" precision: int = 8 minimum_margin: float = None @@ -1033,11 +1443,20 @@ def __call__(self): return "ADXETH" -ADXETH = ADXETH() +ADXUSDT = ADXUSDT() @dataclass(slots=True, frozen=True) class ADXUSDT: + """ + name: ADXUSDT + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 92141578.00000000 + margin: False + """ name: str = "ADXUSDT" precision: int = 8 minimum_margin: float = None @@ -1056,11 +1475,20 @@ def __call__(self): return "ADXUSDT" -ADXUSDT = ADXUSDT() +AEBNB = AEBNB() @dataclass(slots=True, frozen=True) class AEBNB: + """ + name: AEBNB + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 9000000.00000000 + margin: False + """ name: str = "AEBNB" precision: int = 8 minimum_margin: float = None @@ -1079,11 +1507,20 @@ def __call__(self): return "AEBNB" -AEBNB = AEBNB() +AEBTC = AEBTC() @dataclass(slots=True, frozen=True) class AEBTC: + """ + name: AEBTC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 90000000.00000000 + margin: False + """ name: str = "AEBTC" precision: int = 8 minimum_margin: float = None @@ -1102,11 +1539,20 @@ def __call__(self): return "AEBTC" -AEBTC = AEBTC() +AEETH = AEETH() @dataclass(slots=True, frozen=True) class AEETH: + """ + name: AEETH + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 90000000.00000000 + margin: False + """ name: str = "AEETH" precision: int = 8 minimum_margin: float = None @@ -1125,11 +1571,20 @@ def __call__(self): return "AEETH" -AEETH = AEETH() +AERGOBTC = AERGOBTC() @dataclass(slots=True, frozen=True) class AERGOBTC: + """ + name: AERGOBTC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 90000000.00000000 + margin: False + """ name: str = "AERGOBTC" precision: int = 8 minimum_margin: float = None @@ -1148,11 +1603,20 @@ def __call__(self): return "AERGOBTC" -AERGOBTC = AERGOBTC() +AERGOBUSD = AERGOBUSD() @dataclass(slots=True, frozen=True) class AERGOBUSD: + """ + name: AERGOBUSD + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 9000000.00000000 + margin: False + """ name: str = "AERGOBUSD" precision: int = 8 minimum_margin: float = None @@ -1171,11 +1635,20 @@ def __call__(self): return "AERGOBUSD" -AERGOBUSD = AERGOBUSD() +AGIBNB = AGIBNB() @dataclass(slots=True, frozen=True) class AGIBNB: + """ + name: AGIBNB + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 9000000.00000000 + margin: False + """ name: str = "AGIBNB" precision: int = 8 minimum_margin: float = None @@ -1194,11 +1667,20 @@ def __call__(self): return "AGIBNB" -AGIBNB = AGIBNB() +AGIBTC = AGIBTC() @dataclass(slots=True, frozen=True) class AGIBTC: + """ + name: AGIBTC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 90000000.00000000 + margin: False + """ name: str = "AGIBTC" precision: int = 8 minimum_margin: float = None @@ -1217,11 +1699,20 @@ def __call__(self): return "AGIBTC" -AGIBTC = AGIBTC() +AGIETH = AGIETH() @dataclass(slots=True, frozen=True) class AGIETH: + """ + name: AGIETH + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 90000000.00000000 + margin: False + """ name: str = "AGIETH" precision: int = 8 minimum_margin: float = None @@ -1240,11 +1731,20 @@ def __call__(self): return "AGIETH" -AGIETH = AGIETH() +AGIXBTC = AGIXBTC() @dataclass(slots=True, frozen=True) class AGIXBTC: + """ + name: AGIXBTC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 92141578.00000000 + margin: False + """ name: str = "AGIXBTC" precision: int = 8 minimum_margin: float = None @@ -1263,11 +1763,20 @@ def __call__(self): return "AGIXBTC" -AGIXBTC = AGIXBTC() +AGIXBUSD = AGIXBUSD() @dataclass(slots=True, frozen=True) class AGIXBUSD: + """ + name: AGIXBUSD + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 92141578.00000000 + margin: False + """ name: str = "AGIXBUSD" precision: int = 8 minimum_margin: float = None @@ -1286,11 +1795,20 @@ def __call__(self): return "AGIXBUSD" -AGIXBUSD = AGIXBUSD() +AGLDBNB = AGLDBNB() @dataclass(slots=True, frozen=True) class AGLDBNB: + """ + name: AGLDBNB + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 92141578.00000000 + margin: False + """ name: str = "AGLDBNB" precision: int = 8 minimum_margin: float = None @@ -1309,11 +1827,20 @@ def __call__(self): return "AGLDBNB" -AGLDBNB = AGLDBNB() +AGLDBTC = AGLDBTC() @dataclass(slots=True, frozen=True) class AGLDBTC: + """ + name: AGLDBTC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 92141578.00000000 + margin: True + """ name: str = "AGLDBTC" precision: int = 8 minimum_margin: float = None @@ -1332,11 +1859,20 @@ def __call__(self): return "AGLDBTC" -AGLDBTC = AGLDBTC() +AGLDBUSD = AGLDBUSD() @dataclass(slots=True, frozen=True) class AGLDBUSD: + """ + name: AGLDBUSD + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 92141578.00000000 + margin: True + """ name: str = "AGLDBUSD" precision: int = 8 minimum_margin: float = None @@ -1355,11 +1891,20 @@ def __call__(self): return "AGLDBUSD" -AGLDBUSD = AGLDBUSD() +AGLDUSDT = AGLDUSDT() @dataclass(slots=True, frozen=True) class AGLDUSDT: + """ + name: AGLDUSDT + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 92141578.00000000 + margin: True + """ name: str = "AGLDUSDT" precision: int = 8 minimum_margin: float = None @@ -1378,11 +1923,20 @@ def __call__(self): return "AGLDUSDT" -AGLDUSDT = AGLDUSDT() +AIONBNB = AIONBNB() @dataclass(slots=True, frozen=True) class AIONBNB: + """ + name: AIONBNB + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 9000000.00000000 + margin: False + """ name: str = "AIONBNB" precision: int = 8 minimum_margin: float = None @@ -1401,11 +1955,20 @@ def __call__(self): return "AIONBNB" -AIONBNB = AIONBNB() +AIONBTC = AIONBTC() @dataclass(slots=True, frozen=True) class AIONBTC: + """ + name: AIONBTC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 90000000.00000000 + margin: False + """ name: str = "AIONBTC" precision: int = 8 minimum_margin: float = None @@ -1424,11 +1987,20 @@ def __call__(self): return "AIONBTC" -AIONBTC = AIONBTC() +AIONBUSD = AIONBUSD() @dataclass(slots=True, frozen=True) class AIONBUSD: + """ + name: AIONBUSD + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 900000.00000000 + margin: False + """ name: str = "AIONBUSD" precision: int = 8 minimum_margin: float = None @@ -1447,11 +2019,20 @@ def __call__(self): return "AIONBUSD" -AIONBUSD = AIONBUSD() +AIONETH = AIONETH() @dataclass(slots=True, frozen=True) class AIONETH: + """ + name: AIONETH + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 92141578.00000000 + margin: False + """ name: str = "AIONETH" precision: int = 8 minimum_margin: float = None @@ -1470,11 +2051,20 @@ def __call__(self): return "AIONETH" -AIONETH = AIONETH() +AIONUSDT = AIONUSDT() @dataclass(slots=True, frozen=True) class AIONUSDT: + """ + name: AIONUSDT + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 9222449.00000000 + margin: False + """ name: str = "AIONUSDT" precision: int = 8 minimum_margin: float = None @@ -1493,11 +2083,20 @@ def __call__(self): return "AIONUSDT" -AIONUSDT = AIONUSDT() +AKROBTC = AKROBTC() @dataclass(slots=True, frozen=True) class AKROBTC: + """ + name: AKROBTC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 90000000.00000000 + margin: False + """ name: str = "AKROBTC" precision: int = 8 minimum_margin: float = None @@ -1516,11 +2115,20 @@ def __call__(self): return "AKROBTC" -AKROBTC = AKROBTC() +AKROBUSD = AKROBUSD() @dataclass(slots=True, frozen=True) class AKROBUSD: + """ + name: AKROBUSD + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 9000000.00000000 + margin: False + """ name: str = "AKROBUSD" precision: int = 8 minimum_margin: float = None @@ -1539,11 +2147,20 @@ def __call__(self): return "AKROBUSD" -AKROBUSD = AKROBUSD() +AKROUSDT = AKROUSDT() @dataclass(slots=True, frozen=True) class AKROUSDT: + """ + name: AKROUSDT + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 9000000.00000000 + margin: True + """ name: str = "AKROUSDT" precision: int = 8 minimum_margin: float = None @@ -1562,11 +2179,20 @@ def __call__(self): return "AKROUSDT" -AKROUSDT = AKROUSDT() +ALCXBTC = ALCXBTC() @dataclass(slots=True, frozen=True) class ALCXBTC: + """ + name: ALCXBTC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.00010000 + maximum_order_size: 92141578.00000000 + margin: False + """ name: str = "ALCXBTC" precision: int = 8 minimum_margin: float = None @@ -1585,11 +2211,20 @@ def __call__(self): return "ALCXBTC" -ALCXBTC = ALCXBTC() +ALCXBUSD = ALCXBUSD() @dataclass(slots=True, frozen=True) class ALCXBUSD: + """ + name: ALCXBUSD + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.00010000 + maximum_order_size: 92233.00000000 + margin: False + """ name: str = "ALCXBUSD" precision: int = 8 minimum_margin: float = None @@ -1608,11 +2243,20 @@ def __call__(self): return "ALCXBUSD" -ALCXBUSD = ALCXBUSD() +ALCXUSDT = ALCXUSDT() @dataclass(slots=True, frozen=True) class ALCXUSDT: + """ + name: ALCXUSDT + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.00010000 + maximum_order_size: 92233.00000000 + margin: False + """ name: str = "ALCXUSDT" precision: int = 8 minimum_margin: float = None @@ -1631,11 +2275,20 @@ def __call__(self): return "ALCXUSDT" -ALCXUSDT = ALCXUSDT() +ALGOBIDR = ALGOBIDR() @dataclass(slots=True, frozen=True) class ALGOBIDR: + """ + name: ALGOBIDR + precision: 2 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 9223371114.00000000 + margin: False + """ name: str = "ALGOBIDR" precision: int = 2 minimum_margin: float = None @@ -1654,11 +2307,20 @@ def __call__(self): return "ALGOBIDR" -ALGOBIDR = ALGOBIDR() +ALGOBNB = ALGOBNB() @dataclass(slots=True, frozen=True) class ALGOBNB: + """ + name: ALGOBNB + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 9000000.00000000 + margin: False + """ name: str = "ALGOBNB" precision: int = 8 minimum_margin: float = None @@ -1677,11 +2339,20 @@ def __call__(self): return "ALGOBNB" -ALGOBNB = ALGOBNB() +ALGOBTC = ALGOBTC() @dataclass(slots=True, frozen=True) class ALGOBTC: + """ + name: ALGOBTC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 90000000.00000000 + margin: True + """ name: str = "ALGOBTC" precision: int = 8 minimum_margin: float = None @@ -1700,11 +2371,20 @@ def __call__(self): return "ALGOBTC" -ALGOBTC = ALGOBTC() +ALGOBUSD = ALGOBUSD() @dataclass(slots=True, frozen=True) class ALGOBUSD: + """ + name: ALGOBUSD + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 900000.00000000 + margin: True + """ name: str = "ALGOBUSD" precision: int = 8 minimum_margin: float = None @@ -1723,11 +2403,20 @@ def __call__(self): return "ALGOBUSD" -ALGOBUSD = ALGOBUSD() +ALGOETH = ALGOETH() @dataclass(slots=True, frozen=True) class ALGOETH: + """ + name: ALGOETH + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 92141578.00000000 + margin: False + """ name: str = "ALGOETH" precision: int = 8 minimum_margin: float = None @@ -1746,11 +2435,20 @@ def __call__(self): return "ALGOETH" -ALGOETH = ALGOETH() +ALGOPAX = ALGOPAX() @dataclass(slots=True, frozen=True) class ALGOPAX: + """ + name: ALGOPAX + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 900000.00000000 + margin: False + """ name: str = "ALGOPAX" precision: int = 8 minimum_margin: float = None @@ -1769,11 +2467,20 @@ def __call__(self): return "ALGOPAX" -ALGOPAX = ALGOPAX() +ALGORUB = ALGORUB() @dataclass(slots=True, frozen=True) class ALGORUB: + """ + name: ALGORUB + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 922327.00000000 + margin: False + """ name: str = "ALGORUB" precision: int = 8 minimum_margin: float = None @@ -1792,11 +2499,20 @@ def __call__(self): return "ALGORUB" -ALGORUB = ALGORUB() +ALGOTRY = ALGOTRY() @dataclass(slots=True, frozen=True) class ALGOTRY: + """ + name: ALGOTRY + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 92141578.00000000 + margin: False + """ name: str = "ALGOTRY" precision: int = 8 minimum_margin: float = None @@ -1815,11 +2531,20 @@ def __call__(self): return "ALGOTRY" -ALGOTRY = ALGOTRY() +ALGOTUSD = ALGOTUSD() @dataclass(slots=True, frozen=True) class ALGOTUSD: + """ + name: ALGOTUSD + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 900000.00000000 + margin: False + """ name: str = "ALGOTUSD" precision: int = 8 minimum_margin: float = None @@ -1838,11 +2563,20 @@ def __call__(self): return "ALGOTUSD" -ALGOTUSD = ALGOTUSD() +ALGOUSDC = ALGOUSDC() @dataclass(slots=True, frozen=True) class ALGOUSDC: + """ + name: ALGOUSDC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 900000.00000000 + margin: False + """ name: str = "ALGOUSDC" precision: int = 8 minimum_margin: float = None @@ -1861,11 +2595,20 @@ def __call__(self): return "ALGOUSDC" -ALGOUSDC = ALGOUSDC() +ALGOUSDT = ALGOUSDT() @dataclass(slots=True, frozen=True) class ALGOUSDT: + """ + name: ALGOUSDT + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 922327.00000000 + margin: True + """ name: str = "ALGOUSDT" precision: int = 8 minimum_margin: float = None @@ -1884,11 +2627,20 @@ def __call__(self): return "ALGOUSDT" -ALGOUSDT = ALGOUSDT() +ALICEBIDR = ALICEBIDR() @dataclass(slots=True, frozen=True) class ALICEBIDR: + """ + name: ALICEBIDR + precision: 2 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 922337194.00000000 + margin: False + """ name: str = "ALICEBIDR" precision: int = 2 minimum_margin: float = None @@ -1907,11 +2659,20 @@ def __call__(self): return "ALICEBIDR" -ALICEBIDR = ALICEBIDR() +ALICEBNB = ALICEBNB() @dataclass(slots=True, frozen=True) class ALICEBNB: + """ + name: ALICEBNB + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.00100000 + maximum_order_size: 92141578.00000000 + margin: False + """ name: str = "ALICEBNB" precision: int = 8 minimum_margin: float = None @@ -1930,11 +2691,20 @@ def __call__(self): return "ALICEBNB" -ALICEBNB = ALICEBNB() +ALICEBTC = ALICEBTC() @dataclass(slots=True, frozen=True) class ALICEBTC: + """ + name: ALICEBTC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 90000000.00000000 + margin: True + """ name: str = "ALICEBTC" precision: int = 8 minimum_margin: float = None @@ -1953,11 +2723,20 @@ def __call__(self): return "ALICEBTC" -ALICEBTC = ALICEBTC() +ALICEBUSD = ALICEBUSD() @dataclass(slots=True, frozen=True) class ALICEBUSD: + """ + name: ALICEBUSD + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 900000.00000000 + margin: True + """ name: str = "ALICEBUSD" precision: int = 8 minimum_margin: float = None @@ -1976,11 +2755,20 @@ def __call__(self): return "ALICEBUSD" -ALICEBUSD = ALICEBUSD() +ALICETRY = ALICETRY() @dataclass(slots=True, frozen=True) class ALICETRY: + """ + name: ALICETRY + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.00100000 + maximum_order_size: 922327.00000000 + margin: False + """ name: str = "ALICETRY" precision: int = 8 minimum_margin: float = None @@ -1999,11 +2787,20 @@ def __call__(self): return "ALICETRY" -ALICETRY = ALICETRY() +ALICEUSDT = ALICEUSDT() @dataclass(slots=True, frozen=True) class ALICEUSDT: + """ + name: ALICEUSDT + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 900000.00000000 + margin: True + """ name: str = "ALICEUSDT" precision: int = 8 minimum_margin: float = None @@ -2022,11 +2819,20 @@ def __call__(self): return "ALICEUSDT" -ALICEUSDT = ALICEUSDT() +ALPACABNB = ALPACABNB() @dataclass(slots=True, frozen=True) class ALPACABNB: + """ + name: ALPACABNB + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 92141578.00000000 + margin: False + """ name: str = "ALPACABNB" precision: int = 8 minimum_margin: float = None @@ -2045,11 +2851,20 @@ def __call__(self): return "ALPACABNB" -ALPACABNB = ALPACABNB() +ALPACABTC = ALPACABTC() @dataclass(slots=True, frozen=True) class ALPACABTC: + """ + name: ALPACABTC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 92141578.00000000 + margin: False + """ name: str = "ALPACABTC" precision: int = 8 minimum_margin: float = None @@ -2068,11 +2883,20 @@ def __call__(self): return "ALPACABTC" -ALPACABTC = ALPACABTC() +ALPACABUSD = ALPACABUSD() @dataclass(slots=True, frozen=True) class ALPACABUSD: + """ + name: ALPACABUSD + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 92141578.00000000 + margin: False + """ name: str = "ALPACABUSD" precision: int = 8 minimum_margin: float = None @@ -2091,11 +2915,20 @@ def __call__(self): return "ALPACABUSD" -ALPACABUSD = ALPACABUSD() +ALPACAUSDT = ALPACAUSDT() @dataclass(slots=True, frozen=True) class ALPACAUSDT: + """ + name: ALPACAUSDT + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 92141578.00000000 + margin: False + """ name: str = "ALPACAUSDT" precision: int = 8 minimum_margin: float = None @@ -2114,11 +2947,20 @@ def __call__(self): return "ALPACAUSDT" -ALPACAUSDT = ALPACAUSDT() +ALPHABNB = ALPHABNB() @dataclass(slots=True, frozen=True) class ALPHABNB: + """ + name: ALPHABNB + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 9000000.00000000 + margin: False + """ name: str = "ALPHABNB" precision: int = 8 minimum_margin: float = None @@ -2137,11 +2979,20 @@ def __call__(self): return "ALPHABNB" -ALPHABNB = ALPHABNB() +ALPHABTC = ALPHABTC() @dataclass(slots=True, frozen=True) class ALPHABTC: + """ + name: ALPHABTC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 90000000.00000000 + margin: True + """ name: str = "ALPHABTC" precision: int = 8 minimum_margin: float = None @@ -2160,11 +3011,20 @@ def __call__(self): return "ALPHABTC" -ALPHABTC = ALPHABTC() +ALPHABUSD = ALPHABUSD() @dataclass(slots=True, frozen=True) class ALPHABUSD: + """ + name: ALPHABUSD + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 900000.00000000 + margin: False + """ name: str = "ALPHABUSD" precision: int = 8 minimum_margin: float = None @@ -2183,11 +3043,20 @@ def __call__(self): return "ALPHABUSD" -ALPHABUSD = ALPHABUSD() +ALPHAUSDT = ALPHAUSDT() @dataclass(slots=True, frozen=True) class ALPHAUSDT: + """ + name: ALPHAUSDT + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 900000.00000000 + margin: True + """ name: str = "ALPHAUSDT" precision: int = 8 minimum_margin: float = None @@ -2206,11 +3075,20 @@ def __call__(self): return "ALPHAUSDT" -ALPHAUSDT = ALPHAUSDT() +ALPINEBTC = ALPINEBTC() @dataclass(slots=True, frozen=True) class ALPINEBTC: + """ + name: ALPINEBTC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 92141578.00000000 + margin: False + """ name: str = "ALPINEBTC" precision: int = 8 minimum_margin: float = None @@ -2229,11 +3107,20 @@ def __call__(self): return "ALPINEBTC" -ALPINEBTC = ALPINEBTC() +ALPINEBUSD = ALPINEBUSD() @dataclass(slots=True, frozen=True) class ALPINEBUSD: + """ + name: ALPINEBUSD + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 92141578.00000000 + margin: False + """ name: str = "ALPINEBUSD" precision: int = 8 minimum_margin: float = None @@ -2252,11 +3139,20 @@ def __call__(self): return "ALPINEBUSD" -ALPINEBUSD = ALPINEBUSD() +ALPINEEUR = ALPINEEUR() @dataclass(slots=True, frozen=True) class ALPINEEUR: + """ + name: ALPINEEUR + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 92141578.00000000 + margin: False + """ name: str = "ALPINEEUR" precision: int = 8 minimum_margin: float = None @@ -2275,11 +3171,20 @@ def __call__(self): return "ALPINEEUR" -ALPINEEUR = ALPINEEUR() +ALPINETRY = ALPINETRY() @dataclass(slots=True, frozen=True) class ALPINETRY: + """ + name: ALPINETRY + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 92141578.00000000 + margin: False + """ name: str = "ALPINETRY" precision: int = 8 minimum_margin: float = None @@ -2298,11 +3203,20 @@ def __call__(self): return "ALPINETRY" -ALPINETRY = ALPINETRY() +ALPINEUSDT = ALPINEUSDT() @dataclass(slots=True, frozen=True) class ALPINEUSDT: + """ + name: ALPINEUSDT + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 92141578.00000000 + margin: False + """ name: str = "ALPINEUSDT" precision: int = 8 minimum_margin: float = None @@ -2321,11 +3235,20 @@ def __call__(self): return "ALPINEUSDT" -ALPINEUSDT = ALPINEUSDT() +AMBBNB = AMBBNB() @dataclass(slots=True, frozen=True) class AMBBNB: + """ + name: AMBBNB + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 9000000.00000000 + margin: False + """ name: str = "AMBBNB" precision: int = 8 minimum_margin: float = None @@ -2344,11 +3267,20 @@ def __call__(self): return "AMBBNB" -AMBBNB = AMBBNB() +AMBBTC = AMBBTC() @dataclass(slots=True, frozen=True) class AMBBTC: + """ + name: AMBBTC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 90000000.00000000 + margin: False + """ name: str = "AMBBTC" precision: int = 8 minimum_margin: float = None @@ -2367,11 +3299,20 @@ def __call__(self): return "AMBBTC" -AMBBTC = AMBBTC() +AMBBUSD = AMBBUSD() @dataclass(slots=True, frozen=True) class AMBBUSD: + """ + name: AMBBUSD + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 913205152.00000000 + margin: True + """ name: str = "AMBBUSD" precision: int = 8 minimum_margin: float = None @@ -2390,11 +3331,20 @@ def __call__(self): return "AMBBUSD" -AMBBUSD = AMBBUSD() +AMBETH = AMBETH() @dataclass(slots=True, frozen=True) class AMBETH: + """ + name: AMBETH + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 90000000.00000000 + margin: False + """ name: str = "AMBETH" precision: int = 8 minimum_margin: float = None @@ -2413,11 +3363,20 @@ def __call__(self): return "AMBETH" -AMBETH = AMBETH() +AMPBNB = AMPBNB() @dataclass(slots=True, frozen=True) class AMPBNB: + """ + name: AMPBNB + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 92141578.00000000 + margin: False + """ name: str = "AMPBNB" precision: int = 8 minimum_margin: float = None @@ -2436,11 +3395,20 @@ def __call__(self): return "AMPBNB" -AMPBNB = AMPBNB() +AMPBTC = AMPBTC() @dataclass(slots=True, frozen=True) class AMPBTC: + """ + name: AMPBTC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 92141578.00000000 + margin: False + """ name: str = "AMPBTC" precision: int = 8 minimum_margin: float = None @@ -2459,11 +3427,20 @@ def __call__(self): return "AMPBTC" -AMPBTC = AMPBTC() +AMPBUSD = AMPBUSD() @dataclass(slots=True, frozen=True) class AMPBUSD: + """ + name: AMPBUSD + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 92141578.00000000 + margin: False + """ name: str = "AMPBUSD" precision: int = 8 minimum_margin: float = None @@ -2482,11 +3459,20 @@ def __call__(self): return "AMPBUSD" -AMPBUSD = AMPBUSD() +AMPUSDT = AMPUSDT() @dataclass(slots=True, frozen=True) class AMPUSDT: + """ + name: AMPUSDT + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 92141578.00000000 + margin: False + """ name: str = "AMPUSDT" precision: int = 8 minimum_margin: float = None @@ -2505,11 +3491,20 @@ def __call__(self): return "AMPUSDT" -AMPUSDT = AMPUSDT() +ANCBNB = ANCBNB() @dataclass(slots=True, frozen=True) class ANCBNB: + """ + name: ANCBNB + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 92141578.00000000 + margin: False + """ name: str = "ANCBNB" precision: int = 8 minimum_margin: float = None @@ -2528,11 +3523,20 @@ def __call__(self): return "ANCBNB" -ANCBNB = ANCBNB() +ANCBTC = ANCBTC() @dataclass(slots=True, frozen=True) class ANCBTC: + """ + name: ANCBTC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 92141578.00000000 + margin: False + """ name: str = "ANCBTC" precision: int = 8 minimum_margin: float = None @@ -2551,11 +3555,20 @@ def __call__(self): return "ANCBTC" -ANCBTC = ANCBTC() +ANCBUSD = ANCBUSD() @dataclass(slots=True, frozen=True) class ANCBUSD: + """ + name: ANCBUSD + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 92141578.00000000 + margin: False + """ name: str = "ANCBUSD" precision: int = 8 minimum_margin: float = None @@ -2574,11 +3587,20 @@ def __call__(self): return "ANCBUSD" -ANCBUSD = ANCBUSD() +ANCUSDT = ANCUSDT() @dataclass(slots=True, frozen=True) class ANCUSDT: + """ + name: ANCUSDT + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 92141578.00000000 + margin: False + """ name: str = "ANCUSDT" precision: int = 8 minimum_margin: float = None @@ -2597,11 +3619,20 @@ def __call__(self): return "ANCUSDT" -ANCUSDT = ANCUSDT() +ANKRBNB = ANKRBNB() @dataclass(slots=True, frozen=True) class ANKRBNB: + """ + name: ANKRBNB + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 9000000.00000000 + margin: False + """ name: str = "ANKRBNB" precision: int = 8 minimum_margin: float = None @@ -2620,11 +3651,20 @@ def __call__(self): return "ANKRBNB" -ANKRBNB = ANKRBNB() +ANKRBTC = ANKRBTC() @dataclass(slots=True, frozen=True) class ANKRBTC: + """ + name: ANKRBTC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 90000000.00000000 + margin: True + """ name: str = "ANKRBTC" precision: int = 8 minimum_margin: float = None @@ -2643,11 +3683,20 @@ def __call__(self): return "ANKRBTC" -ANKRBTC = ANKRBTC() +ANKRBUSD = ANKRBUSD() @dataclass(slots=True, frozen=True) class ANKRBUSD: + """ + name: ANKRBUSD + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 92141578.00000000 + margin: True + """ name: str = "ANKRBUSD" precision: int = 8 minimum_margin: float = None @@ -2666,11 +3715,20 @@ def __call__(self): return "ANKRBUSD" -ANKRBUSD = ANKRBUSD() +ANKRPAX = ANKRPAX() @dataclass(slots=True, frozen=True) class ANKRPAX: + """ + name: ANKRPAX + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 9000000.00000000 + margin: False + """ name: str = "ANKRPAX" precision: int = 8 minimum_margin: float = None @@ -2689,11 +3747,20 @@ def __call__(self): return "ANKRPAX" -ANKRPAX = ANKRPAX() +ANKRTRY = ANKRTRY() @dataclass(slots=True, frozen=True) class ANKRTRY: + """ + name: ANKRTRY + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 92141578.00000000 + margin: False + """ name: str = "ANKRTRY" precision: int = 8 minimum_margin: float = None @@ -2712,11 +3779,20 @@ def __call__(self): return "ANKRTRY" -ANKRTRY = ANKRTRY() +ANKRTUSD = ANKRTUSD() @dataclass(slots=True, frozen=True) class ANKRTUSD: + """ + name: ANKRTUSD + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 9000000.00000000 + margin: False + """ name: str = "ANKRTUSD" precision: int = 8 minimum_margin: float = None @@ -2735,11 +3811,20 @@ def __call__(self): return "ANKRTUSD" -ANKRTUSD = ANKRTUSD() +ANKRUSDC = ANKRUSDC() @dataclass(slots=True, frozen=True) class ANKRUSDC: + """ + name: ANKRUSDC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 9000000.00000000 + margin: False + """ name: str = "ANKRUSDC" precision: int = 8 minimum_margin: float = None @@ -2758,11 +3843,20 @@ def __call__(self): return "ANKRUSDC" -ANKRUSDC = ANKRUSDC() +ANKRUSDT = ANKRUSDT() @dataclass(slots=True, frozen=True) class ANKRUSDT: + """ + name: ANKRUSDT + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 9000000.00000000 + margin: True + """ name: str = "ANKRUSDT" precision: int = 8 minimum_margin: float = None @@ -2781,11 +3875,20 @@ def __call__(self): return "ANKRUSDT" -ANKRUSDT = ANKRUSDT() +ANTBNB = ANTBNB() @dataclass(slots=True, frozen=True) class ANTBNB: + """ + name: ANTBNB + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 9000000.00000000 + margin: False + """ name: str = "ANTBNB" precision: int = 8 minimum_margin: float = None @@ -2804,11 +3907,20 @@ def __call__(self): return "ANTBNB" -ANTBNB = ANTBNB() +ANTBTC = ANTBTC() @dataclass(slots=True, frozen=True) class ANTBTC: + """ + name: ANTBTC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 90000000.00000000 + margin: True + """ name: str = "ANTBTC" precision: int = 8 minimum_margin: float = None @@ -2827,11 +3939,20 @@ def __call__(self): return "ANTBTC" -ANTBTC = ANTBTC() +ANTBUSD = ANTBUSD() @dataclass(slots=True, frozen=True) class ANTBUSD: + """ + name: ANTBUSD + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 900000.00000000 + margin: True + """ name: str = "ANTBUSD" precision: int = 8 minimum_margin: float = None @@ -2850,11 +3971,20 @@ def __call__(self): return "ANTBUSD" -ANTBUSD = ANTBUSD() +ANTUSDT = ANTUSDT() @dataclass(slots=True, frozen=True) class ANTUSDT: + """ + name: ANTUSDT + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 900000.00000000 + margin: True + """ name: str = "ANTUSDT" precision: int = 8 minimum_margin: float = None @@ -2873,11 +4003,20 @@ def __call__(self): return "ANTUSDT" -ANTUSDT = ANTUSDT() +ANYBTC = ANYBTC() @dataclass(slots=True, frozen=True) class ANYBTC: + """ + name: ANYBTC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 92141578.00000000 + margin: False + """ name: str = "ANYBTC" precision: int = 8 minimum_margin: float = None @@ -2896,11 +4035,20 @@ def __call__(self): return "ANYBTC" -ANYBTC = ANYBTC() +ANYBUSD = ANYBUSD() @dataclass(slots=True, frozen=True) class ANYBUSD: + """ + name: ANYBUSD + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 9222449.00000000 + margin: False + """ name: str = "ANYBUSD" precision: int = 8 minimum_margin: float = None @@ -2919,11 +4067,20 @@ def __call__(self): return "ANYBUSD" -ANYBUSD = ANYBUSD() +ANYUSDT = ANYUSDT() @dataclass(slots=True, frozen=True) class ANYUSDT: + """ + name: ANYUSDT + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 9222449.00000000 + margin: False + """ name: str = "ANYUSDT" precision: int = 8 minimum_margin: float = None @@ -2942,11 +4099,20 @@ def __call__(self): return "ANYUSDT" -ANYUSDT = ANYUSDT() +APEAUD = APEAUD() @dataclass(slots=True, frozen=True) class APEAUD: + """ + name: APEAUD + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 92141578.00000000 + margin: False + """ name: str = "APEAUD" precision: int = 8 minimum_margin: float = None @@ -2965,11 +4131,20 @@ def __call__(self): return "APEAUD" -APEAUD = APEAUD() +APEBNB = APEBNB() @dataclass(slots=True, frozen=True) class APEBNB: + """ + name: APEBNB + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.00100000 + maximum_order_size: 92141578.00000000 + margin: False + """ name: str = "APEBNB" precision: int = 8 minimum_margin: float = None @@ -2988,11 +4163,20 @@ def __call__(self): return "APEBNB" -APEBNB = APEBNB() +APEBRL = APEBRL() @dataclass(slots=True, frozen=True) class APEBRL: + """ + name: APEBRL + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 922327.00000000 + margin: False + """ name: str = "APEBRL" precision: int = 8 minimum_margin: float = None @@ -3011,11 +4195,20 @@ def __call__(self): return "APEBRL" -APEBRL = APEBRL() +APEBTC = APEBTC() @dataclass(slots=True, frozen=True) class APEBTC: + """ + name: APEBTC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 92141578.00000000 + margin: True + """ name: str = "APEBTC" precision: int = 8 minimum_margin: float = None @@ -3034,11 +4227,20 @@ def __call__(self): return "APEBTC" -APEBTC = APEBTC() +APEBUSD = APEBUSD() @dataclass(slots=True, frozen=True) class APEBUSD: + """ + name: APEBUSD + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 92141578.00000000 + margin: True + """ name: str = "APEBUSD" precision: int = 8 minimum_margin: float = None @@ -3057,11 +4259,20 @@ def __call__(self): return "APEBUSD" -APEBUSD = APEBUSD() +APEETH = APEETH() @dataclass(slots=True, frozen=True) class APEETH: + """ + name: APEETH + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.00100000 + maximum_order_size: 92141578.00000000 + margin: True + """ name: str = "APEETH" precision: int = 8 minimum_margin: float = None @@ -3080,11 +4291,20 @@ def __call__(self): return "APEETH" -APEETH = APEETH() +APEEUR = APEEUR() @dataclass(slots=True, frozen=True) class APEEUR: + """ + name: APEEUR + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 92141578.00000000 + margin: False + """ name: str = "APEEUR" precision: int = 8 minimum_margin: float = None @@ -3103,11 +4323,20 @@ def __call__(self): return "APEEUR" -APEEUR = APEEUR() +APEGBP = APEGBP() @dataclass(slots=True, frozen=True) class APEGBP: + """ + name: APEGBP + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 92141578.00000000 + margin: False + """ name: str = "APEGBP" precision: int = 8 minimum_margin: float = None @@ -3126,11 +4355,20 @@ def __call__(self): return "APEGBP" -APEGBP = APEGBP() +APETRY = APETRY() @dataclass(slots=True, frozen=True) class APETRY: + """ + name: APETRY + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.00100000 + maximum_order_size: 922327.00000000 + margin: False + """ name: str = "APETRY" precision: int = 8 minimum_margin: float = None @@ -3149,11 +4387,20 @@ def __call__(self): return "APETRY" -APETRY = APETRY() +APEUSDT = APEUSDT() @dataclass(slots=True, frozen=True) class APEUSDT: + """ + name: APEUSDT + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 92141578.00000000 + margin: True + """ name: str = "APEUSDT" precision: int = 8 minimum_margin: float = None @@ -3172,11 +4419,20 @@ def __call__(self): return "APEUSDT" -APEUSDT = APEUSDT() +API3BNB = API3BNB() @dataclass(slots=True, frozen=True) class API3BNB: + """ + name: API3BNB + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 92141578.00000000 + margin: False + """ name: str = "API3BNB" precision: int = 8 minimum_margin: float = None @@ -3195,11 +4451,20 @@ def __call__(self): return "API3BNB" -API3BNB = API3BNB() +API3BTC = API3BTC() @dataclass(slots=True, frozen=True) class API3BTC: + """ + name: API3BTC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 92141578.00000000 + margin: False + """ name: str = "API3BTC" precision: int = 8 minimum_margin: float = None @@ -3218,11 +4483,20 @@ def __call__(self): return "API3BTC" -API3BTC = API3BTC() +API3BUSD = API3BUSD() @dataclass(slots=True, frozen=True) class API3BUSD: + """ + name: API3BUSD + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 92141578.00000000 + margin: False + """ name: str = "API3BUSD" precision: int = 8 minimum_margin: float = None @@ -3241,11 +4515,20 @@ def __call__(self): return "API3BUSD" -API3BUSD = API3BUSD() +API3TRY = API3TRY() @dataclass(slots=True, frozen=True) class API3TRY: + """ + name: API3TRY + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 9222449.00000000 + margin: False + """ name: str = "API3TRY" precision: int = 8 minimum_margin: float = None @@ -3264,11 +4547,20 @@ def __call__(self): return "API3TRY" -API3TRY = API3TRY() +API3USDT = API3USDT() @dataclass(slots=True, frozen=True) class API3USDT: + """ + name: API3USDT + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 92141578.00000000 + margin: True + """ name: str = "API3USDT" precision: int = 8 minimum_margin: float = None @@ -3287,11 +4579,20 @@ def __call__(self): return "API3USDT" -API3USDT = API3USDT() +APPCBNB = APPCBNB() @dataclass(slots=True, frozen=True) class APPCBNB: + """ + name: APPCBNB + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 9000000.00000000 + margin: False + """ name: str = "APPCBNB" precision: int = 8 minimum_margin: float = None @@ -3310,11 +4611,20 @@ def __call__(self): return "APPCBNB" -APPCBNB = APPCBNB() +APPCBTC = APPCBTC() @dataclass(slots=True, frozen=True) class APPCBTC: + """ + name: APPCBTC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 90000000.00000000 + margin: False + """ name: str = "APPCBTC" precision: int = 8 minimum_margin: float = None @@ -3333,11 +4643,20 @@ def __call__(self): return "APPCBTC" -APPCBTC = APPCBTC() +APPCETH = APPCETH() @dataclass(slots=True, frozen=True) class APPCETH: + """ + name: APPCETH + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 90000000.00000000 + margin: False + """ name: str = "APPCETH" precision: int = 8 minimum_margin: float = None @@ -3356,11 +4675,20 @@ def __call__(self): return "APPCETH" -APPCETH = APPCETH() +APTBRL = APTBRL() @dataclass(slots=True, frozen=True) class APTBRL: + """ + name: APTBRL + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 9222449.00000000 + margin: False + """ name: str = "APTBRL" precision: int = 8 minimum_margin: float = None @@ -3379,11 +4707,20 @@ def __call__(self): return "APTBRL" -APTBRL = APTBRL() +APTBTC = APTBTC() @dataclass(slots=True, frozen=True) class APTBTC: + """ + name: APTBTC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 8384883677.00000000 + margin: False + """ name: str = "APTBTC" precision: int = 8 minimum_margin: float = None @@ -3402,11 +4739,20 @@ def __call__(self): return "APTBTC" -APTBTC = APTBTC() +APTBUSD = APTBUSD() @dataclass(slots=True, frozen=True) class APTBUSD: + """ + name: APTBUSD + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 92141578.00000000 + margin: True + """ name: str = "APTBUSD" precision: int = 8 minimum_margin: float = None @@ -3425,11 +4771,20 @@ def __call__(self): return "APTBUSD" -APTBUSD = APTBUSD() +APTEUR = APTEUR() @dataclass(slots=True, frozen=True) class APTEUR: + """ + name: APTEUR + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 92141578.00000000 + margin: False + """ name: str = "APTEUR" precision: int = 8 minimum_margin: float = None @@ -3448,11 +4803,20 @@ def __call__(self): return "APTEUR" -APTEUR = APTEUR() +APTTRY = APTTRY() @dataclass(slots=True, frozen=True) class APTTRY: + """ + name: APTTRY + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 922327.00000000 + margin: False + """ name: str = "APTTRY" precision: int = 8 minimum_margin: float = None @@ -3471,11 +4835,20 @@ def __call__(self): return "APTTRY" -APTTRY = APTTRY() +APTUSDT = APTUSDT() @dataclass(slots=True, frozen=True) class APTUSDT: + """ + name: APTUSDT + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 92141578.00000000 + margin: True + """ name: str = "APTUSDT" precision: int = 8 minimum_margin: float = None @@ -3494,11 +4867,20 @@ def __call__(self): return "APTUSDT" -APTUSDT = APTUSDT() +ARBNB = ARBNB() @dataclass(slots=True, frozen=True) class ARBNB: + """ + name: ARBNB + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 100000.00000000 + margin: False + """ name: str = "ARBNB" precision: int = 8 minimum_margin: float = None @@ -3517,11 +4899,20 @@ def __call__(self): return "ARBNB" -ARBNB = ARBNB() +ARBTC = ARBTC() @dataclass(slots=True, frozen=True) class ARBTC: + """ + name: ARBTC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 100000.00000000 + margin: False + """ name: str = "ARBTC" precision: int = 8 minimum_margin: float = None @@ -3540,11 +4931,20 @@ def __call__(self): return "ARBTC" -ARBTC = ARBTC() +ARBUSD = ARBUSD() @dataclass(slots=True, frozen=True) class ARBUSD: + """ + name: ARBUSD + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 100000.00000000 + margin: False + """ name: str = "ARBUSD" precision: int = 8 minimum_margin: float = None @@ -3563,11 +4963,20 @@ def __call__(self): return "ARBUSD" -ARBUSD = ARBUSD() +ARDRBNB = ARDRBNB() @dataclass(slots=True, frozen=True) class ARDRBNB: + """ + name: ARDRBNB + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 9000000.00000000 + margin: False + """ name: str = "ARDRBNB" precision: int = 8 minimum_margin: float = None @@ -3586,11 +4995,20 @@ def __call__(self): return "ARDRBNB" -ARDRBNB = ARDRBNB() +ARDRBTC = ARDRBTC() @dataclass(slots=True, frozen=True) class ARDRBTC: + """ + name: ARDRBTC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 90000000.00000000 + margin: False + """ name: str = "ARDRBTC" precision: int = 8 minimum_margin: float = None @@ -3609,11 +5027,20 @@ def __call__(self): return "ARDRBTC" -ARDRBTC = ARDRBTC() +ARDRETH = ARDRETH() @dataclass(slots=True, frozen=True) class ARDRETH: + """ + name: ARDRETH + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 90000000.00000000 + margin: False + """ name: str = "ARDRETH" precision: int = 8 minimum_margin: float = None @@ -3632,11 +5059,20 @@ def __call__(self): return "ARDRETH" -ARDRETH = ARDRETH() +ARDRUSDT = ARDRUSDT() @dataclass(slots=True, frozen=True) class ARDRUSDT: + """ + name: ARDRUSDT + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 9000000.00000000 + margin: False + """ name: str = "ARDRUSDT" precision: int = 8 minimum_margin: float = None @@ -3655,11 +5091,20 @@ def __call__(self): return "ARDRUSDT" -ARDRUSDT = ARDRUSDT() +ARKBTC = ARKBTC() @dataclass(slots=True, frozen=True) class ARKBTC: + """ + name: ARKBTC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 90000000.00000000 + margin: False + """ name: str = "ARKBTC" precision: int = 8 minimum_margin: float = None @@ -3678,11 +5123,20 @@ def __call__(self): return "ARKBTC" -ARKBTC = ARKBTC() +ARKBUSD = ARKBUSD() @dataclass(slots=True, frozen=True) class ARKBUSD: + """ + name: ARKBUSD + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 92141578.00000000 + margin: False + """ name: str = "ARKBUSD" precision: int = 8 minimum_margin: float = None @@ -3701,11 +5155,20 @@ def __call__(self): return "ARKBUSD" -ARKBUSD = ARKBUSD() +ARKETH = ARKETH() @dataclass(slots=True, frozen=True) class ARKETH: + """ + name: ARKETH + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 90000000.00000000 + margin: False + """ name: str = "ARKETH" precision: int = 8 minimum_margin: float = None @@ -3724,11 +5187,20 @@ def __call__(self): return "ARKETH" -ARKETH = ARKETH() +ARNBTC = ARNBTC() @dataclass(slots=True, frozen=True) class ARNBTC: + """ + name: ARNBTC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 90000000.00000000 + margin: False + """ name: str = "ARNBTC" precision: int = 8 minimum_margin: float = None @@ -3747,11 +5219,20 @@ def __call__(self): return "ARNBTC" -ARNBTC = ARNBTC() +ARNETH = ARNETH() @dataclass(slots=True, frozen=True) class ARNETH: + """ + name: ARNETH + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 90000000.00000000 + margin: False + """ name: str = "ARNETH" precision: int = 8 minimum_margin: float = None @@ -3770,11 +5251,20 @@ def __call__(self): return "ARNETH" -ARNETH = ARNETH() +ARPABNB = ARPABNB() @dataclass(slots=True, frozen=True) class ARPABNB: + """ + name: ARPABNB + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 9000000.00000000 + margin: False + """ name: str = "ARPABNB" precision: int = 8 minimum_margin: float = None @@ -3793,11 +5283,20 @@ def __call__(self): return "ARPABNB" -ARPABNB = ARPABNB() +ARPABTC = ARPABTC() @dataclass(slots=True, frozen=True) class ARPABTC: + """ + name: ARPABTC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 90000000.00000000 + margin: True + """ name: str = "ARPABTC" precision: int = 8 minimum_margin: float = None @@ -3816,11 +5315,20 @@ def __call__(self): return "ARPABTC" -ARPABTC = ARPABTC() +ARPABUSD = ARPABUSD() @dataclass(slots=True, frozen=True) class ARPABUSD: + """ + name: ARPABUSD + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 92141578.00000000 + margin: True + """ name: str = "ARPABUSD" precision: int = 8 minimum_margin: float = None @@ -3839,11 +5347,20 @@ def __call__(self): return "ARPABUSD" -ARPABUSD = ARPABUSD() +ARPAETH = ARPAETH() @dataclass(slots=True, frozen=True) class ARPAETH: + """ + name: ARPAETH + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 913205152.00000000 + margin: False + """ name: str = "ARPAETH" precision: int = 8 minimum_margin: float = None @@ -3862,11 +5379,20 @@ def __call__(self): return "ARPAETH" -ARPAETH = ARPAETH() +ARPARUB = ARPARUB() @dataclass(slots=True, frozen=True) class ARPARUB: + """ + name: ARPARUB + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 92141578.00000000 + margin: False + """ name: str = "ARPARUB" precision: int = 8 minimum_margin: float = None @@ -3885,11 +5411,20 @@ def __call__(self): return "ARPARUB" -ARPARUB = ARPARUB() +ARPATRY = ARPATRY() @dataclass(slots=True, frozen=True) class ARPATRY: + """ + name: ARPATRY + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 92141578.00000000 + margin: False + """ name: str = "ARPATRY" precision: int = 8 minimum_margin: float = None @@ -3908,11 +5443,20 @@ def __call__(self): return "ARPATRY" -ARPATRY = ARPATRY() +ARPAUSDT = ARPAUSDT() @dataclass(slots=True, frozen=True) class ARPAUSDT: + """ + name: ARPAUSDT + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 9000000.00000000 + margin: True + """ name: str = "ARPAUSDT" precision: int = 8 minimum_margin: float = None @@ -3931,11 +5475,20 @@ def __call__(self): return "ARPAUSDT" -ARPAUSDT = ARPAUSDT() +ARUSDT = ARUSDT() @dataclass(slots=True, frozen=True) class ARUSDT: + """ + name: ARUSDT + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 100000.00000000 + margin: True + """ name: str = "ARUSDT" precision: int = 8 minimum_margin: float = None @@ -3954,11 +5507,20 @@ def __call__(self): return "ARUSDT" -ARUSDT = ARUSDT() +ASRBTC = ASRBTC() @dataclass(slots=True, frozen=True) class ASRBTC: + """ + name: ASRBTC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 90000000.00000000 + margin: False + """ name: str = "ASRBTC" precision: int = 8 minimum_margin: float = None @@ -3977,11 +5539,20 @@ def __call__(self): return "ASRBTC" -ASRBTC = ASRBTC() +ASRBUSD = ASRBUSD() @dataclass(slots=True, frozen=True) class ASRBUSD: + """ + name: ASRBUSD + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 90000.00000000 + margin: False + """ name: str = "ASRBUSD" precision: int = 8 minimum_margin: float = None @@ -4000,11 +5571,20 @@ def __call__(self): return "ASRBUSD" -ASRBUSD = ASRBUSD() +ASRUSDT = ASRUSDT() @dataclass(slots=True, frozen=True) class ASRUSDT: + """ + name: ASRUSDT + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 90000.00000000 + margin: False + """ name: str = "ASRUSDT" precision: int = 8 minimum_margin: float = None @@ -4023,11 +5603,20 @@ def __call__(self): return "ASRUSDT" -ASRUSDT = ASRUSDT() +ASTBTC = ASTBTC() @dataclass(slots=True, frozen=True) class ASTBTC: + """ + name: ASTBTC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 90000000.00000000 + margin: False + """ name: str = "ASTBTC" precision: int = 8 minimum_margin: float = None @@ -4046,11 +5635,20 @@ def __call__(self): return "ASTBTC" -ASTBTC = ASTBTC() +ASTETH = ASTETH() @dataclass(slots=True, frozen=True) class ASTETH: + """ + name: ASTETH + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 90000000.00000000 + margin: False + """ name: str = "ASTETH" precision: int = 8 minimum_margin: float = None @@ -4069,11 +5667,20 @@ def __call__(self): return "ASTETH" -ASTETH = ASTETH() +ASTRBTC = ASTRBTC() @dataclass(slots=True, frozen=True) class ASTRBTC: + """ + name: ASTRBTC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 92141578.00000000 + margin: False + """ name: str = "ASTRBTC" precision: int = 8 minimum_margin: float = None @@ -4092,11 +5699,20 @@ def __call__(self): return "ASTRBTC" -ASTRBTC = ASTRBTC() +ASTRBUSD = ASTRBUSD() @dataclass(slots=True, frozen=True) class ASTRBUSD: + """ + name: ASTRBUSD + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 92141578.00000000 + margin: True + """ name: str = "ASTRBUSD" precision: int = 8 minimum_margin: float = None @@ -4115,11 +5731,20 @@ def __call__(self): return "ASTRBUSD" -ASTRBUSD = ASTRBUSD() +ASTRETH = ASTRETH() @dataclass(slots=True, frozen=True) class ASTRETH: + """ + name: ASTRETH + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 92141578.00000000 + margin: False + """ name: str = "ASTRETH" precision: int = 8 minimum_margin: float = None @@ -4138,11 +5763,20 @@ def __call__(self): return "ASTRETH" -ASTRETH = ASTRETH() +ASTRUSDT = ASTRUSDT() @dataclass(slots=True, frozen=True) class ASTRUSDT: + """ + name: ASTRUSDT + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 92141578.00000000 + margin: True + """ name: str = "ASTRUSDT" precision: int = 8 minimum_margin: float = None @@ -4161,11 +5795,20 @@ def __call__(self): return "ASTRUSDT" -ASTRUSDT = ASTRUSDT() +ATABNB = ATABNB() @dataclass(slots=True, frozen=True) class ATABNB: + """ + name: ATABNB + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 92141578.00000000 + margin: False + """ name: str = "ATABNB" precision: int = 8 minimum_margin: float = None @@ -4184,11 +5827,20 @@ def __call__(self): return "ATABNB" -ATABNB = ATABNB() +ATABTC = ATABTC() @dataclass(slots=True, frozen=True) class ATABTC: + """ + name: ATABTC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 92141578.00000000 + margin: False + """ name: str = "ATABTC" precision: int = 8 minimum_margin: float = None @@ -4207,11 +5859,20 @@ def __call__(self): return "ATABTC" -ATABTC = ATABTC() +ATABUSD = ATABUSD() @dataclass(slots=True, frozen=True) class ATABUSD: + """ + name: ATABUSD + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 9222449.00000000 + margin: False + """ name: str = "ATABUSD" precision: int = 8 minimum_margin: float = None @@ -4230,11 +5891,20 @@ def __call__(self): return "ATABUSD" -ATABUSD = ATABUSD() +ATAUSDT = ATAUSDT() @dataclass(slots=True, frozen=True) class ATAUSDT: + """ + name: ATAUSDT + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 9222449.00000000 + margin: False + """ name: str = "ATAUSDT" precision: int = 8 minimum_margin: float = None @@ -4253,11 +5923,20 @@ def __call__(self): return "ATAUSDT" -ATAUSDT = ATAUSDT() +ATMBTC = ATMBTC() @dataclass(slots=True, frozen=True) class ATMBTC: + """ + name: ATMBTC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 90000000.00000000 + margin: False + """ name: str = "ATMBTC" precision: int = 8 minimum_margin: float = None @@ -4276,11 +5955,20 @@ def __call__(self): return "ATMBTC" -ATMBTC = ATMBTC() +ATMBUSD = ATMBUSD() @dataclass(slots=True, frozen=True) class ATMBUSD: + """ + name: ATMBUSD + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 9222449.00000000 + margin: False + """ name: str = "ATMBUSD" precision: int = 8 minimum_margin: float = None @@ -4299,11 +5987,20 @@ def __call__(self): return "ATMBUSD" -ATMBUSD = ATMBUSD() +ATMUSDT = ATMUSDT() @dataclass(slots=True, frozen=True) class ATMUSDT: + """ + name: ATMUSDT + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 90000.00000000 + margin: False + """ name: str = "ATMUSDT" precision: int = 8 minimum_margin: float = None @@ -4322,11 +6019,20 @@ def __call__(self): return "ATMUSDT" -ATMUSDT = ATMUSDT() +ATOMBIDR = ATOMBIDR() @dataclass(slots=True, frozen=True) class ATOMBIDR: + """ + name: ATOMBIDR + precision: 2 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.00100000 + maximum_order_size: 922337194.00000000 + margin: False + """ name: str = "ATOMBIDR" precision: int = 2 minimum_margin: float = None @@ -4345,11 +6051,20 @@ def __call__(self): return "ATOMBIDR" -ATOMBIDR = ATOMBIDR() +ATOMBNB = ATOMBNB() @dataclass(slots=True, frozen=True) class ATOMBNB: + """ + name: ATOMBNB + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 9000000.00000000 + margin: False + """ name: str = "ATOMBNB" precision: int = 8 minimum_margin: float = None @@ -4368,11 +6083,20 @@ def __call__(self): return "ATOMBNB" -ATOMBNB = ATOMBNB() +ATOMBRL = ATOMBRL() @dataclass(slots=True, frozen=True) class ATOMBRL: + """ + name: ATOMBRL + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.00100000 + maximum_order_size: 922327.00000000 + margin: False + """ name: str = "ATOMBRL" precision: int = 8 minimum_margin: float = None @@ -4391,11 +6115,20 @@ def __call__(self): return "ATOMBRL" -ATOMBRL = ATOMBRL() +ATOMBTC = ATOMBTC() @dataclass(slots=True, frozen=True) class ATOMBTC: + """ + name: ATOMBTC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 90000000.00000000 + margin: True + """ name: str = "ATOMBTC" precision: int = 8 minimum_margin: float = None @@ -4414,11 +6147,20 @@ def __call__(self): return "ATOMBTC" -ATOMBTC = ATOMBTC() +ATOMBUSD = ATOMBUSD() @dataclass(slots=True, frozen=True) class ATOMBUSD: + """ + name: ATOMBUSD + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 90000.00000000 + margin: True + """ name: str = "ATOMBUSD" precision: int = 8 minimum_margin: float = None @@ -4437,11 +6179,20 @@ def __call__(self): return "ATOMBUSD" -ATOMBUSD = ATOMBUSD() +ATOMETH = ATOMETH() @dataclass(slots=True, frozen=True) class ATOMETH: + """ + name: ATOMETH + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.00100000 + maximum_order_size: 92141578.00000000 + margin: False + """ name: str = "ATOMETH" precision: int = 8 minimum_margin: float = None @@ -4460,11 +6211,20 @@ def __call__(self): return "ATOMETH" -ATOMETH = ATOMETH() +ATOMEUR = ATOMEUR() @dataclass(slots=True, frozen=True) class ATOMEUR: + """ + name: ATOMEUR + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 90000.00000000 + margin: False + """ name: str = "ATOMEUR" precision: int = 8 minimum_margin: float = None @@ -4483,11 +6243,20 @@ def __call__(self): return "ATOMEUR" -ATOMEUR = ATOMEUR() +ATOMPAX = ATOMPAX() @dataclass(slots=True, frozen=True) class ATOMPAX: + """ + name: ATOMPAX + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.00100000 + maximum_order_size: 90000.00000000 + margin: False + """ name: str = "ATOMPAX" precision: int = 8 minimum_margin: float = None @@ -4506,11 +6275,20 @@ def __call__(self): return "ATOMPAX" -ATOMPAX = ATOMPAX() +ATOMTRY = ATOMTRY() @dataclass(slots=True, frozen=True) class ATOMTRY: + """ + name: ATOMTRY + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.00100000 + maximum_order_size: 922327.00000000 + margin: False + """ name: str = "ATOMTRY" precision: int = 8 minimum_margin: float = None @@ -4529,11 +6307,20 @@ def __call__(self): return "ATOMTRY" -ATOMTRY = ATOMTRY() +ATOMTUSD = ATOMTUSD() @dataclass(slots=True, frozen=True) class ATOMTUSD: + """ + name: ATOMTUSD + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.00100000 + maximum_order_size: 90000.00000000 + margin: False + """ name: str = "ATOMTUSD" precision: int = 8 minimum_margin: float = None @@ -4552,11 +6339,20 @@ def __call__(self): return "ATOMTUSD" -ATOMTUSD = ATOMTUSD() +ATOMUSDC = ATOMUSDC() @dataclass(slots=True, frozen=True) class ATOMUSDC: + """ + name: ATOMUSDC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 90000.00000000 + margin: False + """ name: str = "ATOMUSDC" precision: int = 8 minimum_margin: float = None @@ -4575,11 +6371,20 @@ def __call__(self): return "ATOMUSDC" -ATOMUSDC = ATOMUSDC() +ATOMUSDT = ATOMUSDT() @dataclass(slots=True, frozen=True) class ATOMUSDT: + """ + name: ATOMUSDT + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 90000.00000000 + margin: True + """ name: str = "ATOMUSDT" precision: int = 8 minimum_margin: float = None @@ -4598,11 +6403,20 @@ def __call__(self): return "ATOMUSDT" -ATOMUSDT = ATOMUSDT() +AUCTIONBTC = AUCTIONBTC() @dataclass(slots=True, frozen=True) class AUCTIONBTC: + """ + name: AUCTIONBTC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 90000000.00000000 + margin: False + """ name: str = "AUCTIONBTC" precision: int = 8 minimum_margin: float = None @@ -4621,11 +6435,20 @@ def __call__(self): return "AUCTIONBTC" -AUCTIONBTC = AUCTIONBTC() +AUCTIONBUSD = AUCTIONBUSD() @dataclass(slots=True, frozen=True) class AUCTIONBUSD: + """ + name: AUCTIONBUSD + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 90000.00000000 + margin: True + """ name: str = "AUCTIONBUSD" precision: int = 8 minimum_margin: float = None @@ -4644,11 +6467,20 @@ def __call__(self): return "AUCTIONBUSD" -AUCTIONBUSD = AUCTIONBUSD() +AUCTIONUSDT = AUCTIONUSDT() @dataclass(slots=True, frozen=True) class AUCTIONUSDT: + """ + name: AUCTIONUSDT + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 9222449.00000000 + margin: True + """ name: str = "AUCTIONUSDT" precision: int = 8 minimum_margin: float = None @@ -4667,11 +6499,20 @@ def __call__(self): return "AUCTIONUSDT" -AUCTIONUSDT = AUCTIONUSDT() +AUDBUSD = AUDBUSD() @dataclass(slots=True, frozen=True) class AUDBUSD: + """ + name: AUDBUSD + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 9000000.00000000 + margin: False + """ name: str = "AUDBUSD" precision: int = 8 minimum_margin: float = None @@ -4690,11 +6531,20 @@ def __call__(self): return "AUDBUSD" -AUDBUSD = AUDBUSD() +AUDIOBTC = AUDIOBTC() @dataclass(slots=True, frozen=True) class AUDIOBTC: + """ + name: AUDIOBTC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 90000000.00000000 + margin: True + """ name: str = "AUDIOBTC" precision: int = 8 minimum_margin: float = None @@ -4713,11 +6563,20 @@ def __call__(self): return "AUDIOBTC" -AUDIOBTC = AUDIOBTC() +AUDIOBUSD = AUDIOBUSD() @dataclass(slots=True, frozen=True) class AUDIOBUSD: + """ + name: AUDIOBUSD + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 900000.00000000 + margin: True + """ name: str = "AUDIOBUSD" precision: int = 8 minimum_margin: float = None @@ -4736,11 +6595,20 @@ def __call__(self): return "AUDIOBUSD" -AUDIOBUSD = AUDIOBUSD() +AUDIOTRY = AUDIOTRY() @dataclass(slots=True, frozen=True) class AUDIOTRY: + """ + name: AUDIOTRY + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 9222449.00000000 + margin: False + """ name: str = "AUDIOTRY" precision: int = 8 minimum_margin: float = None @@ -4759,11 +6627,20 @@ def __call__(self): return "AUDIOTRY" -AUDIOTRY = AUDIOTRY() +AUDIOUSDT = AUDIOUSDT() @dataclass(slots=True, frozen=True) class AUDIOUSDT: + """ + name: AUDIOUSDT + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 900000.00000000 + margin: True + """ name: str = "AUDIOUSDT" precision: int = 8 minimum_margin: float = None @@ -4782,11 +6659,20 @@ def __call__(self): return "AUDIOUSDT" -AUDIOUSDT = AUDIOUSDT() +AUDUSDC = AUDUSDC() @dataclass(slots=True, frozen=True) class AUDUSDC: + """ + name: AUDUSDC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 922327.00000000 + margin: False + """ name: str = "AUDUSDC" precision: int = 8 minimum_margin: float = None @@ -4805,11 +6691,20 @@ def __call__(self): return "AUDUSDC" -AUDUSDC = AUDUSDC() +AUDUSDT = AUDUSDT() @dataclass(slots=True, frozen=True) class AUDUSDT: + """ + name: AUDUSDT + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 9000000.00000000 + margin: False + """ name: str = "AUDUSDT" precision: int = 8 minimum_margin: float = None @@ -4828,11 +6723,20 @@ def __call__(self): return "AUDUSDT" -AUDUSDT = AUDUSDT() +AUTOBTC = AUTOBTC() @dataclass(slots=True, frozen=True) class AUTOBTC: + """ + name: AUTOBTC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.00100000 + maximum_order_size: 92141578.00000000 + margin: False + """ name: str = "AUTOBTC" precision: int = 8 minimum_margin: float = None @@ -4851,11 +6755,20 @@ def __call__(self): return "AUTOBTC" -AUTOBTC = AUTOBTC() +AUTOBUSD = AUTOBUSD() @dataclass(slots=True, frozen=True) class AUTOBUSD: + """ + name: AUTOBUSD + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.00100000 + maximum_order_size: 9000.00000000 + margin: False + """ name: str = "AUTOBUSD" precision: int = 8 minimum_margin: float = None @@ -4874,11 +6787,20 @@ def __call__(self): return "AUTOBUSD" -AUTOBUSD = AUTOBUSD() +AUTOUSDT = AUTOUSDT() @dataclass(slots=True, frozen=True) class AUTOUSDT: + """ + name: AUTOUSDT + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.00100000 + maximum_order_size: 9000.00000000 + margin: False + """ name: str = "AUTOUSDT" precision: int = 8 minimum_margin: float = None @@ -4897,11 +6819,20 @@ def __call__(self): return "AUTOUSDT" -AUTOUSDT = AUTOUSDT() +AVABNB = AVABNB() @dataclass(slots=True, frozen=True) class AVABNB: + """ + name: AVABNB + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 9000000.00000000 + margin: False + """ name: str = "AVABNB" precision: int = 8 minimum_margin: float = None @@ -4920,11 +6851,20 @@ def __call__(self): return "AVABNB" -AVABNB = AVABNB() +AVABTC = AVABTC() @dataclass(slots=True, frozen=True) class AVABTC: + """ + name: AVABTC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 90000000.00000000 + margin: False + """ name: str = "AVABTC" precision: int = 8 minimum_margin: float = None @@ -4943,11 +6883,20 @@ def __call__(self): return "AVABTC" -AVABTC = AVABTC() +AVABUSD = AVABUSD() @dataclass(slots=True, frozen=True) class AVABUSD: + """ + name: AVABUSD + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 900000.00000000 + margin: True + """ name: str = "AVABUSD" precision: int = 8 minimum_margin: float = None @@ -4966,11 +6915,20 @@ def __call__(self): return "AVABUSD" -AVABUSD = AVABUSD() +AVAUSDT = AVAUSDT() @dataclass(slots=True, frozen=True) class AVAUSDT: + """ + name: AVAUSDT + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 900000.00000000 + margin: True + """ name: str = "AVAUSDT" precision: int = 8 minimum_margin: float = None @@ -4989,11 +6947,20 @@ def __call__(self): return "AVAUSDT" -AVAUSDT = AVAUSDT() +AVAXAUD = AVAXAUD() @dataclass(slots=True, frozen=True) class AVAXAUD: + """ + name: AVAXAUD + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 9222449.00000000 + margin: False + """ name: str = "AVAXAUD" precision: int = 8 minimum_margin: float = None @@ -5012,11 +6979,20 @@ def __call__(self): return "AVAXAUD" -AVAXAUD = AVAXAUD() +AVAXBIDR = AVAXBIDR() @dataclass(slots=True, frozen=True) class AVAXBIDR: + """ + name: AVAXBIDR + precision: 2 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 922337194.00000000 + margin: False + """ name: str = "AVAXBIDR" precision: int = 2 minimum_margin: float = None @@ -5035,11 +7011,20 @@ def __call__(self): return "AVAXBIDR" -AVAXBIDR = AVAXBIDR() +AVAXBNB = AVAXBNB() @dataclass(slots=True, frozen=True) class AVAXBNB: + """ + name: AVAXBNB + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 9000000.00000000 + margin: False + """ name: str = "AVAXBNB" precision: int = 8 minimum_margin: float = None @@ -5058,11 +7043,20 @@ def __call__(self): return "AVAXBNB" -AVAXBNB = AVAXBNB() +AVAXBRL = AVAXBRL() @dataclass(slots=True, frozen=True) class AVAXBRL: + """ + name: AVAXBRL + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 922327.00000000 + margin: False + """ name: str = "AVAXBRL" precision: int = 8 minimum_margin: float = None @@ -5081,11 +7075,20 @@ def __call__(self): return "AVAXBRL" -AVAXBRL = AVAXBRL() +AVAXBTC = AVAXBTC() @dataclass(slots=True, frozen=True) class AVAXBTC: + """ + name: AVAXBTC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 90000000.00000000 + margin: True + """ name: str = "AVAXBTC" precision: int = 8 minimum_margin: float = None @@ -5104,11 +7107,20 @@ def __call__(self): return "AVAXBTC" -AVAXBTC = AVAXBTC() +AVAXBUSD = AVAXBUSD() @dataclass(slots=True, frozen=True) class AVAXBUSD: + """ + name: AVAXBUSD + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 90000.00000000 + margin: True + """ name: str = "AVAXBUSD" precision: int = 8 minimum_margin: float = None @@ -5127,11 +7139,20 @@ def __call__(self): return "AVAXBUSD" -AVAXBUSD = AVAXBUSD() +AVAXETH = AVAXETH() @dataclass(slots=True, frozen=True) class AVAXETH: + """ + name: AVAXETH + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 92141578.00000000 + margin: False + """ name: str = "AVAXETH" precision: int = 8 minimum_margin: float = None @@ -5150,11 +7171,20 @@ def __call__(self): return "AVAXETH" -AVAXETH = AVAXETH() +AVAXEUR = AVAXEUR() @dataclass(slots=True, frozen=True) class AVAXEUR: + """ + name: AVAXEUR + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 90000.00000000 + margin: False + """ name: str = "AVAXEUR" precision: int = 8 minimum_margin: float = None @@ -5173,11 +7203,20 @@ def __call__(self): return "AVAXEUR" -AVAXEUR = AVAXEUR() +AVAXGBP = AVAXGBP() @dataclass(slots=True, frozen=True) class AVAXGBP: + """ + name: AVAXGBP + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 90000.00000000 + margin: False + """ name: str = "AVAXGBP" precision: int = 8 minimum_margin: float = None @@ -5196,11 +7235,20 @@ def __call__(self): return "AVAXGBP" -AVAXGBP = AVAXGBP() +AVAXTRY = AVAXTRY() @dataclass(slots=True, frozen=True) class AVAXTRY: + """ + name: AVAXTRY + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 922327.00000000 + margin: False + """ name: str = "AVAXTRY" precision: int = 8 minimum_margin: float = None @@ -5219,11 +7267,20 @@ def __call__(self): return "AVAXTRY" -AVAXTRY = AVAXTRY() +AVAXUSDT = AVAXUSDT() @dataclass(slots=True, frozen=True) class AVAXUSDT: + """ + name: AVAXUSDT + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 90000.00000000 + margin: True + """ name: str = "AVAXUSDT" precision: int = 8 minimum_margin: float = None @@ -5242,11 +7299,20 @@ def __call__(self): return "AVAXUSDT" -AVAXUSDT = AVAXUSDT() +AXSAUD = AXSAUD() @dataclass(slots=True, frozen=True) class AXSAUD: + """ + name: AXSAUD + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 922327.00000000 + margin: False + """ name: str = "AXSAUD" precision: int = 8 minimum_margin: float = None @@ -5265,11 +7331,20 @@ def __call__(self): return "AXSAUD" -AXSAUD = AXSAUD() +AXSBIDR = AXSBIDR() @dataclass(slots=True, frozen=True) class AXSBIDR: + """ + name: AXSBIDR + precision: 2 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.00100000 + maximum_order_size: 9223372.00000000 + margin: False + """ name: str = "AXSBIDR" precision: int = 2 minimum_margin: float = None @@ -5288,11 +7363,20 @@ def __call__(self): return "AXSBIDR" -AXSBIDR = AXSBIDR() +AXSBNB = AXSBNB() @dataclass(slots=True, frozen=True) class AXSBNB: + """ + name: AXSBNB + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 9000000.00000000 + margin: False + """ name: str = "AXSBNB" precision: int = 8 minimum_margin: float = None @@ -5311,11 +7395,20 @@ def __call__(self): return "AXSBNB" -AXSBNB = AXSBNB() +AXSBRL = AXSBRL() @dataclass(slots=True, frozen=True) class AXSBRL: + """ + name: AXSBRL + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 922327.00000000 + margin: False + """ name: str = "AXSBRL" precision: int = 8 minimum_margin: float = None @@ -5334,11 +7427,20 @@ def __call__(self): return "AXSBRL" -AXSBRL = AXSBRL() +AXSBTC = AXSBTC() @dataclass(slots=True, frozen=True) class AXSBTC: + """ + name: AXSBTC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 90000000.00000000 + margin: True + """ name: str = "AXSBTC" precision: int = 8 minimum_margin: float = None @@ -5357,11 +7459,20 @@ def __call__(self): return "AXSBTC" -AXSBTC = AXSBTC() +AXSBUSD = AXSBUSD() @dataclass(slots=True, frozen=True) class AXSBUSD: + """ + name: AXSBUSD + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 900000.00000000 + margin: True + """ name: str = "AXSBUSD" precision: int = 8 minimum_margin: float = None @@ -5380,11 +7491,20 @@ def __call__(self): return "AXSBUSD" -AXSBUSD = AXSBUSD() +AXSETH = AXSETH() @dataclass(slots=True, frozen=True) class AXSETH: + """ + name: AXSETH + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.00100000 + maximum_order_size: 92141578.00000000 + margin: False + """ name: str = "AXSETH" precision: int = 8 minimum_margin: float = None @@ -5403,11 +7523,20 @@ def __call__(self): return "AXSETH" -AXSETH = AXSETH() +AXSTRY = AXSTRY() @dataclass(slots=True, frozen=True) class AXSTRY: + """ + name: AXSTRY + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.00100000 + maximum_order_size: 922327.00000000 + margin: False + """ name: str = "AXSTRY" precision: int = 8 minimum_margin: float = None @@ -5426,11 +7555,20 @@ def __call__(self): return "AXSTRY" -AXSTRY = AXSTRY() +AXSUSDT = AXSUSDT() @dataclass(slots=True, frozen=True) class AXSUSDT: + """ + name: AXSUSDT + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 900000.00000000 + margin: True + """ name: str = "AXSUSDT" precision: int = 8 minimum_margin: float = None @@ -5449,11 +7587,20 @@ def __call__(self): return "AXSUSDT" -AXSUSDT = AXSUSDT() +BADGERBTC = BADGERBTC() @dataclass(slots=True, frozen=True) class BADGERBTC: + """ + name: BADGERBTC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 90000000.00000000 + margin: True + """ name: str = "BADGERBTC" precision: int = 8 minimum_margin: float = None @@ -5472,11 +7619,20 @@ def __call__(self): return "BADGERBTC" -BADGERBTC = BADGERBTC() +BADGERBUSD = BADGERBUSD() @dataclass(slots=True, frozen=True) class BADGERBUSD: + """ + name: BADGERBUSD + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 90000.00000000 + margin: True + """ name: str = "BADGERBUSD" precision: int = 8 minimum_margin: float = None @@ -5495,11 +7651,20 @@ def __call__(self): return "BADGERBUSD" -BADGERBUSD = BADGERBUSD() +BADGERUSDT = BADGERUSDT() @dataclass(slots=True, frozen=True) class BADGERUSDT: + """ + name: BADGERUSDT + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 90000.00000000 + margin: True + """ name: str = "BADGERUSDT" precision: int = 8 minimum_margin: float = None @@ -5518,11 +7683,20 @@ def __call__(self): return "BADGERUSDT" -BADGERUSDT = BADGERUSDT() +BAKEBNB = BAKEBNB() @dataclass(slots=True, frozen=True) class BAKEBNB: + """ + name: BAKEBNB + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 9000000.00000000 + margin: False + """ name: str = "BAKEBNB" precision: int = 8 minimum_margin: float = None @@ -5541,11 +7715,20 @@ def __call__(self): return "BAKEBNB" -BAKEBNB = BAKEBNB() +BAKEBTC = BAKEBTC() @dataclass(slots=True, frozen=True) class BAKEBTC: + """ + name: BAKEBTC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 92141578.00000000 + margin: True + """ name: str = "BAKEBTC" precision: int = 8 minimum_margin: float = None @@ -5564,11 +7747,20 @@ def __call__(self): return "BAKEBTC" -BAKEBTC = BAKEBTC() +BAKEBUSD = BAKEBUSD() @dataclass(slots=True, frozen=True) class BAKEBUSD: + """ + name: BAKEBUSD + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 900000.00000000 + margin: True + """ name: str = "BAKEBUSD" precision: int = 8 minimum_margin: float = None @@ -5587,11 +7779,20 @@ def __call__(self): return "BAKEBUSD" -BAKEBUSD = BAKEBUSD() +BAKEUSDT = BAKEUSDT() @dataclass(slots=True, frozen=True) class BAKEUSDT: + """ + name: BAKEUSDT + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 9222449.00000000 + margin: True + """ name: str = "BAKEUSDT" precision: int = 8 minimum_margin: float = None @@ -5610,11 +7811,20 @@ def __call__(self): return "BAKEUSDT" -BAKEUSDT = BAKEUSDT() +BALBNB = BALBNB() @dataclass(slots=True, frozen=True) class BALBNB: + """ + name: BALBNB + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 900000.00000000 + margin: False + """ name: str = "BALBNB" precision: int = 8 minimum_margin: float = None @@ -5633,11 +7843,20 @@ def __call__(self): return "BALBNB" -BALBNB = BALBNB() +BALBTC = BALBTC() @dataclass(slots=True, frozen=True) class BALBTC: + """ + name: BALBTC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 90000000.00000000 + margin: True + """ name: str = "BALBTC" precision: int = 8 minimum_margin: float = None @@ -5656,11 +7875,20 @@ def __call__(self): return "BALBTC" -BALBTC = BALBTC() +BALBUSD = BALBUSD() @dataclass(slots=True, frozen=True) class BALBUSD: + """ + name: BALBUSD + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 90000.00000000 + margin: False + """ name: str = "BALBUSD" precision: int = 8 minimum_margin: float = None @@ -5679,11 +7907,20 @@ def __call__(self): return "BALBUSD" -BALBUSD = BALBUSD() +BALUSDT = BALUSDT() @dataclass(slots=True, frozen=True) class BALUSDT: + """ + name: BALUSDT + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 90000.00000000 + margin: True + """ name: str = "BALUSDT" precision: int = 8 minimum_margin: float = None @@ -5702,11 +7939,20 @@ def __call__(self): return "BALUSDT" -BALUSDT = BALUSDT() +BANDBNB = BANDBNB() @dataclass(slots=True, frozen=True) class BANDBNB: + """ + name: BANDBNB + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 9000000.00000000 + margin: False + """ name: str = "BANDBNB" precision: int = 8 minimum_margin: float = None @@ -5725,11 +7971,20 @@ def __call__(self): return "BANDBNB" -BANDBNB = BANDBNB() +BANDBTC = BANDBTC() @dataclass(slots=True, frozen=True) class BANDBTC: + """ + name: BANDBTC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 90000000.00000000 + margin: True + """ name: str = "BANDBTC" precision: int = 8 minimum_margin: float = None @@ -5748,11 +8003,20 @@ def __call__(self): return "BANDBTC" -BANDBTC = BANDBTC() +BANDBUSD = BANDBUSD() @dataclass(slots=True, frozen=True) class BANDBUSD: + """ + name: BANDBUSD + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 90000.00000000 + margin: False + """ name: str = "BANDBUSD" precision: int = 8 minimum_margin: float = None @@ -5771,11 +8035,20 @@ def __call__(self): return "BANDBUSD" -BANDBUSD = BANDBUSD() +BANDUSDT = BANDUSDT() @dataclass(slots=True, frozen=True) class BANDUSDT: + """ + name: BANDUSDT + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 90000.00000000 + margin: True + """ name: str = "BANDUSDT" precision: int = 8 minimum_margin: float = None @@ -5794,11 +8067,20 @@ def __call__(self): return "BANDUSDT" -BANDUSDT = BANDUSDT() +BARBTC = BARBTC() @dataclass(slots=True, frozen=True) class BARBTC: + """ + name: BARBTC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 90000000.00000000 + margin: False + """ name: str = "BARBTC" precision: int = 8 minimum_margin: float = None @@ -5817,11 +8099,20 @@ def __call__(self): return "BARBTC" -BARBTC = BARBTC() +BARBUSD = BARBUSD() @dataclass(slots=True, frozen=True) class BARBUSD: + """ + name: BARBUSD + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 90000.00000000 + margin: False + """ name: str = "BARBUSD" precision: int = 8 minimum_margin: float = None @@ -5840,11 +8131,20 @@ def __call__(self): return "BARBUSD" -BARBUSD = BARBUSD() +BARUSDT = BARUSDT() @dataclass(slots=True, frozen=True) class BARUSDT: + """ + name: BARUSDT + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 90000.00000000 + margin: False + """ name: str = "BARUSDT" precision: int = 8 minimum_margin: float = None @@ -5863,11 +8163,20 @@ def __call__(self): return "BARUSDT" -BARUSDT = BARUSDT() +BATBNB = BATBNB() @dataclass(slots=True, frozen=True) class BATBNB: + """ + name: BATBNB + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 9000000.00000000 + margin: False + """ name: str = "BATBNB" precision: int = 8 minimum_margin: float = None @@ -5886,11 +8195,20 @@ def __call__(self): return "BATBNB" -BATBNB = BATBNB() +BATBTC = BATBTC() @dataclass(slots=True, frozen=True) class BATBTC: + """ + name: BATBTC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 90000000.00000000 + margin: True + """ name: str = "BATBTC" precision: int = 8 minimum_margin: float = None @@ -5909,11 +8227,20 @@ def __call__(self): return "BATBTC" -BATBTC = BATBTC() +BATBUSD = BATBUSD() @dataclass(slots=True, frozen=True) class BATBUSD: + """ + name: BATBUSD + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 900000.00000000 + margin: True + """ name: str = "BATBUSD" precision: int = 8 minimum_margin: float = None @@ -5932,11 +8259,20 @@ def __call__(self): return "BATBUSD" -BATBUSD = BATBUSD() +BATETH = BATETH() @dataclass(slots=True, frozen=True) class BATETH: + """ + name: BATETH + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 90000000.00000000 + margin: False + """ name: str = "BATETH" precision: int = 8 minimum_margin: float = None @@ -5955,11 +8291,20 @@ def __call__(self): return "BATETH" -BATETH = BATETH() +BATPAX = BATPAX() @dataclass(slots=True, frozen=True) class BATPAX: + """ + name: BATPAX + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 900000.00000000 + margin: False + """ name: str = "BATPAX" precision: int = 8 minimum_margin: float = None @@ -5978,11 +8323,20 @@ def __call__(self): return "BATPAX" -BATPAX = BATPAX() +BATTUSD = BATTUSD() @dataclass(slots=True, frozen=True) class BATTUSD: + """ + name: BATTUSD + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 900000.00000000 + margin: False + """ name: str = "BATTUSD" precision: int = 8 minimum_margin: float = None @@ -6001,11 +8355,20 @@ def __call__(self): return "BATTUSD" -BATTUSD = BATTUSD() +BATUSDC = BATUSDC() @dataclass(slots=True, frozen=True) class BATUSDC: + """ + name: BATUSDC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 900000.00000000 + margin: False + """ name: str = "BATUSDC" precision: int = 8 minimum_margin: float = None @@ -6024,11 +8387,20 @@ def __call__(self): return "BATUSDC" -BATUSDC = BATUSDC() +BATUSDT = BATUSDT() @dataclass(slots=True, frozen=True) class BATUSDT: + """ + name: BATUSDT + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 900000.00000000 + margin: True + """ name: str = "BATUSDT" precision: int = 8 minimum_margin: float = None @@ -6047,11 +8419,20 @@ def __call__(self): return "BATUSDT" -BATUSDT = BATUSDT() +BCCBNB = BCCBNB() @dataclass(slots=True, frozen=True) class BCCBNB: + """ + name: BCCBNB + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.00001000 + maximum_order_size: 900000.00000000 + margin: False + """ name: str = "BCCBNB" precision: int = 8 minimum_margin: float = None @@ -6070,11 +8451,20 @@ def __call__(self): return "BCCBNB" -BCCBNB = BCCBNB() +BCCBTC = BCCBTC() @dataclass(slots=True, frozen=True) class BCCBTC: + """ + name: BCCBTC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.00100000 + maximum_order_size: 92141578.00000000 + margin: False + """ name: str = "BCCBTC" precision: int = 8 minimum_margin: float = None @@ -6093,11 +8483,20 @@ def __call__(self): return "BCCBTC" -BCCBTC = BCCBTC() +BCCETH = BCCETH() @dataclass(slots=True, frozen=True) class BCCETH: + """ + name: BCCETH + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.00100000 + maximum_order_size: 9000000.00000000 + margin: False + """ name: str = "BCCETH" precision: int = 8 minimum_margin: float = None @@ -6116,11 +8515,20 @@ def __call__(self): return "BCCETH" -BCCETH = BCCETH() +BCCUSDT = BCCUSDT() @dataclass(slots=True, frozen=True) class BCCUSDT: + """ + name: BCCUSDT + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.00001000 + maximum_order_size: 90000.00000000 + margin: False + """ name: str = "BCCUSDT" precision: int = 8 minimum_margin: float = None @@ -6139,11 +8547,20 @@ def __call__(self): return "BCCUSDT" -BCCUSDT = BCCUSDT() +BCDBTC = BCDBTC() @dataclass(slots=True, frozen=True) class BCDBTC: + """ + name: BCDBTC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 90000000.00000000 + margin: False + """ name: str = "BCDBTC" precision: int = 8 minimum_margin: float = None @@ -6162,11 +8579,20 @@ def __call__(self): return "BCDBTC" -BCDBTC = BCDBTC() +BCDETH = BCDETH() @dataclass(slots=True, frozen=True) class BCDETH: + """ + name: BCDETH + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.00100000 + maximum_order_size: 9000000.00000000 + margin: False + """ name: str = "BCDETH" precision: int = 8 minimum_margin: float = None @@ -6185,11 +8611,20 @@ def __call__(self): return "BCDETH" -BCDETH = BCDETH() +BCHABCBTC = BCHABCBTC() @dataclass(slots=True, frozen=True) class BCHABCBTC: + """ + name: BCHABCBTC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.00100000 + maximum_order_size: 10000000.00000000 + margin: False + """ name: str = "BCHABCBTC" precision: int = 8 minimum_margin: float = None @@ -6208,11 +8643,20 @@ def __call__(self): return "BCHABCBTC" -BCHABCBTC = BCHABCBTC() +BCHABCBUSD = BCHABCBUSD() @dataclass(slots=True, frozen=True) class BCHABCBUSD: + """ + name: BCHABCBUSD + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.00001000 + maximum_order_size: 90000.00000000 + margin: False + """ name: str = "BCHABCBUSD" precision: int = 8 minimum_margin: float = None @@ -6231,11 +8675,20 @@ def __call__(self): return "BCHABCBUSD" -BCHABCBUSD = BCHABCBUSD() +BCHABCPAX = BCHABCPAX() @dataclass(slots=True, frozen=True) class BCHABCPAX: + """ + name: BCHABCPAX + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.00001000 + maximum_order_size: 90000.00000000 + margin: False + """ name: str = "BCHABCPAX" precision: int = 8 minimum_margin: float = None @@ -6254,11 +8707,20 @@ def __call__(self): return "BCHABCPAX" -BCHABCPAX = BCHABCPAX() +BCHABCTUSD = BCHABCTUSD() @dataclass(slots=True, frozen=True) class BCHABCTUSD: + """ + name: BCHABCTUSD + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.00001000 + maximum_order_size: 90000.00000000 + margin: False + """ name: str = "BCHABCTUSD" precision: int = 8 minimum_margin: float = None @@ -6277,11 +8739,20 @@ def __call__(self): return "BCHABCTUSD" -BCHABCTUSD = BCHABCTUSD() +BCHABCUSDC = BCHABCUSDC() @dataclass(slots=True, frozen=True) class BCHABCUSDC: + """ + name: BCHABCUSDC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.00001000 + maximum_order_size: 90000.00000000 + margin: False + """ name: str = "BCHABCUSDC" precision: int = 8 minimum_margin: float = None @@ -6300,11 +8771,20 @@ def __call__(self): return "BCHABCUSDC" -BCHABCUSDC = BCHABCUSDC() +BCHABCUSDT = BCHABCUSDT() @dataclass(slots=True, frozen=True) class BCHABCUSDT: + """ + name: BCHABCUSDT + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.00001000 + maximum_order_size: 90000.00000000 + margin: False + """ name: str = "BCHABCUSDT" precision: int = 8 minimum_margin: float = None @@ -6323,11 +8803,20 @@ def __call__(self): return "BCHABCUSDT" -BCHABCUSDT = BCHABCUSDT() +BCHABUSD = BCHABUSD() @dataclass(slots=True, frozen=True) class BCHABUSD: + """ + name: BCHABUSD + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.00100000 + maximum_order_size: 90000.00000000 + margin: False + """ name: str = "BCHABUSD" precision: int = 8 minimum_margin: float = None @@ -6346,11 +8835,20 @@ def __call__(self): return "BCHABUSD" -BCHABUSD = BCHABUSD() +BCHBNB = BCHBNB() @dataclass(slots=True, frozen=True) class BCHBNB: + """ + name: BCHBNB + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.00100000 + maximum_order_size: 900000.00000000 + margin: False + """ name: str = "BCHBNB" precision: int = 8 minimum_margin: float = None @@ -6369,11 +8867,20 @@ def __call__(self): return "BCHBNB" -BCHBNB = BCHBNB() +BCHBTC = BCHBTC() @dataclass(slots=True, frozen=True) class BCHBTC: + """ + name: BCHBTC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.00100000 + maximum_order_size: 10000000.00000000 + margin: True + """ name: str = "BCHBTC" precision: int = 8 minimum_margin: float = None @@ -6392,11 +8899,20 @@ def __call__(self): return "BCHBTC" -BCHBTC = BCHBTC() +BCHBUSD = BCHBUSD() @dataclass(slots=True, frozen=True) class BCHBUSD: + """ + name: BCHBUSD + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.00100000 + maximum_order_size: 90000.00000000 + margin: True + """ name: str = "BCHBUSD" precision: int = 8 minimum_margin: float = None @@ -6415,11 +8931,20 @@ def __call__(self): return "BCHBUSD" -BCHBUSD = BCHBUSD() +BCHDOWNUSDT = BCHDOWNUSDT() @dataclass(slots=True, frozen=True) class BCHDOWNUSDT: + """ + name: BCHDOWNUSDT + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 920000.00000000 + margin: False + """ name: str = "BCHDOWNUSDT" precision: int = 8 minimum_margin: float = None @@ -6438,11 +8963,20 @@ def __call__(self): return "BCHDOWNUSDT" -BCHDOWNUSDT = BCHDOWNUSDT() +BCHEUR = BCHEUR() @dataclass(slots=True, frozen=True) class BCHEUR: + """ + name: BCHEUR + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.00100000 + maximum_order_size: 90000.00000000 + margin: False + """ name: str = "BCHEUR" precision: int = 8 minimum_margin: float = None @@ -6461,11 +8995,20 @@ def __call__(self): return "BCHEUR" -BCHEUR = BCHEUR() +BCHPAX = BCHPAX() @dataclass(slots=True, frozen=True) class BCHPAX: + """ + name: BCHPAX + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.00001000 + maximum_order_size: 90000.00000000 + margin: False + """ name: str = "BCHPAX" precision: int = 8 minimum_margin: float = None @@ -6484,11 +9027,20 @@ def __call__(self): return "BCHPAX" -BCHPAX = BCHPAX() +BCHSVBTC = BCHSVBTC() @dataclass(slots=True, frozen=True) class BCHSVBTC: + """ + name: BCHSVBTC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.00100000 + maximum_order_size: 10000000.00000000 + margin: False + """ name: str = "BCHSVBTC" precision: int = 8 minimum_margin: float = None @@ -6507,11 +9059,20 @@ def __call__(self): return "BCHSVBTC" -BCHSVBTC = BCHSVBTC() +BCHSVPAX = BCHSVPAX() @dataclass(slots=True, frozen=True) class BCHSVPAX: + """ + name: BCHSVPAX + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.00001000 + maximum_order_size: 90000.00000000 + margin: False + """ name: str = "BCHSVPAX" precision: int = 8 minimum_margin: float = None @@ -6530,11 +9091,20 @@ def __call__(self): return "BCHSVPAX" -BCHSVPAX = BCHSVPAX() +BCHSVTUSD = BCHSVTUSD() @dataclass(slots=True, frozen=True) class BCHSVTUSD: + """ + name: BCHSVTUSD + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.00001000 + maximum_order_size: 90000.00000000 + margin: False + """ name: str = "BCHSVTUSD" precision: int = 8 minimum_margin: float = None @@ -6553,11 +9123,20 @@ def __call__(self): return "BCHSVTUSD" -BCHSVTUSD = BCHSVTUSD() +BCHSVUSDC = BCHSVUSDC() @dataclass(slots=True, frozen=True) class BCHSVUSDC: + """ + name: BCHSVUSDC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.00001000 + maximum_order_size: 90000.00000000 + margin: False + """ name: str = "BCHSVUSDC" precision: int = 8 minimum_margin: float = None @@ -6576,11 +9155,20 @@ def __call__(self): return "BCHSVUSDC" -BCHSVUSDC = BCHSVUSDC() +BCHSVUSDT = BCHSVUSDT() @dataclass(slots=True, frozen=True) class BCHSVUSDT: + """ + name: BCHSVUSDT + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.00001000 + maximum_order_size: 92141578.00000000 + margin: False + """ name: str = "BCHSVUSDT" precision: int = 8 minimum_margin: float = None @@ -6599,11 +9187,20 @@ def __call__(self): return "BCHSVUSDT" -BCHSVUSDT = BCHSVUSDT() +BCHTUSD = BCHTUSD() @dataclass(slots=True, frozen=True) class BCHTUSD: + """ + name: BCHTUSD + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.00100000 + maximum_order_size: 90000.00000000 + margin: False + """ name: str = "BCHTUSD" precision: int = 8 minimum_margin: float = None @@ -6622,11 +9219,20 @@ def __call__(self): return "BCHTUSD" -BCHTUSD = BCHTUSD() +BCHUPUSDT = BCHUPUSDT() @dataclass(slots=True, frozen=True) class BCHUPUSDT: + """ + name: BCHUPUSDT + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 920000.00000000 + margin: False + """ name: str = "BCHUPUSDT" precision: int = 8 minimum_margin: float = None @@ -6645,11 +9251,20 @@ def __call__(self): return "BCHUPUSDT" -BCHUPUSDT = BCHUPUSDT() +BCHUSDC = BCHUSDC() @dataclass(slots=True, frozen=True) class BCHUSDC: + """ + name: BCHUSDC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.00100000 + maximum_order_size: 90000.00000000 + margin: False + """ name: str = "BCHUSDC" precision: int = 8 minimum_margin: float = None @@ -6668,11 +9283,20 @@ def __call__(self): return "BCHUSDC" -BCHUSDC = BCHUSDC() +BCHUSDT = BCHUSDT() @dataclass(slots=True, frozen=True) class BCHUSDT: + """ + name: BCHUSDT + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.00100000 + maximum_order_size: 90000.00000000 + margin: True + """ name: str = "BCHUSDT" precision: int = 8 minimum_margin: float = None @@ -6691,11 +9315,20 @@ def __call__(self): return "BCHUSDT" -BCHUSDT = BCHUSDT() +BCNBNB = BCNBNB() @dataclass(slots=True, frozen=True) class BCNBNB: + """ + name: BCNBNB + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 9000000.00000000 + margin: False + """ name: str = "BCNBNB" precision: int = 8 minimum_margin: float = None @@ -6714,11 +9347,20 @@ def __call__(self): return "BCNBNB" -BCNBNB = BCNBNB() +BCNBTC = BCNBTC() @dataclass(slots=True, frozen=True) class BCNBTC: + """ + name: BCNBTC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 90000000.00000000 + margin: False + """ name: str = "BCNBTC" precision: int = 8 minimum_margin: float = None @@ -6737,11 +9379,20 @@ def __call__(self): return "BCNBTC" -BCNBTC = BCNBTC() +BCNETH = BCNETH() @dataclass(slots=True, frozen=True) class BCNETH: + """ + name: BCNETH + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 90000000.00000000 + margin: False + """ name: str = "BCNETH" precision: int = 8 minimum_margin: float = None @@ -6760,11 +9411,20 @@ def __call__(self): return "BCNETH" -BCNETH = BCNETH() +BCPTBNB = BCPTBNB() @dataclass(slots=True, frozen=True) class BCPTBNB: + """ + name: BCPTBNB + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 9000000.00000000 + margin: False + """ name: str = "BCPTBNB" precision: int = 8 minimum_margin: float = None @@ -6783,11 +9443,20 @@ def __call__(self): return "BCPTBNB" -BCPTBNB = BCPTBNB() +BCPTBTC = BCPTBTC() @dataclass(slots=True, frozen=True) class BCPTBTC: + """ + name: BCPTBTC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 90000000.00000000 + margin: False + """ name: str = "BCPTBTC" precision: int = 8 minimum_margin: float = None @@ -6806,11 +9475,20 @@ def __call__(self): return "BCPTBTC" -BCPTBTC = BCPTBTC() +BCPTETH = BCPTETH() @dataclass(slots=True, frozen=True) class BCPTETH: + """ + name: BCPTETH + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 90000000.00000000 + margin: False + """ name: str = "BCPTETH" precision: int = 8 minimum_margin: float = None @@ -6829,11 +9507,20 @@ def __call__(self): return "BCPTETH" -BCPTETH = BCPTETH() +BCPTPAX = BCPTPAX() @dataclass(slots=True, frozen=True) class BCPTPAX: + """ + name: BCPTPAX + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 9000000.00000000 + margin: False + """ name: str = "BCPTPAX" precision: int = 8 minimum_margin: float = None @@ -6852,11 +9539,20 @@ def __call__(self): return "BCPTPAX" -BCPTPAX = BCPTPAX() +BCPTTUSD = BCPTTUSD() @dataclass(slots=True, frozen=True) class BCPTTUSD: + """ + name: BCPTTUSD + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 9000000.00000000 + margin: False + """ name: str = "BCPTTUSD" precision: int = 8 minimum_margin: float = None @@ -6875,11 +9571,20 @@ def __call__(self): return "BCPTTUSD" -BCPTTUSD = BCPTTUSD() +BCPTUSDC = BCPTUSDC() @dataclass(slots=True, frozen=True) class BCPTUSDC: + """ + name: BCPTUSDC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 9000000.00000000 + margin: False + """ name: str = "BCPTUSDC" precision: int = 8 minimum_margin: float = None @@ -6898,11 +9603,20 @@ def __call__(self): return "BCPTUSDC" -BCPTUSDC = BCPTUSDC() +BDOTDOT = BDOTDOT() @dataclass(slots=True, frozen=True) class BDOTDOT: + """ + name: BDOTDOT + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.00100000 + maximum_order_size: 92141578.00000000 + margin: False + """ name: str = "BDOTDOT" precision: int = 8 minimum_margin: float = None @@ -6921,11 +9635,20 @@ def __call__(self): return "BDOTDOT" -BDOTDOT = BDOTDOT() +BEAMBNB = BEAMBNB() @dataclass(slots=True, frozen=True) class BEAMBNB: + """ + name: BEAMBNB + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 9000000.00000000 + margin: False + """ name: str = "BEAMBNB" precision: int = 8 minimum_margin: float = None @@ -6944,11 +9667,20 @@ def __call__(self): return "BEAMBNB" -BEAMBNB = BEAMBNB() +BEAMBTC = BEAMBTC() @dataclass(slots=True, frozen=True) class BEAMBTC: + """ + name: BEAMBTC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 9000000.00000000 + margin: False + """ name: str = "BEAMBTC" precision: int = 8 minimum_margin: float = None @@ -6967,11 +9699,20 @@ def __call__(self): return "BEAMBTC" -BEAMBTC = BEAMBTC() +BEAMUSDT = BEAMUSDT() @dataclass(slots=True, frozen=True) class BEAMUSDT: + """ + name: BEAMUSDT + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 900000.00000000 + margin: False + """ name: str = "BEAMUSDT" precision: int = 8 minimum_margin: float = None @@ -6990,11 +9731,20 @@ def __call__(self): return "BEAMUSDT" -BEAMUSDT = BEAMUSDT() +BEARBUSD = BEARBUSD() @dataclass(slots=True, frozen=True) class BEARBUSD: + """ + name: BEARBUSD + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.00001000 + maximum_order_size: 90000.00000000 + margin: False + """ name: str = "BEARBUSD" precision: int = 8 minimum_margin: float = None @@ -7013,11 +9763,20 @@ def __call__(self): return "BEARBUSD" -BEARBUSD = BEARBUSD() +BEARUSDT = BEARUSDT() @dataclass(slots=True, frozen=True) class BEARUSDT: + """ + name: BEARUSDT + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.00001000 + maximum_order_size: 90000.00000000 + margin: False + """ name: str = "BEARUSDT" precision: int = 8 minimum_margin: float = None @@ -7036,11 +9795,20 @@ def __call__(self): return "BEARUSDT" -BEARUSDT = BEARUSDT() +BELBNB = BELBNB() @dataclass(slots=True, frozen=True) class BELBNB: + """ + name: BELBNB + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 9000000.00000000 + margin: False + """ name: str = "BELBNB" precision: int = 8 minimum_margin: float = None @@ -7059,11 +9827,20 @@ def __call__(self): return "BELBNB" -BELBNB = BELBNB() +BELBTC = BELBTC() @dataclass(slots=True, frozen=True) class BELBTC: + """ + name: BELBTC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 90000000.00000000 + margin: False + """ name: str = "BELBTC" precision: int = 8 minimum_margin: float = None @@ -7082,11 +9859,20 @@ def __call__(self): return "BELBTC" -BELBTC = BELBTC() +BELBUSD = BELBUSD() @dataclass(slots=True, frozen=True) class BELBUSD: + """ + name: BELBUSD + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 900000.00000000 + margin: True + """ name: str = "BELBUSD" precision: int = 8 minimum_margin: float = None @@ -7105,11 +9891,20 @@ def __call__(self): return "BELBUSD" -BELBUSD = BELBUSD() +BELETH = BELETH() @dataclass(slots=True, frozen=True) class BELETH: + """ + name: BELETH + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 92141578.00000000 + margin: False + """ name: str = "BELETH" precision: int = 8 minimum_margin: float = None @@ -7128,11 +9923,20 @@ def __call__(self): return "BELETH" -BELETH = BELETH() +BELTRY = BELTRY() @dataclass(slots=True, frozen=True) class BELTRY: + """ + name: BELTRY + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 9222449.00000000 + margin: False + """ name: str = "BELTRY" precision: int = 8 minimum_margin: float = None @@ -7151,11 +9955,20 @@ def __call__(self): return "BELTRY" -BELTRY = BELTRY() +BELUSDT = BELUSDT() @dataclass(slots=True, frozen=True) class BELUSDT: + """ + name: BELUSDT + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 900000.00000000 + margin: True + """ name: str = "BELUSDT" precision: int = 8 minimum_margin: float = None @@ -7174,11 +9987,20 @@ def __call__(self): return "BELUSDT" -BELUSDT = BELUSDT() +BETABNB = BETABNB() @dataclass(slots=True, frozen=True) class BETABNB: + """ + name: BETABNB + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 92141578.00000000 + margin: False + """ name: str = "BETABNB" precision: int = 8 minimum_margin: float = None @@ -7197,11 +10019,20 @@ def __call__(self): return "BETABNB" -BETABNB = BETABNB() +BETABTC = BETABTC() @dataclass(slots=True, frozen=True) class BETABTC: + """ + name: BETABTC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 92141578.00000000 + margin: False + """ name: str = "BETABTC" precision: int = 8 minimum_margin: float = None @@ -7220,11 +10051,20 @@ def __call__(self): return "BETABTC" -BETABTC = BETABTC() +BETABUSD = BETABUSD() @dataclass(slots=True, frozen=True) class BETABUSD: + """ + name: BETABUSD + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 92141578.00000000 + margin: False + """ name: str = "BETABUSD" precision: int = 8 minimum_margin: float = None @@ -7243,11 +10083,20 @@ def __call__(self): return "BETABUSD" -BETABUSD = BETABUSD() +BETAETH = BETAETH() @dataclass(slots=True, frozen=True) class BETAETH: + """ + name: BETAETH + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 92141578.00000000 + margin: False + """ name: str = "BETAETH" precision: int = 8 minimum_margin: float = None @@ -7266,11 +10115,20 @@ def __call__(self): return "BETAETH" -BETAETH = BETAETH() +BETAUSDT = BETAUSDT() @dataclass(slots=True, frozen=True) class BETAUSDT: + """ + name: BETAUSDT + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 92141578.00000000 + margin: True + """ name: str = "BETAUSDT" precision: int = 8 minimum_margin: float = None @@ -7289,11 +10147,20 @@ def __call__(self): return "BETAUSDT" -BETAUSDT = BETAUSDT() +BETHBUSD = BETHBUSD() @dataclass(slots=True, frozen=True) class BETHBUSD: + """ + name: BETHBUSD + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.00010000 + maximum_order_size: 9000.00000000 + margin: False + """ name: str = "BETHBUSD" precision: int = 8 minimum_margin: float = None @@ -7312,11 +10179,20 @@ def __call__(self): return "BETHBUSD" -BETHBUSD = BETHBUSD() +BETHETH = BETHETH() @dataclass(slots=True, frozen=True) class BETHETH: + """ + name: BETHETH + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.00010000 + maximum_order_size: 92141578.00000000 + margin: False + """ name: str = "BETHETH" precision: int = 8 minimum_margin: float = None @@ -7335,11 +10211,20 @@ def __call__(self): return "BETHETH" -BETHETH = BETHETH() +BGBPUSDC = BGBPUSDC() @dataclass(slots=True, frozen=True) class BGBPUSDC: + """ + name: BGBPUSDC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 900000.00000000 + margin: False + """ name: str = "BGBPUSDC" precision: int = 8 minimum_margin: float = None @@ -7358,11 +10243,20 @@ def __call__(self): return "BGBPUSDC" -BGBPUSDC = BGBPUSDC() +BICOBTC = BICOBTC() @dataclass(slots=True, frozen=True) class BICOBTC: + """ + name: BICOBTC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 92141578.00000000 + margin: True + """ name: str = "BICOBTC" precision: int = 8 minimum_margin: float = None @@ -7381,11 +10275,20 @@ def __call__(self): return "BICOBTC" -BICOBTC = BICOBTC() +BICOBUSD = BICOBUSD() @dataclass(slots=True, frozen=True) class BICOBUSD: + """ + name: BICOBUSD + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 92141578.00000000 + margin: True + """ name: str = "BICOBUSD" precision: int = 8 minimum_margin: float = None @@ -7404,11 +10307,20 @@ def __call__(self): return "BICOBUSD" -BICOBUSD = BICOBUSD() +BICOUSDT = BICOUSDT() @dataclass(slots=True, frozen=True) class BICOUSDT: + """ + name: BICOUSDT + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 92141578.00000000 + margin: True + """ name: str = "BICOUSDT" precision: int = 8 minimum_margin: float = None @@ -7427,11 +10339,20 @@ def __call__(self): return "BICOUSDT" -BICOUSDT = BICOUSDT() +BIFIBNB = BIFIBNB() @dataclass(slots=True, frozen=True) class BIFIBNB: + """ + name: BIFIBNB + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.00100000 + maximum_order_size: 900000.00000000 + margin: False + """ name: str = "BIFIBNB" precision: int = 8 minimum_margin: float = None @@ -7450,11 +10371,20 @@ def __call__(self): return "BIFIBNB" -BIFIBNB = BIFIBNB() +BIFIBUSD = BIFIBUSD() @dataclass(slots=True, frozen=True) class BIFIBUSD: + """ + name: BIFIBUSD + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.00100000 + maximum_order_size: 90000.00000000 + margin: False + """ name: str = "BIFIBUSD" precision: int = 8 minimum_margin: float = None @@ -7473,11 +10403,20 @@ def __call__(self): return "BIFIBUSD" -BIFIBUSD = BIFIBUSD() +BIFIUSDT = BIFIUSDT() @dataclass(slots=True, frozen=True) class BIFIUSDT: + """ + name: BIFIUSDT + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.00100000 + maximum_order_size: 90000.00000000 + margin: False + """ name: str = "BIFIUSDT" precision: int = 8 minimum_margin: float = None @@ -7496,11 +10435,20 @@ def __call__(self): return "BIFIUSDT" -BIFIUSDT = BIFIUSDT() +BKRWBUSD = BKRWBUSD() @dataclass(slots=True, frozen=True) class BKRWBUSD: + """ + name: BKRWBUSD + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 90000000.00000000 + margin: False + """ name: str = "BKRWBUSD" precision: int = 8 minimum_margin: float = None @@ -7519,11 +10467,20 @@ def __call__(self): return "BKRWBUSD" -BKRWBUSD = BKRWBUSD() +BKRWUSDT = BKRWUSDT() @dataclass(slots=True, frozen=True) class BKRWUSDT: + """ + name: BKRWUSDT + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 90000000.00000000 + margin: False + """ name: str = "BKRWUSDT" precision: int = 8 minimum_margin: float = None @@ -7542,11 +10499,20 @@ def __call__(self): return "BKRWUSDT" -BKRWUSDT = BKRWUSDT() +BLZBNB = BLZBNB() @dataclass(slots=True, frozen=True) class BLZBNB: + """ + name: BLZBNB + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 9000000.00000000 + margin: False + """ name: str = "BLZBNB" precision: int = 8 minimum_margin: float = None @@ -7565,11 +10531,20 @@ def __call__(self): return "BLZBNB" -BLZBNB = BLZBNB() +BLZBTC = BLZBTC() @dataclass(slots=True, frozen=True) class BLZBTC: + """ + name: BLZBTC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 90000000.00000000 + margin: True + """ name: str = "BLZBTC" precision: int = 8 minimum_margin: float = None @@ -7588,11 +10563,20 @@ def __call__(self): return "BLZBTC" -BLZBTC = BLZBTC() +BLZBUSD = BLZBUSD() @dataclass(slots=True, frozen=True) class BLZBUSD: + """ + name: BLZBUSD + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 9000000.00000000 + margin: False + """ name: str = "BLZBUSD" precision: int = 8 minimum_margin: float = None @@ -7611,11 +10595,20 @@ def __call__(self): return "BLZBUSD" -BLZBUSD = BLZBUSD() +BLZETH = BLZETH() @dataclass(slots=True, frozen=True) class BLZETH: + """ + name: BLZETH + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 90000000.00000000 + margin: False + """ name: str = "BLZETH" precision: int = 8 minimum_margin: float = None @@ -7634,11 +10627,20 @@ def __call__(self): return "BLZETH" -BLZETH = BLZETH() +BLZUSDT = BLZUSDT() @dataclass(slots=True, frozen=True) class BLZUSDT: + """ + name: BLZUSDT + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 9000000.00000000 + margin: True + """ name: str = "BLZUSDT" precision: int = 8 minimum_margin: float = None @@ -7657,11 +10659,20 @@ def __call__(self): return "BLZUSDT" -BLZUSDT = BLZUSDT() +BNBAUD = BNBAUD() @dataclass(slots=True, frozen=True) class BNBAUD: + """ + name: BNBAUD + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.00100000 + maximum_order_size: 900000.00000000 + margin: False + """ name: str = "BNBAUD" precision: int = 8 minimum_margin: float = None @@ -7680,11 +10691,20 @@ def __call__(self): return "BNBAUD" -BNBAUD = BNBAUD() +BNBBEARBUSD = BNBBEARBUSD() @dataclass(slots=True, frozen=True) class BNBBEARBUSD: + """ + name: BNBBEARBUSD + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.00001000 + maximum_order_size: 90000.00000000 + margin: False + """ name: str = "BNBBEARBUSD" precision: int = 8 minimum_margin: float = None @@ -7703,11 +10723,20 @@ def __call__(self): return "BNBBEARBUSD" -BNBBEARBUSD = BNBBEARBUSD() +BNBBEARUSDT = BNBBEARUSDT() @dataclass(slots=True, frozen=True) class BNBBEARUSDT: + """ + name: BNBBEARUSDT + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.00001000 + maximum_order_size: 90000.00000000 + margin: False + """ name: str = "BNBBEARUSDT" precision: int = 8 minimum_margin: float = None @@ -7726,11 +10755,20 @@ def __call__(self): return "BNBBEARUSDT" -BNBBEARUSDT = BNBBEARUSDT() +BNBBIDR = BNBBIDR() @dataclass(slots=True, frozen=True) class BNBBIDR: + """ + name: BNBBIDR + precision: 2 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.00100000 + maximum_order_size: 100000.00000000 + margin: False + """ name: str = "BNBBIDR" precision: int = 2 minimum_margin: float = None @@ -7749,11 +10787,20 @@ def __call__(self): return "BNBBIDR" -BNBBIDR = BNBBIDR() +BNBBKRW = BNBBKRW() @dataclass(slots=True, frozen=True) class BNBBKRW: + """ + name: BNBBKRW + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.00100000 + maximum_order_size: 9000.00000000 + margin: False + """ name: str = "BNBBKRW" precision: int = 8 minimum_margin: float = None @@ -7772,11 +10819,20 @@ def __call__(self): return "BNBBKRW" -BNBBKRW = BNBBKRW() +BNBBRL = BNBBRL() @dataclass(slots=True, frozen=True) class BNBBRL: + """ + name: BNBBRL + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.00100000 + maximum_order_size: 45000.00000000 + margin: False + """ name: str = "BNBBRL" precision: int = 8 minimum_margin: float = None @@ -7795,11 +10851,20 @@ def __call__(self): return "BNBBRL" -BNBBRL = BNBBRL() +BNBBTC = BNBBTC() @dataclass(slots=True, frozen=True) class BNBBTC: + """ + name: BNBBTC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.00100000 + maximum_order_size: 100000.00000000 + margin: True + """ name: str = "BNBBTC" precision: int = 8 minimum_margin: float = None @@ -7818,11 +10883,20 @@ def __call__(self): return "BNBBTC" -BNBBTC = BNBBTC() +BNBBULLBUSD = BNBBULLBUSD() @dataclass(slots=True, frozen=True) class BNBBULLBUSD: + """ + name: BNBBULLBUSD + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.00001000 + maximum_order_size: 90000.00000000 + margin: False + """ name: str = "BNBBULLBUSD" precision: int = 8 minimum_margin: float = None @@ -7841,11 +10915,20 @@ def __call__(self): return "BNBBULLBUSD" -BNBBULLBUSD = BNBBULLBUSD() +BNBBULLUSDT = BNBBULLUSDT() @dataclass(slots=True, frozen=True) class BNBBULLUSDT: + """ + name: BNBBULLUSDT + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.00001000 + maximum_order_size: 90000.00000000 + margin: False + """ name: str = "BNBBULLUSDT" precision: int = 8 minimum_margin: float = None @@ -7864,11 +10947,20 @@ def __call__(self): return "BNBBULLUSDT" -BNBBULLUSDT = BNBBULLUSDT() +BNBBUSD = BNBBUSD() @dataclass(slots=True, frozen=True) class BNBBUSD: + """ + name: BNBBUSD + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.00100000 + maximum_order_size: 900000.00000000 + margin: True + """ name: str = "BNBBUSD" precision: int = 8 minimum_margin: float = None @@ -7887,11 +10979,20 @@ def __call__(self): return "BNBBUSD" -BNBBUSD = BNBBUSD() +BNBDAI = BNBDAI() @dataclass(slots=True, frozen=True) class BNBDAI: + """ + name: BNBDAI + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.00100000 + maximum_order_size: 900000.00000000 + margin: False + """ name: str = "BNBDAI" precision: int = 8 minimum_margin: float = None @@ -7910,11 +11011,20 @@ def __call__(self): return "BNBDAI" -BNBDAI = BNBDAI() +BNBDOWNUSDT = BNBDOWNUSDT() @dataclass(slots=True, frozen=True) class BNBDOWNUSDT: + """ + name: BNBDOWNUSDT + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 920000.00000000 + margin: False + """ name: str = "BNBDOWNUSDT" precision: int = 8 minimum_margin: float = None @@ -7933,11 +11043,20 @@ def __call__(self): return "BNBDOWNUSDT" -BNBDOWNUSDT = BNBDOWNUSDT() +BNBETH = BNBETH() @dataclass(slots=True, frozen=True) class BNBETH: + """ + name: BNBETH + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.00100000 + maximum_order_size: 9000000.00000000 + margin: True + """ name: str = "BNBETH" precision: int = 8 minimum_margin: float = None @@ -7956,11 +11075,20 @@ def __call__(self): return "BNBETH" -BNBETH = BNBETH() +BNBEUR = BNBEUR() @dataclass(slots=True, frozen=True) class BNBEUR: + """ + name: BNBEUR + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.00100000 + maximum_order_size: 9222449.00000000 + margin: False + """ name: str = "BNBEUR" precision: int = 8 minimum_margin: float = None @@ -7979,11 +11107,20 @@ def __call__(self): return "BNBEUR" -BNBEUR = BNBEUR() +BNBGBP = BNBGBP() @dataclass(slots=True, frozen=True) class BNBGBP: + """ + name: BNBGBP + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.00100000 + maximum_order_size: 900000.00000000 + margin: False + """ name: str = "BNBGBP" precision: int = 8 minimum_margin: float = None @@ -8002,11 +11139,20 @@ def __call__(self): return "BNBGBP" -BNBGBP = BNBGBP() +BNBIDRT = BNBIDRT() @dataclass(slots=True, frozen=True) class BNBIDRT: + """ + name: BNBIDRT + precision: 2 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.00100000 + maximum_order_size: 100000.00000000 + margin: False + """ name: str = "BNBIDRT" precision: int = 2 minimum_margin: float = None @@ -8025,11 +11171,20 @@ def __call__(self): return "BNBIDRT" -BNBIDRT = BNBIDRT() +BNBNGN = BNBNGN() @dataclass(slots=True, frozen=True) class BNBNGN: + """ + name: BNBNGN + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.00100000 + maximum_order_size: 90000.00000000 + margin: False + """ name: str = "BNBNGN" precision: int = 8 minimum_margin: float = None @@ -8048,11 +11203,20 @@ def __call__(self): return "BNBNGN" -BNBNGN = BNBNGN() +BNBPAX = BNBPAX() @dataclass(slots=True, frozen=True) class BNBPAX: + """ + name: BNBPAX + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.00100000 + maximum_order_size: 9222449.00000000 + margin: False + """ name: str = "BNBPAX" precision: int = 8 minimum_margin: float = None @@ -8071,11 +11235,20 @@ def __call__(self): return "BNBPAX" -BNBPAX = BNBPAX() +BNBRUB = BNBRUB() @dataclass(slots=True, frozen=True) class BNBRUB: + """ + name: BNBRUB + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.00100000 + maximum_order_size: 184466.00000000 + margin: False + """ name: str = "BNBRUB" precision: int = 8 minimum_margin: float = None @@ -8094,11 +11267,20 @@ def __call__(self): return "BNBRUB" -BNBRUB = BNBRUB() +BNBTRY = BNBTRY() @dataclass(slots=True, frozen=True) class BNBTRY: + """ + name: BNBTRY + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.00100000 + maximum_order_size: 92232.00000000 + margin: False + """ name: str = "BNBTRY" precision: int = 8 minimum_margin: float = None @@ -8117,11 +11299,20 @@ def __call__(self): return "BNBTRY" -BNBTRY = BNBTRY() +BNBTUSD = BNBTUSD() @dataclass(slots=True, frozen=True) class BNBTUSD: + """ + name: BNBTUSD + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.00100000 + maximum_order_size: 9222449.00000000 + margin: False + """ name: str = "BNBTUSD" precision: int = 8 minimum_margin: float = None @@ -8140,11 +11331,20 @@ def __call__(self): return "BNBTUSD" -BNBTUSD = BNBTUSD() +BNBUAH = BNBUAH() @dataclass(slots=True, frozen=True) class BNBUAH: + """ + name: BNBUAH + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.00100000 + maximum_order_size: 90000.00000000 + margin: False + """ name: str = "BNBUAH" precision: int = 8 minimum_margin: float = None @@ -8163,11 +11363,20 @@ def __call__(self): return "BNBUAH" -BNBUAH = BNBUAH() +BNBUPUSDT = BNBUPUSDT() @dataclass(slots=True, frozen=True) class BNBUPUSDT: + """ + name: BNBUPUSDT + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 500.00000000 + margin: False + """ name: str = "BNBUPUSDT" precision: int = 8 minimum_margin: float = None @@ -8186,11 +11395,20 @@ def __call__(self): return "BNBUPUSDT" -BNBUPUSDT = BNBUPUSDT() +BNBUSDC = BNBUSDC() @dataclass(slots=True, frozen=True) class BNBUSDC: + """ + name: BNBUSDC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.00100000 + maximum_order_size: 900000.00000000 + margin: False + """ name: str = "BNBUSDC" precision: int = 8 minimum_margin: float = None @@ -8209,11 +11427,20 @@ def __call__(self): return "BNBUSDC" -BNBUSDC = BNBUSDC() +BNBUSDP = BNBUSDP() @dataclass(slots=True, frozen=True) class BNBUSDP: + """ + name: BNBUSDP + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.00100000 + maximum_order_size: 922327.00000000 + margin: False + """ name: str = "BNBUSDP" precision: int = 8 minimum_margin: float = None @@ -8232,11 +11459,20 @@ def __call__(self): return "BNBUSDP" -BNBUSDP = BNBUSDP() +BNBUSDS = BNBUSDS() @dataclass(slots=True, frozen=True) class BNBUSDS: + """ + name: BNBUSDS + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 900000.00000000 + margin: False + """ name: str = "BNBUSDS" precision: int = 8 minimum_margin: float = None @@ -8255,11 +11491,20 @@ def __call__(self): return "BNBUSDS" -BNBUSDS = BNBUSDS() +BNBUSDT = BNBUSDT() @dataclass(slots=True, frozen=True) class BNBUSDT: + """ + name: BNBUSDT + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.00100000 + maximum_order_size: 900000.00000000 + margin: True + """ name: str = "BNBUSDT" precision: int = 8 minimum_margin: float = None @@ -8278,11 +11523,20 @@ def __call__(self): return "BNBUSDT" -BNBUSDT = BNBUSDT() +BNBUST = BNBUST() @dataclass(slots=True, frozen=True) class BNBUST: + """ + name: BNBUST + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.00100000 + maximum_order_size: 922327.00000000 + margin: False + """ name: str = "BNBUST" precision: int = 8 minimum_margin: float = None @@ -8301,11 +11555,20 @@ def __call__(self): return "BNBUST" -BNBUST = BNBUST() +BNBZAR = BNBZAR() @dataclass(slots=True, frozen=True) class BNBZAR: + """ + name: BNBZAR + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 100000.00000000 + margin: False + """ name: str = "BNBZAR" precision: int = 8 minimum_margin: float = None @@ -8324,11 +11587,20 @@ def __call__(self): return "BNBZAR" -BNBZAR = BNBZAR() +BNTBTC = BNTBTC() @dataclass(slots=True, frozen=True) class BNTBTC: + """ + name: BNTBTC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 90000000.00000000 + margin: True + """ name: str = "BNTBTC" precision: int = 8 minimum_margin: float = None @@ -8347,11 +11619,20 @@ def __call__(self): return "BNTBTC" -BNTBTC = BNTBTC() +BNTBUSD = BNTBUSD() @dataclass(slots=True, frozen=True) class BNTBUSD: + """ + name: BNTBUSD + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 900000.00000000 + margin: False + """ name: str = "BNTBUSD" precision: int = 8 minimum_margin: float = None @@ -8370,11 +11651,20 @@ def __call__(self): return "BNTBUSD" -BNTBUSD = BNTBUSD() +BNTETH = BNTETH() @dataclass(slots=True, frozen=True) class BNTETH: + """ + name: BNTETH + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 92141578.00000000 + margin: False + """ name: str = "BNTETH" precision: int = 8 minimum_margin: float = None @@ -8393,11 +11683,20 @@ def __call__(self): return "BNTETH" -BNTETH = BNTETH() +BNTUSDT = BNTUSDT() @dataclass(slots=True, frozen=True) class BNTUSDT: + """ + name: BNTUSDT + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 900000.00000000 + margin: True + """ name: str = "BNTUSDT" precision: int = 8 minimum_margin: float = None @@ -8416,11 +11715,20 @@ def __call__(self): return "BNTUSDT" -BNTUSDT = BNTUSDT() +BNXBNB = BNXBNB() @dataclass(slots=True, frozen=True) class BNXBNB: + """ + name: BNXBNB + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.00100000 + maximum_order_size: 92141578.00000000 + margin: False + """ name: str = "BNXBNB" precision: int = 8 minimum_margin: float = None @@ -8439,11 +11747,20 @@ def __call__(self): return "BNXBNB" -BNXBNB = BNXBNB() +BNXBTC = BNXBTC() @dataclass(slots=True, frozen=True) class BNXBTC: + """ + name: BNXBTC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.00100000 + maximum_order_size: 92141578.00000000 + margin: False + """ name: str = "BNXBTC" precision: int = 8 minimum_margin: float = None @@ -8462,11 +11779,20 @@ def __call__(self): return "BNXBTC" -BNXBTC = BNXBTC() +BNXBUSD = BNXBUSD() @dataclass(slots=True, frozen=True) class BNXBUSD: + """ + name: BNXBUSD + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.00100000 + maximum_order_size: 922327.00000000 + margin: False + """ name: str = "BNXBUSD" precision: int = 8 minimum_margin: float = None @@ -8485,11 +11811,20 @@ def __call__(self): return "BNXBUSD" -BNXBUSD = BNXBUSD() +BNXUSDT = BNXUSDT() @dataclass(slots=True, frozen=True) class BNXUSDT: + """ + name: BNXUSDT + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.00100000 + maximum_order_size: 922327.00000000 + margin: False + """ name: str = "BNXUSDT" precision: int = 8 minimum_margin: float = None @@ -8508,11 +11843,20 @@ def __call__(self): return "BNXUSDT" -BNXUSDT = BNXUSDT() +BONDBNB = BONDBNB() @dataclass(slots=True, frozen=True) class BONDBNB: + """ + name: BONDBNB + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 92141578.00000000 + margin: False + """ name: str = "BONDBNB" precision: int = 8 minimum_margin: float = None @@ -8531,11 +11875,20 @@ def __call__(self): return "BONDBNB" -BONDBNB = BONDBNB() +BONDBTC = BONDBTC() @dataclass(slots=True, frozen=True) class BONDBTC: + """ + name: BONDBTC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 92141578.00000000 + margin: True + """ name: str = "BONDBTC" precision: int = 8 minimum_margin: float = None @@ -8554,11 +11907,20 @@ def __call__(self): return "BONDBTC" -BONDBTC = BONDBTC() +BONDBUSD = BONDBUSD() @dataclass(slots=True, frozen=True) class BONDBUSD: + """ + name: BONDBUSD + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 9222449.00000000 + margin: True + """ name: str = "BONDBUSD" precision: int = 8 minimum_margin: float = None @@ -8577,11 +11939,20 @@ def __call__(self): return "BONDBUSD" -BONDBUSD = BONDBUSD() +BONDETH = BONDETH() @dataclass(slots=True, frozen=True) class BONDETH: + """ + name: BONDETH + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.00100000 + maximum_order_size: 92141578.00000000 + margin: False + """ name: str = "BONDETH" precision: int = 8 minimum_margin: float = None @@ -8600,11 +11971,20 @@ def __call__(self): return "BONDETH" -BONDETH = BONDETH() +BONDUSDT = BONDUSDT() @dataclass(slots=True, frozen=True) class BONDUSDT: + """ + name: BONDUSDT + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 9222449.00000000 + margin: True + """ name: str = "BONDUSDT" precision: int = 8 minimum_margin: float = None @@ -8623,11 +12003,20 @@ def __call__(self): return "BONDUSDT" -BONDUSDT = BONDUSDT() +BOTBTC = BOTBTC() @dataclass(slots=True, frozen=True) class BOTBTC: + """ + name: BOTBTC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.00010000 + maximum_order_size: 92141578.00000000 + margin: False + """ name: str = "BOTBTC" precision: int = 8 minimum_margin: float = None @@ -8646,11 +12035,20 @@ def __call__(self): return "BOTBTC" -BOTBTC = BOTBTC() +BOTBUSD = BOTBUSD() @dataclass(slots=True, frozen=True) class BOTBUSD: + """ + name: BOTBUSD + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.00001000 + maximum_order_size: 90000.00000000 + margin: False + """ name: str = "BOTBUSD" precision: int = 8 minimum_margin: float = None @@ -8669,11 +12067,20 @@ def __call__(self): return "BOTBUSD" -BOTBUSD = BOTBUSD() +BQXBTC = BQXBTC() @dataclass(slots=True, frozen=True) class BQXBTC: + """ + name: BQXBTC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 90000000.00000000 + margin: False + """ name: str = "BQXBTC" precision: int = 8 minimum_margin: float = None @@ -8692,11 +12099,20 @@ def __call__(self): return "BQXBTC" -BQXBTC = BQXBTC() +BQXETH = BQXETH() @dataclass(slots=True, frozen=True) class BQXETH: + """ + name: BQXETH + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 10.00000000 + maximum_order_size: 90000000.00000000 + margin: False + """ name: str = "BQXETH" precision: int = 8 minimum_margin: float = None @@ -8715,11 +12131,20 @@ def __call__(self): return "BQXETH" -BQXETH = BQXETH() +BRDBNB = BRDBNB() @dataclass(slots=True, frozen=True) class BRDBNB: + """ + name: BRDBNB + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 9000000.00000000 + margin: False + """ name: str = "BRDBNB" precision: int = 8 minimum_margin: float = None @@ -8738,11 +12163,20 @@ def __call__(self): return "BRDBNB" -BRDBNB = BRDBNB() +BRDBTC = BRDBTC() @dataclass(slots=True, frozen=True) class BRDBTC: + """ + name: BRDBTC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 90000000.00000000 + margin: False + """ name: str = "BRDBTC" precision: int = 8 minimum_margin: float = None @@ -8761,11 +12195,20 @@ def __call__(self): return "BRDBTC" -BRDBTC = BRDBTC() +BRDETH = BRDETH() @dataclass(slots=True, frozen=True) class BRDETH: + """ + name: BRDETH + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 90000000.00000000 + margin: False + """ name: str = "BRDETH" precision: int = 8 minimum_margin: float = None @@ -8784,11 +12227,20 @@ def __call__(self): return "BRDETH" -BRDETH = BRDETH() +BSWBNB = BSWBNB() @dataclass(slots=True, frozen=True) class BSWBNB: + """ + name: BSWBNB + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 92141578.00000000 + margin: False + """ name: str = "BSWBNB" precision: int = 8 minimum_margin: float = None @@ -8807,11 +12259,20 @@ def __call__(self): return "BSWBNB" -BSWBNB = BSWBNB() +BSWBUSD = BSWBUSD() @dataclass(slots=True, frozen=True) class BSWBUSD: + """ + name: BSWBUSD + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 92141578.00000000 + margin: True + """ name: str = "BSWBUSD" precision: int = 8 minimum_margin: float = None @@ -8830,11 +12291,20 @@ def __call__(self): return "BSWBUSD" -BSWBUSD = BSWBUSD() +BSWETH = BSWETH() @dataclass(slots=True, frozen=True) class BSWETH: + """ + name: BSWETH + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 92141578.00000000 + margin: False + """ name: str = "BSWETH" precision: int = 8 minimum_margin: float = None @@ -8853,11 +12323,20 @@ def __call__(self): return "BSWETH" -BSWETH = BSWETH() +BSWTRY = BSWTRY() @dataclass(slots=True, frozen=True) class BSWTRY: + """ + name: BSWTRY + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 9222449.00000000 + margin: False + """ name: str = "BSWTRY" precision: int = 8 minimum_margin: float = None @@ -8876,11 +12355,20 @@ def __call__(self): return "BSWTRY" -BSWTRY = BSWTRY() +BSWUSDT = BSWUSDT() @dataclass(slots=True, frozen=True) class BSWUSDT: + """ + name: BSWUSDT + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 92141578.00000000 + margin: True + """ name: str = "BSWUSDT" precision: int = 8 minimum_margin: float = None @@ -8899,11 +12387,20 @@ def __call__(self): return "BSWUSDT" -BSWUSDT = BSWUSDT() +BTCAUD = BTCAUD() @dataclass(slots=True, frozen=True) class BTCAUD: + """ + name: BTCAUD + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.00001000 + maximum_order_size: 9000.00000000 + margin: False + """ name: str = "BTCAUD" precision: int = 8 minimum_margin: float = None @@ -8922,11 +12419,20 @@ def __call__(self): return "BTCAUD" -BTCAUD = BTCAUD() +BTCBBTC = BTCBBTC() @dataclass(slots=True, frozen=True) class BTCBBTC: + """ + name: BTCBBTC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.00100000 + maximum_order_size: 10000000.00000000 + margin: False + """ name: str = "BTCBBTC" precision: int = 8 minimum_margin: float = None @@ -8945,11 +12451,20 @@ def __call__(self): return "BTCBBTC" -BTCBBTC = BTCBBTC() +BTCBIDR = BTCBIDR() @dataclass(slots=True, frozen=True) class BTCBIDR: + """ + name: BTCBIDR + precision: 2 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.00001000 + maximum_order_size: 100000.00000000 + margin: False + """ name: str = "BTCBIDR" precision: int = 2 minimum_margin: float = None @@ -8968,11 +12483,20 @@ def __call__(self): return "BTCBIDR" -BTCBIDR = BTCBIDR() +BTCBKRW = BTCBKRW() @dataclass(slots=True, frozen=True) class BTCBKRW: + """ + name: BTCBKRW + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.00000100 + maximum_order_size: 100.00000000 + margin: False + """ name: str = "BTCBKRW" precision: int = 8 minimum_margin: float = None @@ -8991,11 +12515,20 @@ def __call__(self): return "BTCBKRW" -BTCBKRW = BTCBKRW() +BTCBRL = BTCBRL() @dataclass(slots=True, frozen=True) class BTCBRL: + """ + name: BTCBRL + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.00001000 + maximum_order_size: 9000.00000000 + margin: False + """ name: str = "BTCBRL" precision: int = 8 minimum_margin: float = None @@ -9014,11 +12547,20 @@ def __call__(self): return "BTCBRL" -BTCBRL = BTCBRL() +BTCBUSD = BTCBUSD() @dataclass(slots=True, frozen=True) class BTCBUSD: + """ + name: BTCBUSD + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.00001000 + maximum_order_size: 9000.00000000 + margin: True + """ name: str = "BTCBUSD" precision: int = 8 minimum_margin: float = None @@ -9037,11 +12579,20 @@ def __call__(self): return "BTCBUSD" -BTCBUSD = BTCBUSD() +BTCDAI = BTCDAI() @dataclass(slots=True, frozen=True) class BTCDAI: + """ + name: BTCDAI + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.00001000 + maximum_order_size: 9000.00000000 + margin: False + """ name: str = "BTCDAI" precision: int = 8 minimum_margin: float = None @@ -9060,11 +12611,20 @@ def __call__(self): return "BTCDAI" -BTCDAI = BTCDAI() +BTCDOWNUSDT = BTCDOWNUSDT() @dataclass(slots=True, frozen=True) class BTCDOWNUSDT: + """ + name: BTCDOWNUSDT + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 921415.00000000 + margin: False + """ name: str = "BTCDOWNUSDT" precision: int = 8 minimum_margin: float = None @@ -9083,11 +12643,20 @@ def __call__(self): return "BTCDOWNUSDT" -BTCDOWNUSDT = BTCDOWNUSDT() +BTCEUR = BTCEUR() @dataclass(slots=True, frozen=True) class BTCEUR: + """ + name: BTCEUR + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.00001000 + maximum_order_size: 9000.00000000 + margin: False + """ name: str = "BTCEUR" precision: int = 8 minimum_margin: float = None @@ -9106,11 +12675,20 @@ def __call__(self): return "BTCEUR" -BTCEUR = BTCEUR() +BTCGBP = BTCGBP() @dataclass(slots=True, frozen=True) class BTCGBP: + """ + name: BTCGBP + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.00001000 + maximum_order_size: 9000.00000000 + margin: False + """ name: str = "BTCGBP" precision: int = 8 minimum_margin: float = None @@ -9129,11 +12707,20 @@ def __call__(self): return "BTCGBP" -BTCGBP = BTCGBP() +BTCIDRT = BTCIDRT() @dataclass(slots=True, frozen=True) class BTCIDRT: + """ + name: BTCIDRT + precision: 2 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.00001000 + maximum_order_size: 100000.00000000 + margin: False + """ name: str = "BTCIDRT" precision: int = 2 minimum_margin: float = None @@ -9152,11 +12739,20 @@ def __call__(self): return "BTCIDRT" -BTCIDRT = BTCIDRT() +BTCNGN = BTCNGN() @dataclass(slots=True, frozen=True) class BTCNGN: + """ + name: BTCNGN + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.00001000 + maximum_order_size: 305.00000000 + margin: False + """ name: str = "BTCNGN" precision: int = 8 minimum_margin: float = None @@ -9175,11 +12771,20 @@ def __call__(self): return "BTCNGN" -BTCNGN = BTCNGN() +BTCPAX = BTCPAX() @dataclass(slots=True, frozen=True) class BTCPAX: + """ + name: BTCPAX + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.00001000 + maximum_order_size: 9000.00000000 + margin: False + """ name: str = "BTCPAX" precision: int = 8 minimum_margin: float = None @@ -9198,11 +12803,20 @@ def __call__(self): return "BTCPAX" -BTCPAX = BTCPAX() +BTCPLN = BTCPLN() @dataclass(slots=True, frozen=True) class BTCPLN: + """ + name: BTCPLN + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.00001000 + maximum_order_size: 9223.00000000 + margin: False + """ name: str = "BTCPLN" precision: int = 8 minimum_margin: float = None @@ -9221,11 +12835,20 @@ def __call__(self): return "BTCPLN" -BTCPLN = BTCPLN() +BTCRUB = BTCRUB() @dataclass(slots=True, frozen=True) class BTCRUB: + """ + name: BTCRUB + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.00001000 + maximum_order_size: 900.00000000 + margin: False + """ name: str = "BTCRUB" precision: int = 8 minimum_margin: float = None @@ -9244,11 +12867,20 @@ def __call__(self): return "BTCRUB" -BTCRUB = BTCRUB() +BTCSTBTC = BTCSTBTC() @dataclass(slots=True, frozen=True) class BTCSTBTC: + """ + name: BTCSTBTC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 90000000.00000000 + margin: False + """ name: str = "BTCSTBTC" precision: int = 8 minimum_margin: float = None @@ -9267,11 +12899,20 @@ def __call__(self): return "BTCSTBTC" -BTCSTBTC = BTCSTBTC() +BTCSTBUSD = BTCSTBUSD() @dataclass(slots=True, frozen=True) class BTCSTBUSD: + """ + name: BTCSTBUSD + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 90000.00000000 + margin: False + """ name: str = "BTCSTBUSD" precision: int = 8 minimum_margin: float = None @@ -9290,11 +12931,20 @@ def __call__(self): return "BTCSTBUSD" -BTCSTBUSD = BTCSTBUSD() +BTCSTUSDT = BTCSTUSDT() @dataclass(slots=True, frozen=True) class BTCSTUSDT: + """ + name: BTCSTUSDT + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 90000.00000000 + margin: False + """ name: str = "BTCSTUSDT" precision: int = 8 minimum_margin: float = None @@ -9313,11 +12963,20 @@ def __call__(self): return "BTCSTUSDT" -BTCSTUSDT = BTCSTUSDT() +BTCTRY = BTCTRY() @dataclass(slots=True, frozen=True) class BTCTRY: + """ + name: BTCTRY + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.00001000 + maximum_order_size: 9000.00000000 + margin: False + """ name: str = "BTCTRY" precision: int = 8 minimum_margin: float = None @@ -9336,11 +12995,20 @@ def __call__(self): return "BTCTRY" -BTCTRY = BTCTRY() +BTCTUSD = BTCTUSD() @dataclass(slots=True, frozen=True) class BTCTUSD: + """ + name: BTCTUSD + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.00001000 + maximum_order_size: 9000.00000000 + margin: False + """ name: str = "BTCTUSD" precision: int = 8 minimum_margin: float = None @@ -9359,11 +13027,20 @@ def __call__(self): return "BTCTUSD" -BTCTUSD = BTCTUSD() +BTCUAH = BTCUAH() @dataclass(slots=True, frozen=True) class BTCUAH: + """ + name: BTCUAH + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.00001000 + maximum_order_size: 1800.00000000 + margin: False + """ name: str = "BTCUAH" precision: int = 8 minimum_margin: float = None @@ -9382,11 +13059,20 @@ def __call__(self): return "BTCUAH" -BTCUAH = BTCUAH() +BTCUPUSDT = BTCUPUSDT() @dataclass(slots=True, frozen=True) class BTCUPUSDT: + """ + name: BTCUPUSDT + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 3000.00000000 + margin: False + """ name: str = "BTCUPUSDT" precision: int = 8 minimum_margin: float = None @@ -9405,11 +13091,20 @@ def __call__(self): return "BTCUPUSDT" -BTCUPUSDT = BTCUPUSDT() +BTCUSDC = BTCUSDC() @dataclass(slots=True, frozen=True) class BTCUSDC: + """ + name: BTCUSDC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.00001000 + maximum_order_size: 9000.00000000 + margin: False + """ name: str = "BTCUSDC" precision: int = 8 minimum_margin: float = None @@ -9428,11 +13123,20 @@ def __call__(self): return "BTCUSDC" -BTCUSDC = BTCUSDC() +BTCUSDP = BTCUSDP() @dataclass(slots=True, frozen=True) class BTCUSDP: + """ + name: BTCUSDP + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.00001000 + maximum_order_size: 9223.00000000 + margin: False + """ name: str = "BTCUSDP" precision: int = 8 minimum_margin: float = None @@ -9451,11 +13155,20 @@ def __call__(self): return "BTCUSDP" -BTCUSDP = BTCUSDP() +BTCUSDS = BTCUSDS() @dataclass(slots=True, frozen=True) class BTCUSDS: + """ + name: BTCUSDS + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.00000100 + maximum_order_size: 9000.00000000 + margin: False + """ name: str = "BTCUSDS" precision: int = 8 minimum_margin: float = None @@ -9474,11 +13187,20 @@ def __call__(self): return "BTCUSDS" -BTCUSDS = BTCUSDS() +BTCUSDT = BTCUSDT() @dataclass(slots=True, frozen=True) class BTCUSDT: + """ + name: BTCUSDT + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.00001000 + maximum_order_size: 9000.00000000 + margin: True + """ name: str = "BTCUSDT" precision: int = 8 minimum_margin: float = None @@ -9497,11 +13219,20 @@ def __call__(self): return "BTCUSDT" -BTCUSDT = BTCUSDT() +BTCUST = BTCUST() @dataclass(slots=True, frozen=True) class BTCUST: + """ + name: BTCUST + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.00001000 + maximum_order_size: 9000.00000000 + margin: False + """ name: str = "BTCUST" precision: int = 8 minimum_margin: float = None @@ -9520,11 +13251,20 @@ def __call__(self): return "BTCUST" -BTCUST = BTCUST() +BTCVAI = BTCVAI() @dataclass(slots=True, frozen=True) class BTCVAI: + """ + name: BTCVAI + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.00001000 + maximum_order_size: 9000.00000000 + margin: False + """ name: str = "BTCVAI" precision: int = 8 minimum_margin: float = None @@ -9543,11 +13283,20 @@ def __call__(self): return "BTCVAI" -BTCVAI = BTCVAI() +BTCZAR = BTCZAR() @dataclass(slots=True, frozen=True) class BTCZAR: + """ + name: BTCZAR + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.00001000 + maximum_order_size: 922.00000000 + margin: False + """ name: str = "BTCZAR" precision: int = 8 minimum_margin: float = None @@ -9566,11 +13315,20 @@ def __call__(self): return "BTCZAR" -BTCZAR = BTCZAR() +BTGBTC = BTGBTC() @dataclass(slots=True, frozen=True) class BTGBTC: + """ + name: BTGBTC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 92141578.00000000 + margin: False + """ name: str = "BTGBTC" precision: int = 8 minimum_margin: float = None @@ -9589,11 +13347,20 @@ def __call__(self): return "BTGBTC" -BTGBTC = BTGBTC() +BTGBUSD = BTGBUSD() @dataclass(slots=True, frozen=True) class BTGBUSD: + """ + name: BTGBUSD + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 92141578.00000000 + margin: False + """ name: str = "BTGBUSD" precision: int = 8 minimum_margin: float = None @@ -9612,11 +13379,20 @@ def __call__(self): return "BTGBUSD" -BTGBUSD = BTGBUSD() +BTGETH = BTGETH() @dataclass(slots=True, frozen=True) class BTGETH: + """ + name: BTGETH + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 90000000.00000000 + margin: False + """ name: str = "BTGETH" precision: int = 8 minimum_margin: float = None @@ -9635,11 +13411,20 @@ def __call__(self): return "BTGETH" -BTGETH = BTGETH() +BTGUSDT = BTGUSDT() @dataclass(slots=True, frozen=True) class BTGUSDT: + """ + name: BTGUSDT + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 92141578.00000000 + margin: False + """ name: str = "BTGUSDT" precision: int = 8 minimum_margin: float = None @@ -9658,11 +13443,20 @@ def __call__(self): return "BTGUSDT" -BTGUSDT = BTGUSDT() +BTSBNB = BTSBNB() @dataclass(slots=True, frozen=True) class BTSBNB: + """ + name: BTSBNB + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 9000000.00000000 + margin: False + """ name: str = "BTSBNB" precision: int = 8 minimum_margin: float = None @@ -9681,11 +13475,20 @@ def __call__(self): return "BTSBNB" -BTSBNB = BTSBNB() +BTSBTC = BTSBTC() @dataclass(slots=True, frozen=True) class BTSBTC: + """ + name: BTSBTC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 90000000.00000000 + margin: True + """ name: str = "BTSBTC" precision: int = 8 minimum_margin: float = None @@ -9704,11 +13507,20 @@ def __call__(self): return "BTSBTC" -BTSBTC = BTSBTC() +BTSBUSD = BTSBUSD() @dataclass(slots=True, frozen=True) class BTSBUSD: + """ + name: BTSBUSD + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 9000000.00000000 + margin: False + """ name: str = "BTSBUSD" precision: int = 8 minimum_margin: float = None @@ -9727,11 +13539,20 @@ def __call__(self): return "BTSBUSD" -BTSBUSD = BTSBUSD() +BTSETH = BTSETH() @dataclass(slots=True, frozen=True) class BTSETH: + """ + name: BTSETH + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 90000000.00000000 + margin: False + """ name: str = "BTSETH" precision: int = 8 minimum_margin: float = None @@ -9750,11 +13571,20 @@ def __call__(self): return "BTSETH" -BTSETH = BTSETH() +BTSUSDT = BTSUSDT() @dataclass(slots=True, frozen=True) class BTSUSDT: + """ + name: BTSUSDT + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 9000000.00000000 + margin: True + """ name: str = "BTSUSDT" precision: int = 8 minimum_margin: float = None @@ -9773,11 +13603,20 @@ def __call__(self): return "BTSUSDT" -BTSUSDT = BTSUSDT() +BTTBNB = BTTBNB() @dataclass(slots=True, frozen=True) class BTTBNB: + """ + name: BTTBNB + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 90000000.00000000 + margin: False + """ name: str = "BTTBNB" precision: int = 8 minimum_margin: float = None @@ -9796,11 +13635,20 @@ def __call__(self): return "BTTBNB" -BTTBNB = BTTBNB() +BTTBRL = BTTBRL() @dataclass(slots=True, frozen=True) class BTTBRL: + """ + name: BTTBRL + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 92141578.00000000 + margin: False + """ name: str = "BTTBRL" precision: int = 8 minimum_margin: float = None @@ -9819,11 +13667,20 @@ def __call__(self): return "BTTBRL" -BTTBRL = BTTBRL() +BTTBTC = BTTBTC() @dataclass(slots=True, frozen=True) class BTTBTC: + """ + name: BTTBTC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 92141578.00000000 + margin: False + """ name: str = "BTTBTC" precision: int = 8 minimum_margin: float = None @@ -9842,11 +13699,20 @@ def __call__(self): return "BTTBTC" -BTTBTC = BTTBTC() +BTTBUSD = BTTBUSD() @dataclass(slots=True, frozen=True) class BTTBUSD: + """ + name: BTTBUSD + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 90000000.00000000 + margin: False + """ name: str = "BTTBUSD" precision: int = 8 minimum_margin: float = None @@ -9865,11 +13731,20 @@ def __call__(self): return "BTTBUSD" -BTTBUSD = BTTBUSD() +BTTCBUSD = BTTCBUSD() @dataclass(slots=True, frozen=True) class BTTCBUSD: + """ + name: BTTCBUSD + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.0 + maximum_order_size: 92233720368.0 + margin: False + """ name: str = "BTTCBUSD" precision: int = 8 minimum_margin: float = None @@ -9888,11 +13763,20 @@ def __call__(self): return "BTTCBUSD" -BTTCBUSD = BTTCBUSD() +BTTCTRY = BTTCTRY() @dataclass(slots=True, frozen=True) class BTTCTRY: + """ + name: BTTCTRY + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.0 + maximum_order_size: 92233720368.0 + margin: False + """ name: str = "BTTCTRY" precision: int = 8 minimum_margin: float = None @@ -9911,11 +13795,20 @@ def __call__(self): return "BTTCTRY" -BTTCTRY = BTTCTRY() +BTTCUSDC = BTTCUSDC() @dataclass(slots=True, frozen=True) class BTTCUSDC: + """ + name: BTTCUSDC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.0 + maximum_order_size: 92233720368.0 + margin: False + """ name: str = "BTTCUSDC" precision: int = 8 minimum_margin: float = None @@ -9934,11 +13827,20 @@ def __call__(self): return "BTTCUSDC" -BTTCUSDC = BTTCUSDC() +BTTCUSDT = BTTCUSDT() @dataclass(slots=True, frozen=True) class BTTCUSDT: + """ + name: BTTCUSDT + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.0 + maximum_order_size: 92233720368.0 + margin: False + """ name: str = "BTTCUSDT" precision: int = 8 minimum_margin: float = None @@ -9957,11 +13859,20 @@ def __call__(self): return "BTTCUSDT" -BTTCUSDT = BTTCUSDT() +BTTEUR = BTTEUR() @dataclass(slots=True, frozen=True) class BTTEUR: + """ + name: BTTEUR + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 92141578.00000000 + margin: False + """ name: str = "BTTEUR" precision: int = 8 minimum_margin: float = None @@ -9980,11 +13891,20 @@ def __call__(self): return "BTTEUR" -BTTEUR = BTTEUR() +BTTPAX = BTTPAX() @dataclass(slots=True, frozen=True) class BTTPAX: + """ + name: BTTPAX + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 90000000.00000000 + margin: False + """ name: str = "BTTPAX" precision: int = 8 minimum_margin: float = None @@ -10003,11 +13923,20 @@ def __call__(self): return "BTTPAX" -BTTPAX = BTTPAX() +BTTTRX = BTTTRX() @dataclass(slots=True, frozen=True) class BTTTRX: + """ + name: BTTTRX + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 92141578.00000000 + margin: False + """ name: str = "BTTTRX" precision: int = 8 minimum_margin: float = None @@ -10026,11 +13955,20 @@ def __call__(self): return "BTTTRX" -BTTTRX = BTTTRX() +BTTTRY = BTTTRY() @dataclass(slots=True, frozen=True) class BTTTRY: + """ + name: BTTTRY + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 92141578.00000000 + margin: False + """ name: str = "BTTTRY" precision: int = 8 minimum_margin: float = None @@ -10049,11 +13987,20 @@ def __call__(self): return "BTTTRY" -BTTTRY = BTTTRY() +BTTTUSD = BTTTUSD() @dataclass(slots=True, frozen=True) class BTTTUSD: + """ + name: BTTTUSD + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 90000000.00000000 + margin: False + """ name: str = "BTTTUSD" precision: int = 8 minimum_margin: float = None @@ -10072,11 +14019,20 @@ def __call__(self): return "BTTTUSD" -BTTTUSD = BTTTUSD() +BTTUSDC = BTTUSDC() @dataclass(slots=True, frozen=True) class BTTUSDC: + """ + name: BTTUSDC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 90000000.00000000 + margin: False + """ name: str = "BTTUSDC" precision: int = 8 minimum_margin: float = None @@ -10095,11 +14051,20 @@ def __call__(self): return "BTTUSDC" -BTTUSDC = BTTUSDC() +BTTUSDT = BTTUSDT() @dataclass(slots=True, frozen=True) class BTTUSDT: + """ + name: BTTUSDT + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 92141578.00000000 + margin: False + """ name: str = "BTTUSDT" precision: int = 8 minimum_margin: float = None @@ -10118,11 +14083,20 @@ def __call__(self): return "BTTUSDT" -BTTUSDT = BTTUSDT() +BULLBUSD = BULLBUSD() @dataclass(slots=True, frozen=True) class BULLBUSD: + """ + name: BULLBUSD + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.00000100 + maximum_order_size: 9000.00000000 + margin: False + """ name: str = "BULLBUSD" precision: int = 8 minimum_margin: float = None @@ -10141,11 +14115,20 @@ def __call__(self): return "BULLBUSD" -BULLBUSD = BULLBUSD() +BULLUSDT = BULLUSDT() @dataclass(slots=True, frozen=True) class BULLUSDT: + """ + name: BULLUSDT + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.00000100 + maximum_order_size: 9000.00000000 + margin: False + """ name: str = "BULLUSDT" precision: int = 8 minimum_margin: float = None @@ -10164,11 +14147,20 @@ def __call__(self): return "BULLUSDT" -BULLUSDT = BULLUSDT() +BURGERBNB = BURGERBNB() @dataclass(slots=True, frozen=True) class BURGERBNB: + """ + name: BURGERBNB + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 9000000.00000000 + margin: False + """ name: str = "BURGERBNB" precision: int = 8 minimum_margin: float = None @@ -10187,11 +14179,20 @@ def __call__(self): return "BURGERBNB" -BURGERBNB = BURGERBNB() +BURGERBUSD = BURGERBUSD() @dataclass(slots=True, frozen=True) class BURGERBUSD: + """ + name: BURGERBUSD + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 9222449.00000000 + margin: True + """ name: str = "BURGERBUSD" precision: int = 8 minimum_margin: float = None @@ -10210,11 +14211,20 @@ def __call__(self): return "BURGERBUSD" -BURGERBUSD = BURGERBUSD() +BURGERETH = BURGERETH() @dataclass(slots=True, frozen=True) class BURGERETH: + """ + name: BURGERETH + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 92141578.00000000 + margin: False + """ name: str = "BURGERETH" precision: int = 8 minimum_margin: float = None @@ -10233,11 +14243,20 @@ def __call__(self): return "BURGERETH" -BURGERETH = BURGERETH() +BURGERUSDT = BURGERUSDT() @dataclass(slots=True, frozen=True) class BURGERUSDT: + """ + name: BURGERUSDT + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 9222449.00000000 + margin: True + """ name: str = "BURGERUSDT" precision: int = 8 minimum_margin: float = None @@ -10256,11 +14275,20 @@ def __call__(self): return "BURGERUSDT" -BURGERUSDT = BURGERUSDT() +BUSDBIDR = BUSDBIDR() @dataclass(slots=True, frozen=True) class BUSDBIDR: + """ + name: BUSDBIDR + precision: 2 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 1000000.00000000 + margin: False + """ name: str = "BUSDBIDR" precision: int = 2 minimum_margin: float = None @@ -10279,11 +14307,20 @@ def __call__(self): return "BUSDBIDR" -BUSDBIDR = BUSDBIDR() +BUSDBKRW = BUSDBKRW() @dataclass(slots=True, frozen=True) class BUSDBKRW: + """ + name: BUSDBKRW + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 922327.00000000 + margin: False + """ name: str = "BUSDBKRW" precision: int = 8 minimum_margin: float = None @@ -10302,11 +14339,20 @@ def __call__(self): return "BUSDBKRW" -BUSDBKRW = BUSDBKRW() +BUSDBRL = BUSDBRL() @dataclass(slots=True, frozen=True) class BUSDBRL: + """ + name: BUSDBRL + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 9222449.00000000 + margin: False + """ name: str = "BUSDBRL" precision: int = 8 minimum_margin: float = None @@ -10325,11 +14371,20 @@ def __call__(self): return "BUSDBRL" -BUSDBRL = BUSDBRL() +BUSDBVND = BUSDBVND() @dataclass(slots=True, frozen=True) class BUSDBVND: + """ + name: BUSDBVND + precision: 2 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 1000000.00000000 + margin: False + """ name: str = "BUSDBVND" precision: int = 2 minimum_margin: float = None @@ -10348,11 +14403,20 @@ def __call__(self): return "BUSDBVND" -BUSDBVND = BUSDBVND() +BUSDDAI = BUSDDAI() @dataclass(slots=True, frozen=True) class BUSDDAI: + """ + name: BUSDDAI + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 900000.00000000 + margin: False + """ name: str = "BUSDDAI" precision: int = 8 minimum_margin: float = None @@ -10371,11 +14435,20 @@ def __call__(self): return "BUSDDAI" -BUSDDAI = BUSDDAI() +BUSDIDRT = BUSDIDRT() @dataclass(slots=True, frozen=True) class BUSDIDRT: + """ + name: BUSDIDRT + precision: 2 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 1000000.00000000 + margin: False + """ name: str = "BUSDIDRT" precision: int = 2 minimum_margin: float = None @@ -10394,11 +14467,20 @@ def __call__(self): return "BUSDIDRT" -BUSDIDRT = BUSDIDRT() +BUSDNGN = BUSDNGN() @dataclass(slots=True, frozen=True) class BUSDNGN: + """ + name: BUSDNGN + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 922320.00000000 + margin: False + """ name: str = "BUSDNGN" precision: int = 8 minimum_margin: float = None @@ -10417,11 +14499,20 @@ def __call__(self): return "BUSDNGN" -BUSDNGN = BUSDNGN() +BUSDPLN = BUSDPLN() @dataclass(slots=True, frozen=True) class BUSDPLN: + """ + name: BUSDPLN + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 92141578.00000000 + margin: False + """ name: str = "BUSDPLN" precision: int = 8 minimum_margin: float = None @@ -10440,11 +14531,20 @@ def __call__(self): return "BUSDPLN" -BUSDPLN = BUSDPLN() +BUSDRON = BUSDRON() @dataclass(slots=True, frozen=True) class BUSDRON: + """ + name: BUSDRON + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 92141578.00000000 + margin: False + """ name: str = "BUSDRON" precision: int = 8 minimum_margin: float = None @@ -10463,11 +14563,20 @@ def __call__(self): return "BUSDRON" -BUSDRON = BUSDRON() +BUSDRUB = BUSDRUB() @dataclass(slots=True, frozen=True) class BUSDRUB: + """ + name: BUSDRUB + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 9222449.00000000 + margin: False + """ name: str = "BUSDRUB" precision: int = 8 minimum_margin: float = None @@ -10486,11 +14595,20 @@ def __call__(self): return "BUSDRUB" -BUSDRUB = BUSDRUB() +BUSDTRY = BUSDTRY() @dataclass(slots=True, frozen=True) class BUSDTRY: + """ + name: BUSDTRY + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 922327.00000000 + margin: False + """ name: str = "BUSDTRY" precision: int = 8 minimum_margin: float = None @@ -10509,11 +14627,20 @@ def __call__(self): return "BUSDTRY" -BUSDTRY = BUSDTRY() +BUSDUAH = BUSDUAH() @dataclass(slots=True, frozen=True) class BUSDUAH: + """ + name: BUSDUAH + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 922327.00000000 + margin: False + """ name: str = "BUSDUAH" precision: int = 8 minimum_margin: float = None @@ -10532,11 +14659,20 @@ def __call__(self): return "BUSDUAH" -BUSDUAH = BUSDUAH() +BUSDUSDT = BUSDUSDT() @dataclass(slots=True, frozen=True) class BUSDUSDT: + """ + name: BUSDUSDT + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 15000000.00000000 + margin: True + """ name: str = "BUSDUSDT" precision: int = 8 minimum_margin: float = None @@ -10555,11 +14691,20 @@ def __call__(self): return "BUSDUSDT" -BUSDUSDT = BUSDUSDT() +BUSDVAI = BUSDVAI() @dataclass(slots=True, frozen=True) class BUSDVAI: + """ + name: BUSDVAI + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 900000.00000000 + margin: False + """ name: str = "BUSDVAI" precision: int = 8 minimum_margin: float = None @@ -10578,11 +14723,20 @@ def __call__(self): return "BUSDVAI" -BUSDVAI = BUSDVAI() +BUSDZAR = BUSDZAR() @dataclass(slots=True, frozen=True) class BUSDZAR: + """ + name: BUSDZAR + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 9222449.00000000 + margin: False + """ name: str = "BUSDZAR" precision: int = 8 minimum_margin: float = None @@ -10601,11 +14755,20 @@ def __call__(self): return "BUSDZAR" -BUSDZAR = BUSDZAR() +BZRXBNB = BZRXBNB() @dataclass(slots=True, frozen=True) class BZRXBNB: + """ + name: BZRXBNB + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 9000000.00000000 + margin: False + """ name: str = "BZRXBNB" precision: int = 8 minimum_margin: float = None @@ -10624,11 +14787,20 @@ def __call__(self): return "BZRXBNB" -BZRXBNB = BZRXBNB() +BZRXBTC = BZRXBTC() @dataclass(slots=True, frozen=True) class BZRXBTC: + """ + name: BZRXBTC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 90000000.00000000 + margin: False + """ name: str = "BZRXBTC" precision: int = 8 minimum_margin: float = None @@ -10647,11 +14819,20 @@ def __call__(self): return "BZRXBTC" -BZRXBTC = BZRXBTC() +BZRXBUSD = BZRXBUSD() @dataclass(slots=True, frozen=True) class BZRXBUSD: + """ + name: BZRXBUSD + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 900000.00000000 + margin: False + """ name: str = "BZRXBUSD" precision: int = 8 minimum_margin: float = None @@ -10670,11 +14851,20 @@ def __call__(self): return "BZRXBUSD" -BZRXBUSD = BZRXBUSD() +BZRXUSDT = BZRXUSDT() @dataclass(slots=True, frozen=True) class BZRXUSDT: + """ + name: BZRXUSDT + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 900000.00000000 + margin: False + """ name: str = "BZRXUSDT" precision: int = 8 minimum_margin: float = None @@ -10693,11 +14883,20 @@ def __call__(self): return "BZRXUSDT" -BZRXUSDT = BZRXUSDT() +C98BNB = C98BNB() @dataclass(slots=True, frozen=True) class C98BNB: + """ + name: C98BNB + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 92141578.00000000 + margin: False + """ name: str = "C98BNB" precision: int = 8 minimum_margin: float = None @@ -10716,11 +14915,20 @@ def __call__(self): return "C98BNB" -C98BNB = C98BNB() +C98BRL = C98BRL() @dataclass(slots=True, frozen=True) class C98BRL: + """ + name: C98BRL + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 9222449.00000000 + margin: False + """ name: str = "C98BRL" precision: int = 8 minimum_margin: float = None @@ -10739,11 +14947,20 @@ def __call__(self): return "C98BRL" -C98BRL = C98BRL() +C98BTC = C98BTC() @dataclass(slots=True, frozen=True) class C98BTC: + """ + name: C98BTC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 92141578.00000000 + margin: True + """ name: str = "C98BTC" precision: int = 8 minimum_margin: float = None @@ -10762,11 +14979,20 @@ def __call__(self): return "C98BTC" -C98BTC = C98BTC() +C98BUSD = C98BUSD() @dataclass(slots=True, frozen=True) class C98BUSD: + """ + name: C98BUSD + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 92141578.00000000 + margin: True + """ name: str = "C98BUSD" precision: int = 8 minimum_margin: float = None @@ -10785,11 +15011,20 @@ def __call__(self): return "C98BUSD" -C98BUSD = C98BUSD() +C98USDT = C98USDT() @dataclass(slots=True, frozen=True) class C98USDT: + """ + name: C98USDT + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 92141578.00000000 + margin: True + """ name: str = "C98USDT" precision: int = 8 minimum_margin: float = None @@ -10808,11 +15043,20 @@ def __call__(self): return "C98USDT" -C98USDT = C98USDT() +CAKEAUD = CAKEAUD() @dataclass(slots=True, frozen=True) class CAKEAUD: + """ + name: CAKEAUD + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 9222449.00000000 + margin: False + """ name: str = "CAKEAUD" precision: int = 8 minimum_margin: float = None @@ -10831,11 +15075,20 @@ def __call__(self): return "CAKEAUD" -CAKEAUD = CAKEAUD() +CAKEBNB = CAKEBNB() @dataclass(slots=True, frozen=True) class CAKEBNB: + """ + name: CAKEBNB + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 9000000.00000000 + margin: False + """ name: str = "CAKEBNB" precision: int = 8 minimum_margin: float = None @@ -10854,11 +15107,20 @@ def __call__(self): return "CAKEBNB" -CAKEBNB = CAKEBNB() +CAKEBRL = CAKEBRL() @dataclass(slots=True, frozen=True) class CAKEBRL: + """ + name: CAKEBRL + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 9222449.00000000 + margin: False + """ name: str = "CAKEBRL" precision: int = 8 minimum_margin: float = None @@ -10877,11 +15139,20 @@ def __call__(self): return "CAKEBRL" -CAKEBRL = CAKEBRL() +CAKEBTC = CAKEBTC() @dataclass(slots=True, frozen=True) class CAKEBTC: + """ + name: CAKEBTC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 90000000.00000000 + margin: True + """ name: str = "CAKEBTC" precision: int = 8 minimum_margin: float = None @@ -10900,11 +15171,20 @@ def __call__(self): return "CAKEBTC" -CAKEBTC = CAKEBTC() +CAKEBUSD = CAKEBUSD() @dataclass(slots=True, frozen=True) class CAKEBUSD: + """ + name: CAKEBUSD + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 90000.00000000 + margin: True + """ name: str = "CAKEBUSD" precision: int = 8 minimum_margin: float = None @@ -10923,11 +15203,20 @@ def __call__(self): return "CAKEBUSD" -CAKEBUSD = CAKEBUSD() +CAKEGBP = CAKEGBP() @dataclass(slots=True, frozen=True) class CAKEGBP: + """ + name: CAKEGBP + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 90000.00000000 + margin: False + """ name: str = "CAKEGBP" precision: int = 8 minimum_margin: float = None @@ -10946,11 +15235,20 @@ def __call__(self): return "CAKEGBP" -CAKEGBP = CAKEGBP() +CAKEUSDT = CAKEUSDT() @dataclass(slots=True, frozen=True) class CAKEUSDT: + """ + name: CAKEUSDT + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 90000.00000000 + margin: True + """ name: str = "CAKEUSDT" precision: int = 8 minimum_margin: float = None @@ -10969,11 +15267,20 @@ def __call__(self): return "CAKEUSDT" -CAKEUSDT = CAKEUSDT() +CDTBTC = CDTBTC() @dataclass(slots=True, frozen=True) class CDTBTC: + """ + name: CDTBTC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 90000000.00000000 + margin: False + """ name: str = "CDTBTC" precision: int = 8 minimum_margin: float = None @@ -10992,11 +15299,20 @@ def __call__(self): return "CDTBTC" -CDTBTC = CDTBTC() +CDTETH = CDTETH() @dataclass(slots=True, frozen=True) class CDTETH: + """ + name: CDTETH + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 90000000.00000000 + margin: False + """ name: str = "CDTETH" precision: int = 8 minimum_margin: float = None @@ -11015,11 +15331,20 @@ def __call__(self): return "CDTETH" -CDTETH = CDTETH() +CELOBTC = CELOBTC() @dataclass(slots=True, frozen=True) class CELOBTC: + """ + name: CELOBTC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 90000000.00000000 + margin: False + """ name: str = "CELOBTC" precision: int = 8 minimum_margin: float = None @@ -11038,11 +15363,20 @@ def __call__(self): return "CELOBTC" -CELOBTC = CELOBTC() +CELOBUSD = CELOBUSD() @dataclass(slots=True, frozen=True) class CELOBUSD: + """ + name: CELOBUSD + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 92141578.00000000 + margin: True + """ name: str = "CELOBUSD" precision: int = 8 minimum_margin: float = None @@ -11061,11 +15395,20 @@ def __call__(self): return "CELOBUSD" -CELOBUSD = CELOBUSD() +CELOUSDT = CELOUSDT() @dataclass(slots=True, frozen=True) class CELOUSDT: + """ + name: CELOUSDT + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 900000.00000000 + margin: True + """ name: str = "CELOUSDT" precision: int = 8 minimum_margin: float = None @@ -11084,11 +15427,20 @@ def __call__(self): return "CELOUSDT" -CELOUSDT = CELOUSDT() +CELRBNB = CELRBNB() @dataclass(slots=True, frozen=True) class CELRBNB: + """ + name: CELRBNB + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 9000000.00000000 + margin: False + """ name: str = "CELRBNB" precision: int = 8 minimum_margin: float = None @@ -11107,11 +15459,20 @@ def __call__(self): return "CELRBNB" -CELRBNB = CELRBNB() +CELRBTC = CELRBTC() @dataclass(slots=True, frozen=True) class CELRBTC: + """ + name: CELRBTC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 90000000.00000000 + margin: True + """ name: str = "CELRBTC" precision: int = 8 minimum_margin: float = None @@ -11130,11 +15491,20 @@ def __call__(self): return "CELRBTC" -CELRBTC = CELRBTC() +CELRBUSD = CELRBUSD() @dataclass(slots=True, frozen=True) class CELRBUSD: + """ + name: CELRBUSD + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 9222449.00000000 + margin: False + """ name: str = "CELRBUSD" precision: int = 8 minimum_margin: float = None @@ -11153,11 +15523,20 @@ def __call__(self): return "CELRBUSD" -CELRBUSD = CELRBUSD() +CELRETH = CELRETH() @dataclass(slots=True, frozen=True) class CELRETH: + """ + name: CELRETH + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 92141578.00000000 + margin: False + """ name: str = "CELRETH" precision: int = 8 minimum_margin: float = None @@ -11176,11 +15555,20 @@ def __call__(self): return "CELRETH" -CELRETH = CELRETH() +CELRUSDT = CELRUSDT() @dataclass(slots=True, frozen=True) class CELRUSDT: + """ + name: CELRUSDT + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 9222449.00000000 + margin: True + """ name: str = "CELRUSDT" precision: int = 8 minimum_margin: float = None @@ -11199,11 +15587,20 @@ def __call__(self): return "CELRUSDT" -CELRUSDT = CELRUSDT() +CFXBTC = CFXBTC() @dataclass(slots=True, frozen=True) class CFXBTC: + """ + name: CFXBTC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 90000000.00000000 + margin: False + """ name: str = "CFXBTC" precision: int = 8 minimum_margin: float = None @@ -11222,11 +15619,20 @@ def __call__(self): return "CFXBTC" -CFXBTC = CFXBTC() +CFXBUSD = CFXBUSD() @dataclass(slots=True, frozen=True) class CFXBUSD: + """ + name: CFXBUSD + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 9222449.00000000 + margin: False + """ name: str = "CFXBUSD" precision: int = 8 minimum_margin: float = None @@ -11245,11 +15651,20 @@ def __call__(self): return "CFXBUSD" -CFXBUSD = CFXBUSD() +CFXUSDT = CFXUSDT() @dataclass(slots=True, frozen=True) class CFXUSDT: + """ + name: CFXUSDT + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 9222449.00000000 + margin: False + """ name: str = "CFXUSDT" precision: int = 8 minimum_margin: float = None @@ -11268,11 +15683,20 @@ def __call__(self): return "CFXUSDT" -CFXUSDT = CFXUSDT() +CHATBTC = CHATBTC() @dataclass(slots=True, frozen=True) class CHATBTC: + """ + name: CHATBTC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 90000000.00000000 + margin: False + """ name: str = "CHATBTC" precision: int = 8 minimum_margin: float = None @@ -11291,11 +15715,20 @@ def __call__(self): return "CHATBTC" -CHATBTC = CHATBTC() +CHATETH = CHATETH() @dataclass(slots=True, frozen=True) class CHATETH: + """ + name: CHATETH + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 90000000.00000000 + margin: False + """ name: str = "CHATETH" precision: int = 8 minimum_margin: float = None @@ -11314,11 +15747,20 @@ def __call__(self): return "CHATETH" -CHATETH = CHATETH() +CHESSBNB = CHESSBNB() @dataclass(slots=True, frozen=True) class CHESSBNB: + """ + name: CHESSBNB + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 92141578.00000000 + margin: False + """ name: str = "CHESSBNB" precision: int = 8 minimum_margin: float = None @@ -11337,11 +15779,20 @@ def __call__(self): return "CHESSBNB" -CHESSBNB = CHESSBNB() +CHESSBTC = CHESSBTC() @dataclass(slots=True, frozen=True) class CHESSBTC: + """ + name: CHESSBTC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 92141578.00000000 + margin: False + """ name: str = "CHESSBTC" precision: int = 8 minimum_margin: float = None @@ -11360,11 +15811,20 @@ def __call__(self): return "CHESSBTC" -CHESSBTC = CHESSBTC() +CHESSBUSD = CHESSBUSD() @dataclass(slots=True, frozen=True) class CHESSBUSD: + """ + name: CHESSBUSD + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 92141578.00000000 + margin: False + """ name: str = "CHESSBUSD" precision: int = 8 minimum_margin: float = None @@ -11383,11 +15843,20 @@ def __call__(self): return "CHESSBUSD" -CHESSBUSD = CHESSBUSD() +CHESSUSDT = CHESSUSDT() @dataclass(slots=True, frozen=True) class CHESSUSDT: + """ + name: CHESSUSDT + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 92141578.00000000 + margin: False + """ name: str = "CHESSUSDT" precision: int = 8 minimum_margin: float = None @@ -11406,11 +15875,20 @@ def __call__(self): return "CHESSUSDT" -CHESSUSDT = CHESSUSDT() +CHRBNB = CHRBNB() @dataclass(slots=True, frozen=True) class CHRBNB: + """ + name: CHRBNB + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 9000000.00000000 + margin: False + """ name: str = "CHRBNB" precision: int = 8 minimum_margin: float = None @@ -11429,11 +15907,20 @@ def __call__(self): return "CHRBNB" -CHRBNB = CHRBNB() +CHRBTC = CHRBTC() @dataclass(slots=True, frozen=True) class CHRBTC: + """ + name: CHRBTC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 90000000.00000000 + margin: True + """ name: str = "CHRBTC" precision: int = 8 minimum_margin: float = None @@ -11452,11 +15939,20 @@ def __call__(self): return "CHRBTC" -CHRBTC = CHRBTC() +CHRBUSD = CHRBUSD() @dataclass(slots=True, frozen=True) class CHRBUSD: + """ + name: CHRBUSD + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 922327.00000000 + margin: True + """ name: str = "CHRBUSD" precision: int = 8 minimum_margin: float = None @@ -11475,11 +15971,20 @@ def __call__(self): return "CHRBUSD" -CHRBUSD = CHRBUSD() +CHRETH = CHRETH() @dataclass(slots=True, frozen=True) class CHRETH: + """ + name: CHRETH + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 92141578.00000000 + margin: False + """ name: str = "CHRETH" precision: int = 8 minimum_margin: float = None @@ -11498,11 +16003,20 @@ def __call__(self): return "CHRETH" -CHRETH = CHRETH() +CHRUSDT = CHRUSDT() @dataclass(slots=True, frozen=True) class CHRUSDT: + """ + name: CHRUSDT + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 9000000.00000000 + margin: True + """ name: str = "CHRUSDT" precision: int = 8 minimum_margin: float = None @@ -11521,11 +16035,20 @@ def __call__(self): return "CHRUSDT" -CHRUSDT = CHRUSDT() +CHZBNB = CHZBNB() @dataclass(slots=True, frozen=True) class CHZBNB: + """ + name: CHZBNB + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 9000000.00000000 + margin: False + """ name: str = "CHZBNB" precision: int = 8 minimum_margin: float = None @@ -11544,11 +16067,20 @@ def __call__(self): return "CHZBNB" -CHZBNB = CHZBNB() +CHZBRL = CHZBRL() @dataclass(slots=True, frozen=True) class CHZBRL: + """ + name: CHZBRL + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 9222449.00000000 + margin: False + """ name: str = "CHZBRL" precision: int = 8 minimum_margin: float = None @@ -11567,11 +16099,20 @@ def __call__(self): return "CHZBRL" -CHZBRL = CHZBRL() +CHZBTC = CHZBTC() @dataclass(slots=True, frozen=True) class CHZBTC: + """ + name: CHZBTC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 90000000.00000000 + margin: True + """ name: str = "CHZBTC" precision: int = 8 minimum_margin: float = None @@ -11590,11 +16131,20 @@ def __call__(self): return "CHZBTC" -CHZBTC = CHZBTC() +CHZBUSD = CHZBUSD() @dataclass(slots=True, frozen=True) class CHZBUSD: + """ + name: CHZBUSD + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 900000.00000000 + margin: False + """ name: str = "CHZBUSD" precision: int = 8 minimum_margin: float = None @@ -11613,11 +16163,20 @@ def __call__(self): return "CHZBUSD" -CHZBUSD = CHZBUSD() +CHZEUR = CHZEUR() @dataclass(slots=True, frozen=True) class CHZEUR: + """ + name: CHZEUR + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 900000.00000000 + margin: False + """ name: str = "CHZEUR" precision: int = 8 minimum_margin: float = None @@ -11636,11 +16195,20 @@ def __call__(self): return "CHZEUR" -CHZEUR = CHZEUR() +CHZGBP = CHZGBP() @dataclass(slots=True, frozen=True) class CHZGBP: + """ + name: CHZGBP + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 900000.00000000 + margin: False + """ name: str = "CHZGBP" precision: int = 8 minimum_margin: float = None @@ -11659,11 +16227,20 @@ def __call__(self): return "CHZGBP" -CHZGBP = CHZGBP() +CHZTRY = CHZTRY() @dataclass(slots=True, frozen=True) class CHZTRY: + """ + name: CHZTRY + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 92141578.00000000 + margin: False + """ name: str = "CHZTRY" precision: int = 8 minimum_margin: float = None @@ -11682,11 +16259,20 @@ def __call__(self): return "CHZTRY" -CHZTRY = CHZTRY() +CHZUSDT = CHZUSDT() @dataclass(slots=True, frozen=True) class CHZUSDT: + """ + name: CHZUSDT + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 9000000.00000000 + margin: True + """ name: str = "CHZUSDT" precision: int = 8 minimum_margin: float = None @@ -11705,11 +16291,20 @@ def __call__(self): return "CHZUSDT" -CHZUSDT = CHZUSDT() +CITYBNB = CITYBNB() @dataclass(slots=True, frozen=True) class CITYBNB: + """ + name: CITYBNB + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 92141578.00000000 + margin: False + """ name: str = "CITYBNB" precision: int = 8 minimum_margin: float = None @@ -11728,11 +16323,20 @@ def __call__(self): return "CITYBNB" -CITYBNB = CITYBNB() +CITYBTC = CITYBTC() @dataclass(slots=True, frozen=True) class CITYBTC: + """ + name: CITYBTC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 92141578.00000000 + margin: False + """ name: str = "CITYBTC" precision: int = 8 minimum_margin: float = None @@ -11751,11 +16355,20 @@ def __call__(self): return "CITYBTC" -CITYBTC = CITYBTC() +CITYBUSD = CITYBUSD() @dataclass(slots=True, frozen=True) class CITYBUSD: + """ + name: CITYBUSD + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 9222449.00000000 + margin: False + """ name: str = "CITYBUSD" precision: int = 8 minimum_margin: float = None @@ -11774,11 +16387,20 @@ def __call__(self): return "CITYBUSD" -CITYBUSD = CITYBUSD() +CITYUSDT = CITYUSDT() @dataclass(slots=True, frozen=True) class CITYUSDT: + """ + name: CITYUSDT + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 9222449.00000000 + margin: False + """ name: str = "CITYUSDT" precision: int = 8 minimum_margin: float = None @@ -11797,11 +16419,20 @@ def __call__(self): return "CITYUSDT" -CITYUSDT = CITYUSDT() +CKBBTC = CKBBTC() @dataclass(slots=True, frozen=True) class CKBBTC: + """ + name: CKBBTC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 90000000.00000000 + margin: False + """ name: str = "CKBBTC" precision: int = 8 minimum_margin: float = None @@ -11820,11 +16451,20 @@ def __call__(self): return "CKBBTC" -CKBBTC = CKBBTC() +CKBBUSD = CKBBUSD() @dataclass(slots=True, frozen=True) class CKBBUSD: + """ + name: CKBBUSD + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 92141578.00000000 + margin: False + """ name: str = "CKBBUSD" precision: int = 8 minimum_margin: float = None @@ -11843,11 +16483,20 @@ def __call__(self): return "CKBBUSD" -CKBBUSD = CKBBUSD() +CKBUSDT = CKBUSDT() @dataclass(slots=True, frozen=True) class CKBUSDT: + """ + name: CKBUSDT + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 92141578.00000000 + margin: True + """ name: str = "CKBUSDT" precision: int = 8 minimum_margin: float = None @@ -11866,11 +16515,20 @@ def __call__(self): return "CKBUSDT" -CKBUSDT = CKBUSDT() +CLOAKBTC = CLOAKBTC() @dataclass(slots=True, frozen=True) class CLOAKBTC: + """ + name: CLOAKBTC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 90000000.00000000 + margin: False + """ name: str = "CLOAKBTC" precision: int = 8 minimum_margin: float = None @@ -11889,11 +16547,20 @@ def __call__(self): return "CLOAKBTC" -CLOAKBTC = CLOAKBTC() +CLOAKETH = CLOAKETH() @dataclass(slots=True, frozen=True) class CLOAKETH: + """ + name: CLOAKETH + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 90000000.00000000 + margin: False + """ name: str = "CLOAKETH" precision: int = 8 minimum_margin: float = None @@ -11912,11 +16579,20 @@ def __call__(self): return "CLOAKETH" -CLOAKETH = CLOAKETH() +CLVBNB = CLVBNB() @dataclass(slots=True, frozen=True) class CLVBNB: + """ + name: CLVBNB + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 92141578.00000000 + margin: False + """ name: str = "CLVBNB" precision: int = 8 minimum_margin: float = None @@ -11935,11 +16611,20 @@ def __call__(self): return "CLVBNB" -CLVBNB = CLVBNB() +CLVBTC = CLVBTC() @dataclass(slots=True, frozen=True) class CLVBTC: + """ + name: CLVBTC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 92141578.00000000 + margin: True + """ name: str = "CLVBTC" precision: int = 8 minimum_margin: float = None @@ -11958,11 +16643,20 @@ def __call__(self): return "CLVBTC" -CLVBTC = CLVBTC() +CLVBUSD = CLVBUSD() @dataclass(slots=True, frozen=True) class CLVBUSD: + """ + name: CLVBUSD + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 92141578.00000000 + margin: True + """ name: str = "CLVBUSD" precision: int = 8 minimum_margin: float = None @@ -11981,11 +16675,20 @@ def __call__(self): return "CLVBUSD" -CLVBUSD = CLVBUSD() +CLVUSDT = CLVUSDT() @dataclass(slots=True, frozen=True) class CLVUSDT: + """ + name: CLVUSDT + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 92141578.00000000 + margin: True + """ name: str = "CLVUSDT" precision: int = 8 minimum_margin: float = None @@ -12004,11 +16707,20 @@ def __call__(self): return "CLVUSDT" -CLVUSDT = CLVUSDT() +CMTBNB = CMTBNB() @dataclass(slots=True, frozen=True) class CMTBNB: + """ + name: CMTBNB + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 9000000.00000000 + margin: False + """ name: str = "CMTBNB" precision: int = 8 minimum_margin: float = None @@ -12027,11 +16739,20 @@ def __call__(self): return "CMTBNB" -CMTBNB = CMTBNB() +CMTBTC = CMTBTC() @dataclass(slots=True, frozen=True) class CMTBTC: + """ + name: CMTBTC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 90000000.00000000 + margin: False + """ name: str = "CMTBTC" precision: int = 8 minimum_margin: float = None @@ -12050,11 +16771,20 @@ def __call__(self): return "CMTBTC" -CMTBTC = CMTBTC() +CMTETH = CMTETH() @dataclass(slots=True, frozen=True) class CMTETH: + """ + name: CMTETH + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 90000000.00000000 + margin: False + """ name: str = "CMTETH" precision: int = 8 minimum_margin: float = None @@ -12073,11 +16803,20 @@ def __call__(self): return "CMTETH" -CMTETH = CMTETH() +CNDBNB = CNDBNB() @dataclass(slots=True, frozen=True) class CNDBNB: + """ + name: CNDBNB + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 9000000.00000000 + margin: False + """ name: str = "CNDBNB" precision: int = 8 minimum_margin: float = None @@ -12096,11 +16835,20 @@ def __call__(self): return "CNDBNB" -CNDBNB = CNDBNB() +CNDBTC = CNDBTC() @dataclass(slots=True, frozen=True) class CNDBTC: + """ + name: CNDBTC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 90000000.00000000 + margin: False + """ name: str = "CNDBTC" precision: int = 8 minimum_margin: float = None @@ -12119,11 +16867,20 @@ def __call__(self): return "CNDBTC" -CNDBTC = CNDBTC() +CNDETH = CNDETH() @dataclass(slots=True, frozen=True) class CNDETH: + """ + name: CNDETH + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 90000000.00000000 + margin: False + """ name: str = "CNDETH" precision: int = 8 minimum_margin: float = None @@ -12142,11 +16899,20 @@ def __call__(self): return "CNDETH" -CNDETH = CNDETH() +COCOSBNB = COCOSBNB() @dataclass(slots=True, frozen=True) class COCOSBNB: + """ + name: COCOSBNB + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 9000000.00000000 + margin: False + """ name: str = "COCOSBNB" precision: int = 8 minimum_margin: float = None @@ -12165,11 +16931,20 @@ def __call__(self): return "COCOSBNB" -COCOSBNB = COCOSBNB() +COCOSBTC = COCOSBTC() @dataclass(slots=True, frozen=True) class COCOSBTC: + """ + name: COCOSBTC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 90000000.00000000 + margin: False + """ name: str = "COCOSBTC" precision: int = 8 minimum_margin: float = None @@ -12188,11 +16963,20 @@ def __call__(self): return "COCOSBTC" -COCOSBTC = COCOSBTC() +COCOSBUSD = COCOSBUSD() @dataclass(slots=True, frozen=True) class COCOSBUSD: + """ + name: COCOSBUSD + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 92141578.00000000 + margin: False + """ name: str = "COCOSBUSD" precision: int = 8 minimum_margin: float = None @@ -12211,11 +16995,20 @@ def __call__(self): return "COCOSBUSD" -COCOSBUSD = COCOSBUSD() +COCOSTRY = COCOSTRY() @dataclass(slots=True, frozen=True) class COCOSTRY: + """ + name: COCOSTRY + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 9222449.00000000 + margin: False + """ name: str = "COCOSTRY" precision: int = 8 minimum_margin: float = None @@ -12234,11 +17027,20 @@ def __call__(self): return "COCOSTRY" -COCOSTRY = COCOSTRY() +COCOSUSDT = COCOSUSDT() @dataclass(slots=True, frozen=True) class COCOSUSDT: + """ + name: COCOSUSDT + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 900000.00000000 + margin: False + """ name: str = "COCOSUSDT" precision: int = 8 minimum_margin: float = None @@ -12257,11 +17059,20 @@ def __call__(self): return "COCOSUSDT" -COCOSUSDT = COCOSUSDT() +COMPBNB = COMPBNB() @dataclass(slots=True, frozen=True) class COMPBNB: + """ + name: COMPBNB + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.00100000 + maximum_order_size: 900000.00000000 + margin: False + """ name: str = "COMPBNB" precision: int = 8 minimum_margin: float = None @@ -12280,11 +17091,20 @@ def __call__(self): return "COMPBNB" -COMPBNB = COMPBNB() +COMPBTC = COMPBTC() @dataclass(slots=True, frozen=True) class COMPBTC: + """ + name: COMPBTC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.00100000 + maximum_order_size: 10000000.00000000 + margin: True + """ name: str = "COMPBTC" precision: int = 8 minimum_margin: float = None @@ -12303,11 +17123,20 @@ def __call__(self): return "COMPBTC" -COMPBTC = COMPBTC() +COMPBUSD = COMPBUSD() @dataclass(slots=True, frozen=True) class COMPBUSD: + """ + name: COMPBUSD + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.00100000 + maximum_order_size: 90000.00000000 + margin: True + """ name: str = "COMPBUSD" precision: int = 8 minimum_margin: float = None @@ -12326,11 +17155,20 @@ def __call__(self): return "COMPBUSD" -COMPBUSD = COMPBUSD() +COMPUSDT = COMPUSDT() @dataclass(slots=True, frozen=True) class COMPUSDT: + """ + name: COMPUSDT + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.00100000 + maximum_order_size: 90000.00000000 + margin: True + """ name: str = "COMPUSDT" precision: int = 8 minimum_margin: float = None @@ -12349,11 +17187,20 @@ def __call__(self): return "COMPUSDT" -COMPUSDT = COMPUSDT() +COSBNB = COSBNB() @dataclass(slots=True, frozen=True) class COSBNB: + """ + name: COSBNB + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 90000000.00000000 + margin: False + """ name: str = "COSBNB" precision: int = 8 minimum_margin: float = None @@ -12372,11 +17219,20 @@ def __call__(self): return "COSBNB" -COSBNB = COSBNB() +COSBTC = COSBTC() @dataclass(slots=True, frozen=True) class COSBTC: + """ + name: COSBTC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 90000000.00000000 + margin: True + """ name: str = "COSBTC" precision: int = 8 minimum_margin: float = None @@ -12395,11 +17251,20 @@ def __call__(self): return "COSBTC" -COSBTC = COSBTC() +COSBUSD = COSBUSD() @dataclass(slots=True, frozen=True) class COSBUSD: + """ + name: COSBUSD + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 92141578.00000000 + margin: False + """ name: str = "COSBUSD" precision: int = 8 minimum_margin: float = None @@ -12418,11 +17283,20 @@ def __call__(self): return "COSBUSD" -COSBUSD = COSBUSD() +COSTRY = COSTRY() @dataclass(slots=True, frozen=True) class COSTRY: + """ + name: COSTRY + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 92141578.00000000 + margin: False + """ name: str = "COSTRY" precision: int = 8 minimum_margin: float = None @@ -12441,11 +17315,20 @@ def __call__(self): return "COSTRY" -COSTRY = COSTRY() +COSUSDT = COSUSDT() @dataclass(slots=True, frozen=True) class COSUSDT: + """ + name: COSUSDT + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 18443055.00000000 + margin: True + """ name: str = "COSUSDT" precision: int = 8 minimum_margin: float = None @@ -12464,11 +17347,20 @@ def __call__(self): return "COSUSDT" -COSUSDT = COSUSDT() +COTIBNB = COTIBNB() @dataclass(slots=True, frozen=True) class COTIBNB: + """ + name: COTIBNB + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 9000000.00000000 + margin: False + """ name: str = "COTIBNB" precision: int = 8 minimum_margin: float = None @@ -12487,11 +17379,20 @@ def __call__(self): return "COTIBNB" -COTIBNB = COTIBNB() +COTIBTC = COTIBTC() @dataclass(slots=True, frozen=True) class COTIBTC: + """ + name: COTIBTC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 90000000.00000000 + margin: True + """ name: str = "COTIBTC" precision: int = 8 minimum_margin: float = None @@ -12510,11 +17411,20 @@ def __call__(self): return "COTIBTC" -COTIBTC = COTIBTC() +COTIBUSD = COTIBUSD() @dataclass(slots=True, frozen=True) class COTIBUSD: + """ + name: COTIBUSD + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 9222449.00000000 + margin: True + """ name: str = "COTIBUSD" precision: int = 8 minimum_margin: float = None @@ -12533,11 +17443,20 @@ def __call__(self): return "COTIBUSD" -COTIBUSD = COTIBUSD() +COTIUSDT = COTIUSDT() @dataclass(slots=True, frozen=True) class COTIUSDT: + """ + name: COTIUSDT + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 9000000.00000000 + margin: True + """ name: str = "COTIUSDT" precision: int = 8 minimum_margin: float = None @@ -12556,11 +17475,20 @@ def __call__(self): return "COTIUSDT" -COTIUSDT = COTIUSDT() +COVERBUSD = COVERBUSD() @dataclass(slots=True, frozen=True) class COVERBUSD: + """ + name: COVERBUSD + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.00100000 + maximum_order_size: 90000.00000000 + margin: False + """ name: str = "COVERBUSD" precision: int = 8 minimum_margin: float = None @@ -12579,11 +17507,20 @@ def __call__(self): return "COVERBUSD" -COVERBUSD = COVERBUSD() +COVERETH = COVERETH() @dataclass(slots=True, frozen=True) class COVERETH: + """ + name: COVERETH + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.00100000 + maximum_order_size: 92141578.00000000 + margin: False + """ name: str = "COVERETH" precision: int = 8 minimum_margin: float = None @@ -12602,11 +17539,20 @@ def __call__(self): return "COVERETH" -COVERETH = COVERETH() +CREAMBNB = CREAMBNB() @dataclass(slots=True, frozen=True) class CREAMBNB: + """ + name: CREAMBNB + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.00100000 + maximum_order_size: 900000.00000000 + margin: False + """ name: str = "CREAMBNB" precision: int = 8 minimum_margin: float = None @@ -12625,11 +17571,20 @@ def __call__(self): return "CREAMBNB" -CREAMBNB = CREAMBNB() +CREAMBUSD = CREAMBUSD() @dataclass(slots=True, frozen=True) class CREAMBUSD: + """ + name: CREAMBUSD + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.00100000 + maximum_order_size: 900000.00000000 + margin: True + """ name: str = "CREAMBUSD" precision: int = 8 minimum_margin: float = None @@ -12648,11 +17603,20 @@ def __call__(self): return "CREAMBUSD" -CREAMBUSD = CREAMBUSD() +CRVBNB = CRVBNB() @dataclass(slots=True, frozen=True) class CRVBNB: + """ + name: CRVBNB + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 9000000.00000000 + margin: False + """ name: str = "CRVBNB" precision: int = 8 minimum_margin: float = None @@ -12671,11 +17635,20 @@ def __call__(self): return "CRVBNB" -CRVBNB = CRVBNB() +CRVBTC = CRVBTC() @dataclass(slots=True, frozen=True) class CRVBTC: + """ + name: CRVBTC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 9000000.00000000 + margin: True + """ name: str = "CRVBTC" precision: int = 8 minimum_margin: float = None @@ -12694,11 +17667,20 @@ def __call__(self): return "CRVBTC" -CRVBTC = CRVBTC() +CRVBUSD = CRVBUSD() @dataclass(slots=True, frozen=True) class CRVBUSD: + """ + name: CRVBUSD + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 922327.00000000 + margin: True + """ name: str = "CRVBUSD" precision: int = 8 minimum_margin: float = None @@ -12717,11 +17699,20 @@ def __call__(self): return "CRVBUSD" -CRVBUSD = CRVBUSD() +CRVETH = CRVETH() @dataclass(slots=True, frozen=True) class CRVETH: + """ + name: CRVETH + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 92141578.00000000 + margin: False + """ name: str = "CRVETH" precision: int = 8 minimum_margin: float = None @@ -12740,11 +17731,20 @@ def __call__(self): return "CRVETH" -CRVETH = CRVETH() +CRVUSDT = CRVUSDT() @dataclass(slots=True, frozen=True) class CRVUSDT: + """ + name: CRVUSDT + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 922327.00000000 + margin: True + """ name: str = "CRVUSDT" precision: int = 8 minimum_margin: float = None @@ -12763,11 +17763,20 @@ def __call__(self): return "CRVUSDT" -CRVUSDT = CRVUSDT() +CTKBNB = CTKBNB() @dataclass(slots=True, frozen=True) class CTKBNB: + """ + name: CTKBNB + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 9000000.00000000 + margin: False + """ name: str = "CTKBNB" precision: int = 8 minimum_margin: float = None @@ -12786,11 +17795,20 @@ def __call__(self): return "CTKBNB" -CTKBNB = CTKBNB() +CTKBTC = CTKBTC() @dataclass(slots=True, frozen=True) class CTKBTC: + """ + name: CTKBTC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 90000000.00000000 + margin: False + """ name: str = "CTKBTC" precision: int = 8 minimum_margin: float = None @@ -12809,11 +17827,20 @@ def __call__(self): return "CTKBTC" -CTKBTC = CTKBTC() +CTKBUSD = CTKBUSD() @dataclass(slots=True, frozen=True) class CTKBUSD: + """ + name: CTKBUSD + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 900000.00000000 + margin: False + """ name: str = "CTKBUSD" precision: int = 8 minimum_margin: float = None @@ -12832,11 +17859,20 @@ def __call__(self): return "CTKBUSD" -CTKBUSD = CTKBUSD() +CTKUSDT = CTKUSDT() @dataclass(slots=True, frozen=True) class CTKUSDT: + """ + name: CTKUSDT + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 900000.00000000 + margin: True + """ name: str = "CTKUSDT" precision: int = 8 minimum_margin: float = None @@ -12855,11 +17891,20 @@ def __call__(self): return "CTKUSDT" -CTKUSDT = CTKUSDT() +CTSIBNB = CTSIBNB() @dataclass(slots=True, frozen=True) class CTSIBNB: + """ + name: CTSIBNB + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 9000000.00000000 + margin: False + """ name: str = "CTSIBNB" precision: int = 8 minimum_margin: float = None @@ -12878,11 +17923,20 @@ def __call__(self): return "CTSIBNB" -CTSIBNB = CTSIBNB() +CTSIBTC = CTSIBTC() @dataclass(slots=True, frozen=True) class CTSIBTC: + """ + name: CTSIBTC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 90000000.00000000 + margin: True + """ name: str = "CTSIBTC" precision: int = 8 minimum_margin: float = None @@ -12901,11 +17955,20 @@ def __call__(self): return "CTSIBTC" -CTSIBTC = CTSIBTC() +CTSIBUSD = CTSIBUSD() @dataclass(slots=True, frozen=True) class CTSIBUSD: + """ + name: CTSIBUSD + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 9000000.00000000 + margin: False + """ name: str = "CTSIBUSD" precision: int = 8 minimum_margin: float = None @@ -12924,11 +17987,20 @@ def __call__(self): return "CTSIBUSD" -CTSIBUSD = CTSIBUSD() +CTSIUSDT = CTSIUSDT() @dataclass(slots=True, frozen=True) class CTSIUSDT: + """ + name: CTSIUSDT + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 9000000.00000000 + margin: True + """ name: str = "CTSIUSDT" precision: int = 8 minimum_margin: float = None @@ -12947,11 +18019,20 @@ def __call__(self): return "CTSIUSDT" -CTSIUSDT = CTSIUSDT() +CTXCBNB = CTXCBNB() @dataclass(slots=True, frozen=True) class CTXCBNB: + """ + name: CTXCBNB + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 9000000.00000000 + margin: False + """ name: str = "CTXCBNB" precision: int = 8 minimum_margin: float = None @@ -12970,11 +18051,20 @@ def __call__(self): return "CTXCBNB" -CTXCBNB = CTXCBNB() +CTXCBTC = CTXCBTC() @dataclass(slots=True, frozen=True) class CTXCBTC: + """ + name: CTXCBTC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 90000000.00000000 + margin: True + """ name: str = "CTXCBTC" precision: int = 8 minimum_margin: float = None @@ -12993,11 +18083,20 @@ def __call__(self): return "CTXCBTC" -CTXCBTC = CTXCBTC() +CTXCBUSD = CTXCBUSD() @dataclass(slots=True, frozen=True) class CTXCBUSD: + """ + name: CTXCBUSD + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 92141578.00000000 + margin: True + """ name: str = "CTXCBUSD" precision: int = 8 minimum_margin: float = None @@ -13016,11 +18115,20 @@ def __call__(self): return "CTXCBUSD" -CTXCBUSD = CTXCBUSD() +CTXCUSDT = CTXCUSDT() @dataclass(slots=True, frozen=True) class CTXCUSDT: + """ + name: CTXCUSDT + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 9222449.00000000 + margin: True + """ name: str = "CTXCUSDT" precision: int = 8 minimum_margin: float = None @@ -13039,11 +18147,20 @@ def __call__(self): return "CTXCUSDT" -CTXCUSDT = CTXCUSDT() +CVCBNB = CVCBNB() @dataclass(slots=True, frozen=True) class CVCBNB: + """ + name: CVCBNB + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 9000000.00000000 + margin: False + """ name: str = "CVCBNB" precision: int = 8 minimum_margin: float = None @@ -13062,11 +18179,20 @@ def __call__(self): return "CVCBNB" -CVCBNB = CVCBNB() +CVCBTC = CVCBTC() @dataclass(slots=True, frozen=True) class CVCBTC: + """ + name: CVCBTC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 90000000.00000000 + margin: False + """ name: str = "CVCBTC" precision: int = 8 minimum_margin: float = None @@ -13085,11 +18211,20 @@ def __call__(self): return "CVCBTC" -CVCBTC = CVCBTC() +CVCBUSD = CVCBUSD() @dataclass(slots=True, frozen=True) class CVCBUSD: + """ + name: CVCBUSD + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 9000000.00000000 + margin: False + """ name: str = "CVCBUSD" precision: int = 8 minimum_margin: float = None @@ -13108,11 +18243,20 @@ def __call__(self): return "CVCBUSD" -CVCBUSD = CVCBUSD() +CVCETH = CVCETH() @dataclass(slots=True, frozen=True) class CVCETH: + """ + name: CVCETH + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 90000000.00000000 + margin: False + """ name: str = "CVCETH" precision: int = 8 minimum_margin: float = None @@ -13131,11 +18275,20 @@ def __call__(self): return "CVCETH" -CVCETH = CVCETH() +CVCUSDT = CVCUSDT() @dataclass(slots=True, frozen=True) class CVCUSDT: + """ + name: CVCUSDT + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 9000000.00000000 + margin: False + """ name: str = "CVCUSDT" precision: int = 8 minimum_margin: float = None @@ -13154,11 +18307,20 @@ def __call__(self): return "CVCUSDT" -CVCUSDT = CVCUSDT() +CVPBUSD = CVPBUSD() @dataclass(slots=True, frozen=True) class CVPBUSD: + """ + name: CVPBUSD + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 900000.00000000 + margin: False + """ name: str = "CVPBUSD" precision: int = 8 minimum_margin: float = None @@ -13177,11 +18339,20 @@ def __call__(self): return "CVPBUSD" -CVPBUSD = CVPBUSD() +CVPETH = CVPETH() @dataclass(slots=True, frozen=True) class CVPETH: + """ + name: CVPETH + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 92141578.00000000 + margin: False + """ name: str = "CVPETH" precision: int = 8 minimum_margin: float = None @@ -13200,11 +18371,20 @@ def __call__(self): return "CVPETH" -CVPETH = CVPETH() +CVPUSDT = CVPUSDT() @dataclass(slots=True, frozen=True) class CVPUSDT: + """ + name: CVPUSDT + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 92141578.00000000 + margin: False + """ name: str = "CVPUSDT" precision: int = 8 minimum_margin: float = None @@ -13223,11 +18403,20 @@ def __call__(self): return "CVPUSDT" -CVPUSDT = CVPUSDT() +CVXBTC = CVXBTC() @dataclass(slots=True, frozen=True) class CVXBTC: + """ + name: CVXBTC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.00100000 + maximum_order_size: 92141578.00000000 + margin: False + """ name: str = "CVXBTC" precision: int = 8 minimum_margin: float = None @@ -13246,11 +18435,20 @@ def __call__(self): return "CVXBTC" -CVXBTC = CVXBTC() +CVXBUSD = CVXBUSD() @dataclass(slots=True, frozen=True) class CVXBUSD: + """ + name: CVXBUSD + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.00100000 + maximum_order_size: 9222449.00000000 + margin: False + """ name: str = "CVXBUSD" precision: int = 8 minimum_margin: float = None @@ -13269,11 +18467,20 @@ def __call__(self): return "CVXBUSD" -CVXBUSD = CVXBUSD() +CVXUSDT = CVXUSDT() @dataclass(slots=True, frozen=True) class CVXUSDT: + """ + name: CVXUSDT + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.00100000 + maximum_order_size: 9222449.00000000 + margin: False + """ name: str = "CVXUSDT" precision: int = 8 minimum_margin: float = None @@ -13292,11 +18499,20 @@ def __call__(self): return "CVXUSDT" -CVXUSDT = CVXUSDT() +DAIBNB = DAIBNB() @dataclass(slots=True, frozen=True) class DAIBNB: + """ + name: DAIBNB + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 9000000.00000000 + margin: False + """ name: str = "DAIBNB" precision: int = 8 minimum_margin: float = None @@ -13315,11 +18531,20 @@ def __call__(self): return "DAIBNB" -DAIBNB = DAIBNB() +DAIBTC = DAIBTC() @dataclass(slots=True, frozen=True) class DAIBTC: + """ + name: DAIBTC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 90000000.00000000 + margin: False + """ name: str = "DAIBTC" precision: int = 8 minimum_margin: float = None @@ -13338,11 +18563,20 @@ def __call__(self): return "DAIBTC" -DAIBTC = DAIBTC() +DAIBUSD = DAIBUSD() @dataclass(slots=True, frozen=True) class DAIBUSD: + """ + name: DAIBUSD + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 900000.00000000 + margin: False + """ name: str = "DAIBUSD" precision: int = 8 minimum_margin: float = None @@ -13361,11 +18595,20 @@ def __call__(self): return "DAIBUSD" -DAIBUSD = DAIBUSD() +DAIUSDT = DAIUSDT() @dataclass(slots=True, frozen=True) class DAIUSDT: + """ + name: DAIUSDT + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 900000.00000000 + margin: False + """ name: str = "DAIUSDT" precision: int = 8 minimum_margin: float = None @@ -13384,11 +18627,20 @@ def __call__(self): return "DAIUSDT" -DAIUSDT = DAIUSDT() +DARBNB = DARBNB() @dataclass(slots=True, frozen=True) class DARBNB: + """ + name: DARBNB + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 92141578.00000000 + margin: False + """ name: str = "DARBNB" precision: int = 8 minimum_margin: float = None @@ -13407,11 +18659,20 @@ def __call__(self): return "DARBNB" -DARBNB = DARBNB() +DARBTC = DARBTC() @dataclass(slots=True, frozen=True) class DARBTC: + """ + name: DARBTC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 92141578.00000000 + margin: True + """ name: str = "DARBTC" precision: int = 8 minimum_margin: float = None @@ -13430,11 +18691,20 @@ def __call__(self): return "DARBTC" -DARBTC = DARBTC() +DARBUSD = DARBUSD() @dataclass(slots=True, frozen=True) class DARBUSD: + """ + name: DARBUSD + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 92141578.00000000 + margin: True + """ name: str = "DARBUSD" precision: int = 8 minimum_margin: float = None @@ -13453,11 +18723,20 @@ def __call__(self): return "DARBUSD" -DARBUSD = DARBUSD() +DARETH = DARETH() @dataclass(slots=True, frozen=True) class DARETH: + """ + name: DARETH + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 92141578.00000000 + margin: False + """ name: str = "DARETH" precision: int = 8 minimum_margin: float = None @@ -13476,11 +18755,20 @@ def __call__(self): return "DARETH" -DARETH = DARETH() +DAREUR = DAREUR() @dataclass(slots=True, frozen=True) class DAREUR: + """ + name: DAREUR + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 92141578.00000000 + margin: False + """ name: str = "DAREUR" precision: int = 8 minimum_margin: float = None @@ -13499,11 +18787,20 @@ def __call__(self): return "DAREUR" -DAREUR = DAREUR() +DARTRY = DARTRY() @dataclass(slots=True, frozen=True) class DARTRY: + """ + name: DARTRY + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 9222449.00000000 + margin: False + """ name: str = "DARTRY" precision: int = 8 minimum_margin: float = None @@ -13522,11 +18819,20 @@ def __call__(self): return "DARTRY" -DARTRY = DARTRY() +DARUSDT = DARUSDT() @dataclass(slots=True, frozen=True) class DARUSDT: + """ + name: DARUSDT + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 92141578.00000000 + margin: True + """ name: str = "DARUSDT" precision: int = 8 minimum_margin: float = None @@ -13545,11 +18851,20 @@ def __call__(self): return "DARUSDT" -DARUSDT = DARUSDT() +DASHBNB = DASHBNB() @dataclass(slots=True, frozen=True) class DASHBNB: + """ + name: DASHBNB + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.00100000 + maximum_order_size: 900000.00000000 + margin: False + """ name: str = "DASHBNB" precision: int = 8 minimum_margin: float = None @@ -13568,11 +18883,20 @@ def __call__(self): return "DASHBNB" -DASHBNB = DASHBNB() +DASHBTC = DASHBTC() @dataclass(slots=True, frozen=True) class DASHBTC: + """ + name: DASHBTC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.00100000 + maximum_order_size: 10000000.00000000 + margin: True + """ name: str = "DASHBTC" precision: int = 8 minimum_margin: float = None @@ -13591,11 +18915,20 @@ def __call__(self): return "DASHBTC" -DASHBTC = DASHBTC() +DASHBUSD = DASHBUSD() @dataclass(slots=True, frozen=True) class DASHBUSD: + """ + name: DASHBUSD + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.00100000 + maximum_order_size: 90000.00000000 + margin: True + """ name: str = "DASHBUSD" precision: int = 8 minimum_margin: float = None @@ -13614,11 +18947,20 @@ def __call__(self): return "DASHBUSD" -DASHBUSD = DASHBUSD() +DASHETH = DASHETH() @dataclass(slots=True, frozen=True) class DASHETH: + """ + name: DASHETH + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.00100000 + maximum_order_size: 9000000.00000000 + margin: False + """ name: str = "DASHETH" precision: int = 8 minimum_margin: float = None @@ -13637,11 +18979,20 @@ def __call__(self): return "DASHETH" -DASHETH = DASHETH() +DASHUSDT = DASHUSDT() @dataclass(slots=True, frozen=True) class DASHUSDT: + """ + name: DASHUSDT + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.00100000 + maximum_order_size: 90000.00000000 + margin: True + """ name: str = "DASHUSDT" precision: int = 8 minimum_margin: float = None @@ -13660,11 +19011,20 @@ def __call__(self): return "DASHUSDT" -DASHUSDT = DASHUSDT() +DATABTC = DATABTC() @dataclass(slots=True, frozen=True) class DATABTC: + """ + name: DATABTC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 90000000.00000000 + margin: False + """ name: str = "DATABTC" precision: int = 8 minimum_margin: float = None @@ -13683,11 +19043,20 @@ def __call__(self): return "DATABTC" -DATABTC = DATABTC() +DATABUSD = DATABUSD() @dataclass(slots=True, frozen=True) class DATABUSD: + """ + name: DATABUSD + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 9000000.00000000 + margin: True + """ name: str = "DATABUSD" precision: int = 8 minimum_margin: float = None @@ -13706,11 +19075,20 @@ def __call__(self): return "DATABUSD" -DATABUSD = DATABUSD() +DATAETH = DATAETH() @dataclass(slots=True, frozen=True) class DATAETH: + """ + name: DATAETH + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 90000000.00000000 + margin: False + """ name: str = "DATAETH" precision: int = 8 minimum_margin: float = None @@ -13729,11 +19107,20 @@ def __call__(self): return "DATAETH" -DATAETH = DATAETH() +DATAUSDT = DATAUSDT() @dataclass(slots=True, frozen=True) class DATAUSDT: + """ + name: DATAUSDT + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 9000000.00000000 + margin: True + """ name: str = "DATAUSDT" precision: int = 8 minimum_margin: float = None @@ -13752,11 +19139,20 @@ def __call__(self): return "DATAUSDT" -DATAUSDT = DATAUSDT() +DCRBNB = DCRBNB() @dataclass(slots=True, frozen=True) class DCRBNB: + """ + name: DCRBNB + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.00100000 + maximum_order_size: 900000.00000000 + margin: False + """ name: str = "DCRBNB" precision: int = 8 minimum_margin: float = None @@ -13775,11 +19171,20 @@ def __call__(self): return "DCRBNB" -DCRBNB = DCRBNB() +DCRBTC = DCRBTC() @dataclass(slots=True, frozen=True) class DCRBTC: + """ + name: DCRBTC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.00100000 + maximum_order_size: 10000000.00000000 + margin: False + """ name: str = "DCRBTC" precision: int = 8 minimum_margin: float = None @@ -13798,11 +19203,20 @@ def __call__(self): return "DCRBTC" -DCRBTC = DCRBTC() +DCRBUSD = DCRBUSD() @dataclass(slots=True, frozen=True) class DCRBUSD: + """ + name: DCRBUSD + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.00100000 + maximum_order_size: 90000.00000000 + margin: False + """ name: str = "DCRBUSD" precision: int = 8 minimum_margin: float = None @@ -13821,11 +19235,20 @@ def __call__(self): return "DCRBUSD" -DCRBUSD = DCRBUSD() +DCRUSDT = DCRUSDT() @dataclass(slots=True, frozen=True) class DCRUSDT: + """ + name: DCRUSDT + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.00100000 + maximum_order_size: 900000.00000000 + margin: False + """ name: str = "DCRUSDT" precision: int = 8 minimum_margin: float = None @@ -13844,11 +19267,20 @@ def __call__(self): return "DCRUSDT" -DCRUSDT = DCRUSDT() +DEGOBTC = DEGOBTC() @dataclass(slots=True, frozen=True) class DEGOBTC: + """ + name: DEGOBTC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 90000000.00000000 + margin: False + """ name: str = "DEGOBTC" precision: int = 8 minimum_margin: float = None @@ -13867,11 +19299,20 @@ def __call__(self): return "DEGOBTC" -DEGOBTC = DEGOBTC() +DEGOBUSD = DEGOBUSD() @dataclass(slots=True, frozen=True) class DEGOBUSD: + """ + name: DEGOBUSD + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 90000.00000000 + margin: True + """ name: str = "DEGOBUSD" precision: int = 8 minimum_margin: float = None @@ -13890,11 +19331,20 @@ def __call__(self): return "DEGOBUSD" -DEGOBUSD = DEGOBUSD() +DEGOUSDT = DEGOUSDT() @dataclass(slots=True, frozen=True) class DEGOUSDT: + """ + name: DEGOUSDT + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 90000.00000000 + margin: True + """ name: str = "DEGOUSDT" precision: int = 8 minimum_margin: float = None @@ -13913,11 +19363,20 @@ def __call__(self): return "DEGOUSDT" -DEGOUSDT = DEGOUSDT() +DENTBTC = DENTBTC() @dataclass(slots=True, frozen=True) class DENTBTC: + """ + name: DENTBTC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 92141578.00000000 + margin: False + """ name: str = "DENTBTC" precision: int = 8 minimum_margin: float = None @@ -13936,11 +19395,20 @@ def __call__(self): return "DENTBTC" -DENTBTC = DENTBTC() +DENTBUSD = DENTBUSD() @dataclass(slots=True, frozen=True) class DENTBUSD: + """ + name: DENTBUSD + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 92141578.00000000 + margin: False + """ name: str = "DENTBUSD" precision: int = 8 minimum_margin: float = None @@ -13959,11 +19427,20 @@ def __call__(self): return "DENTBUSD" -DENTBUSD = DENTBUSD() +DENTETH = DENTETH() @dataclass(slots=True, frozen=True) class DENTETH: + """ + name: DENTETH + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 92141578.00000000 + margin: True + """ name: str = "DENTETH" precision: int = 8 minimum_margin: float = None @@ -13982,11 +19459,20 @@ def __call__(self): return "DENTETH" -DENTETH = DENTETH() +DENTTRY = DENTTRY() @dataclass(slots=True, frozen=True) class DENTTRY: + """ + name: DENTTRY + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 92141578.00000000 + margin: False + """ name: str = "DENTTRY" precision: int = 8 minimum_margin: float = None @@ -14005,11 +19491,20 @@ def __call__(self): return "DENTTRY" -DENTTRY = DENTTRY() +DENTUSDT = DENTUSDT() @dataclass(slots=True, frozen=True) class DENTUSDT: + """ + name: DENTUSDT + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 90000000.00000000 + margin: True + """ name: str = "DENTUSDT" precision: int = 8 minimum_margin: float = None @@ -14028,11 +19523,20 @@ def __call__(self): return "DENTUSDT" -DENTUSDT = DENTUSDT() +DEXEBUSD = DEXEBUSD() @dataclass(slots=True, frozen=True) class DEXEBUSD: + """ + name: DEXEBUSD + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 90000.00000000 + margin: False + """ name: str = "DEXEBUSD" precision: int = 8 minimum_margin: float = None @@ -14051,11 +19555,20 @@ def __call__(self): return "DEXEBUSD" -DEXEBUSD = DEXEBUSD() +DEXEETH = DEXEETH() @dataclass(slots=True, frozen=True) class DEXEETH: + """ + name: DEXEETH + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 92141578.00000000 + margin: False + """ name: str = "DEXEETH" precision: int = 8 minimum_margin: float = None @@ -14074,11 +19587,20 @@ def __call__(self): return "DEXEETH" -DEXEETH = DEXEETH() +DEXEUSDT = DEXEUSDT() @dataclass(slots=True, frozen=True) class DEXEUSDT: + """ + name: DEXEUSDT + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 92141578.00000000 + margin: False + """ name: str = "DEXEUSDT" precision: int = 8 minimum_margin: float = None @@ -14097,11 +19619,20 @@ def __call__(self): return "DEXEUSDT" -DEXEUSDT = DEXEUSDT() +DFBUSD = DFBUSD() @dataclass(slots=True, frozen=True) class DFBUSD: + """ + name: DFBUSD + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 92141578.00000000 + margin: True + """ name: str = "DFBUSD" precision: int = 8 minimum_margin: float = None @@ -14120,11 +19651,20 @@ def __call__(self): return "DFBUSD" -DFBUSD = DFBUSD() +DFETH = DFETH() @dataclass(slots=True, frozen=True) class DFETH: + """ + name: DFETH + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 90000000.00000000 + margin: False + """ name: str = "DFETH" precision: int = 8 minimum_margin: float = None @@ -14143,11 +19683,20 @@ def __call__(self): return "DFETH" -DFETH = DFETH() +DFUSDT = DFUSDT() @dataclass(slots=True, frozen=True) class DFUSDT: + """ + name: DFUSDT + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 92141578.00000000 + margin: False + """ name: str = "DFUSDT" precision: int = 8 minimum_margin: float = None @@ -14166,11 +19715,20 @@ def __call__(self): return "DFUSDT" -DFUSDT = DFUSDT() +DGBBTC = DGBBTC() @dataclass(slots=True, frozen=True) class DGBBTC: + """ + name: DGBBTC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 90000000.00000000 + margin: True + """ name: str = "DGBBTC" precision: int = 8 minimum_margin: float = None @@ -14189,11 +19747,20 @@ def __call__(self): return "DGBBTC" -DGBBTC = DGBBTC() +DGBBUSD = DGBBUSD() @dataclass(slots=True, frozen=True) class DGBBUSD: + """ + name: DGBBUSD + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 9000000.00000000 + margin: True + """ name: str = "DGBBUSD" precision: int = 8 minimum_margin: float = None @@ -14212,11 +19779,20 @@ def __call__(self): return "DGBBUSD" -DGBBUSD = DGBBUSD() +DGBUSDT = DGBUSDT() @dataclass(slots=True, frozen=True) class DGBUSDT: + """ + name: DGBUSDT + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 9000000.00000000 + margin: True + """ name: str = "DGBUSDT" precision: int = 8 minimum_margin: float = None @@ -14235,11 +19811,20 @@ def __call__(self): return "DGBUSDT" -DGBUSDT = DGBUSDT() +DGDBTC = DGDBTC() @dataclass(slots=True, frozen=True) class DGDBTC: + """ + name: DGDBTC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.00100000 + maximum_order_size: 10000000.00000000 + margin: False + """ name: str = "DGDBTC" precision: int = 8 minimum_margin: float = None @@ -14258,11 +19843,20 @@ def __call__(self): return "DGDBTC" -DGDBTC = DGDBTC() +DGDETH = DGDETH() @dataclass(slots=True, frozen=True) class DGDETH: + """ + name: DGDETH + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.00100000 + maximum_order_size: 9000000.00000000 + margin: False + """ name: str = "DGDETH" precision: int = 8 minimum_margin: float = None @@ -14281,11 +19875,20 @@ def __call__(self): return "DGDETH" -DGDETH = DGDETH() +DIABNB = DIABNB() @dataclass(slots=True, frozen=True) class DIABNB: + """ + name: DIABNB + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 9000000.00000000 + margin: False + """ name: str = "DIABNB" precision: int = 8 minimum_margin: float = None @@ -14304,11 +19907,20 @@ def __call__(self): return "DIABNB" -DIABNB = DIABNB() +DIABTC = DIABTC() @dataclass(slots=True, frozen=True) class DIABTC: + """ + name: DIABTC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 90000000.00000000 + margin: True + """ name: str = "DIABTC" precision: int = 8 minimum_margin: float = None @@ -14327,11 +19939,20 @@ def __call__(self): return "DIABTC" -DIABTC = DIABTC() +DIABUSD = DIABUSD() @dataclass(slots=True, frozen=True) class DIABUSD: + """ + name: DIABUSD + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 922327.00000000 + margin: False + """ name: str = "DIABUSD" precision: int = 8 minimum_margin: float = None @@ -14350,11 +19971,20 @@ def __call__(self): return "DIABUSD" -DIABUSD = DIABUSD() +DIAUSDT = DIAUSDT() @dataclass(slots=True, frozen=True) class DIAUSDT: + """ + name: DIAUSDT + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 922327.00000000 + margin: True + """ name: str = "DIAUSDT" precision: int = 8 minimum_margin: float = None @@ -14373,11 +20003,20 @@ def __call__(self): return "DIAUSDT" -DIAUSDT = DIAUSDT() +DLTBNB = DLTBNB() @dataclass(slots=True, frozen=True) class DLTBNB: + """ + name: DLTBNB + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 9000000.00000000 + margin: False + """ name: str = "DLTBNB" precision: int = 8 minimum_margin: float = None @@ -14396,11 +20035,20 @@ def __call__(self): return "DLTBNB" -DLTBNB = DLTBNB() +DLTBTC = DLTBTC() @dataclass(slots=True, frozen=True) class DLTBTC: + """ + name: DLTBTC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 90000000.00000000 + margin: False + """ name: str = "DLTBTC" precision: int = 8 minimum_margin: float = None @@ -14419,11 +20067,20 @@ def __call__(self): return "DLTBTC" -DLTBTC = DLTBTC() +DLTETH = DLTETH() @dataclass(slots=True, frozen=True) class DLTETH: + """ + name: DLTETH + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 90000000.00000000 + margin: False + """ name: str = "DLTETH" precision: int = 8 minimum_margin: float = None @@ -14442,11 +20099,20 @@ def __call__(self): return "DLTETH" -DLTETH = DLTETH() +DNTBTC = DNTBTC() @dataclass(slots=True, frozen=True) class DNTBTC: + """ + name: DNTBTC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 90000000.00000000 + margin: False + """ name: str = "DNTBTC" precision: int = 8 minimum_margin: float = None @@ -14465,11 +20131,20 @@ def __call__(self): return "DNTBTC" -DNTBTC = DNTBTC() +DNTBUSD = DNTBUSD() @dataclass(slots=True, frozen=True) class DNTBUSD: + """ + name: DNTBUSD + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 9000000.00000000 + margin: False + """ name: str = "DNTBUSD" precision: int = 8 minimum_margin: float = None @@ -14488,11 +20163,20 @@ def __call__(self): return "DNTBUSD" -DNTBUSD = DNTBUSD() +DNTETH = DNTETH() @dataclass(slots=True, frozen=True) class DNTETH: + """ + name: DNTETH + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 90000000.00000000 + margin: False + """ name: str = "DNTETH" precision: int = 8 minimum_margin: float = None @@ -14511,11 +20195,20 @@ def __call__(self): return "DNTETH" -DNTETH = DNTETH() +DNTUSDT = DNTUSDT() @dataclass(slots=True, frozen=True) class DNTUSDT: + """ + name: DNTUSDT + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 9000000.00000000 + margin: False + """ name: str = "DNTUSDT" precision: int = 8 minimum_margin: float = None @@ -14534,11 +20227,20 @@ def __call__(self): return "DNTUSDT" -DNTUSDT = DNTUSDT() +DOCKBTC = DOCKBTC() @dataclass(slots=True, frozen=True) class DOCKBTC: + """ + name: DOCKBTC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 90000000.00000000 + margin: True + """ name: str = "DOCKBTC" precision: int = 8 minimum_margin: float = None @@ -14557,11 +20259,20 @@ def __call__(self): return "DOCKBTC" -DOCKBTC = DOCKBTC() +DOCKBUSD = DOCKBUSD() @dataclass(slots=True, frozen=True) class DOCKBUSD: + """ + name: DOCKBUSD + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 9222449.00000000 + margin: False + """ name: str = "DOCKBUSD" precision: int = 8 minimum_margin: float = None @@ -14580,11 +20291,20 @@ def __call__(self): return "DOCKBUSD" -DOCKBUSD = DOCKBUSD() +DOCKETH = DOCKETH() @dataclass(slots=True, frozen=True) class DOCKETH: + """ + name: DOCKETH + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 90000000.00000000 + margin: False + """ name: str = "DOCKETH" precision: int = 8 minimum_margin: float = None @@ -14603,11 +20323,20 @@ def __call__(self): return "DOCKETH" -DOCKETH = DOCKETH() +DOCKUSDT = DOCKUSDT() @dataclass(slots=True, frozen=True) class DOCKUSDT: + """ + name: DOCKUSDT + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 9000000.00000000 + margin: True + """ name: str = "DOCKUSDT" precision: int = 8 minimum_margin: float = None @@ -14626,11 +20355,20 @@ def __call__(self): return "DOCKUSDT" -DOCKUSDT = DOCKUSDT() +DODOBTC = DODOBTC() @dataclass(slots=True, frozen=True) class DODOBTC: + """ + name: DODOBTC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 90000000.00000000 + margin: True + """ name: str = "DODOBTC" precision: int = 8 minimum_margin: float = None @@ -14649,11 +20387,20 @@ def __call__(self): return "DODOBTC" -DODOBTC = DODOBTC() +DODOBUSD = DODOBUSD() @dataclass(slots=True, frozen=True) class DODOBUSD: + """ + name: DODOBUSD + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 9222449.00000000 + margin: True + """ name: str = "DODOBUSD" precision: int = 8 minimum_margin: float = None @@ -14672,11 +20419,20 @@ def __call__(self): return "DODOBUSD" -DODOBUSD = DODOBUSD() +DODOUSDT = DODOUSDT() @dataclass(slots=True, frozen=True) class DODOUSDT: + """ + name: DODOUSDT + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 9222449.00000000 + margin: True + """ name: str = "DODOUSDT" precision: int = 8 minimum_margin: float = None @@ -14695,11 +20451,20 @@ def __call__(self): return "DODOUSDT" -DODOUSDT = DODOUSDT() +DOGEAUD = DOGEAUD() @dataclass(slots=True, frozen=True) class DOGEAUD: + """ + name: DOGEAUD + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 9000000.00000000 + margin: False + """ name: str = "DOGEAUD" precision: int = 8 minimum_margin: float = None @@ -14718,11 +20483,20 @@ def __call__(self): return "DOGEAUD" -DOGEAUD = DOGEAUD() +DOGEBIDR = DOGEBIDR() @dataclass(slots=True, frozen=True) class DOGEBIDR: + """ + name: DOGEBIDR + precision: 2 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 922327.00000000 + margin: False + """ name: str = "DOGEBIDR" precision: int = 2 minimum_margin: float = None @@ -14741,11 +20515,20 @@ def __call__(self): return "DOGEBIDR" -DOGEBIDR = DOGEBIDR() +DOGEBNB = DOGEBNB() @dataclass(slots=True, frozen=True) class DOGEBNB: + """ + name: DOGEBNB + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 90000000.00000000 + margin: False + """ name: str = "DOGEBNB" precision: int = 8 minimum_margin: float = None @@ -14764,11 +20547,20 @@ def __call__(self): return "DOGEBNB" -DOGEBNB = DOGEBNB() +DOGEBRL = DOGEBRL() @dataclass(slots=True, frozen=True) class DOGEBRL: + """ + name: DOGEBRL + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 92141578.00000000 + margin: False + """ name: str = "DOGEBRL" precision: int = 8 minimum_margin: float = None @@ -14787,11 +20579,20 @@ def __call__(self): return "DOGEBRL" -DOGEBRL = DOGEBRL() +DOGEBTC = DOGEBTC() @dataclass(slots=True, frozen=True) class DOGEBTC: + """ + name: DOGEBTC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 90000000.00000000 + margin: True + """ name: str = "DOGEBTC" precision: int = 8 minimum_margin: float = None @@ -14810,11 +20611,20 @@ def __call__(self): return "DOGEBTC" -DOGEBTC = DOGEBTC() +DOGEBUSD = DOGEBUSD() @dataclass(slots=True, frozen=True) class DOGEBUSD: + """ + name: DOGEBUSD + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 9000000.00000000 + margin: True + """ name: str = "DOGEBUSD" precision: int = 8 minimum_margin: float = None @@ -14833,11 +20643,20 @@ def __call__(self): return "DOGEBUSD" -DOGEBUSD = DOGEBUSD() +DOGEEUR = DOGEEUR() @dataclass(slots=True, frozen=True) class DOGEEUR: + """ + name: DOGEEUR + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 9000000.00000000 + margin: False + """ name: str = "DOGEEUR" precision: int = 8 minimum_margin: float = None @@ -14856,11 +20675,20 @@ def __call__(self): return "DOGEEUR" -DOGEEUR = DOGEEUR() +DOGEGBP = DOGEGBP() @dataclass(slots=True, frozen=True) class DOGEGBP: + """ + name: DOGEGBP + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 9000000.00000000 + margin: False + """ name: str = "DOGEGBP" precision: int = 8 minimum_margin: float = None @@ -14879,11 +20707,20 @@ def __call__(self): return "DOGEGBP" -DOGEGBP = DOGEGBP() +DOGEPAX = DOGEPAX() @dataclass(slots=True, frozen=True) class DOGEPAX: + """ + name: DOGEPAX + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 90000000.00000000 + margin: False + """ name: str = "DOGEPAX" precision: int = 8 minimum_margin: float = None @@ -14902,11 +20739,20 @@ def __call__(self): return "DOGEPAX" -DOGEPAX = DOGEPAX() +DOGERUB = DOGERUB() @dataclass(slots=True, frozen=True) class DOGERUB: + """ + name: DOGERUB + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 922327.00000000 + margin: False + """ name: str = "DOGERUB" precision: int = 8 minimum_margin: float = None @@ -14925,11 +20771,20 @@ def __call__(self): return "DOGERUB" -DOGERUB = DOGERUB() +DOGETRY = DOGETRY() @dataclass(slots=True, frozen=True) class DOGETRY: + """ + name: DOGETRY + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 92141578.00000000 + margin: False + """ name: str = "DOGETRY" precision: int = 8 minimum_margin: float = None @@ -14948,11 +20803,20 @@ def __call__(self): return "DOGETRY" -DOGETRY = DOGETRY() +DOGEUSDC = DOGEUSDC() @dataclass(slots=True, frozen=True) class DOGEUSDC: + """ + name: DOGEUSDC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 90000000.00000000 + margin: False + """ name: str = "DOGEUSDC" precision: int = 8 minimum_margin: float = None @@ -14971,11 +20835,20 @@ def __call__(self): return "DOGEUSDC" -DOGEUSDC = DOGEUSDC() +DOGEUSDT = DOGEUSDT() @dataclass(slots=True, frozen=True) class DOGEUSDT: + """ + name: DOGEUSDT + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 9000000.00000000 + margin: True + """ name: str = "DOGEUSDT" precision: int = 8 minimum_margin: float = None @@ -14994,11 +20867,20 @@ def __call__(self): return "DOGEUSDT" -DOGEUSDT = DOGEUSDT() +DOTAUD = DOTAUD() @dataclass(slots=True, frozen=True) class DOTAUD: + """ + name: DOTAUD + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 9222449.00000000 + margin: False + """ name: str = "DOTAUD" precision: int = 8 minimum_margin: float = None @@ -15017,11 +20899,20 @@ def __call__(self): return "DOTAUD" -DOTAUD = DOTAUD() +DOTBIDR = DOTBIDR() @dataclass(slots=True, frozen=True) class DOTBIDR: + """ + name: DOTBIDR + precision: 2 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 100000.00000000 + margin: False + """ name: str = "DOTBIDR" precision: int = 2 minimum_margin: float = None @@ -15040,11 +20931,20 @@ def __call__(self): return "DOTBIDR" -DOTBIDR = DOTBIDR() +DOTBKRW = DOTBKRW() @dataclass(slots=True, frozen=True) class DOTBKRW: + """ + name: DOTBKRW + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 9200.00000000 + margin: False + """ name: str = "DOTBKRW" precision: int = 8 minimum_margin: float = None @@ -15063,11 +20963,20 @@ def __call__(self): return "DOTBKRW" -DOTBKRW = DOTBKRW() +DOTBNB = DOTBNB() @dataclass(slots=True, frozen=True) class DOTBNB: + """ + name: DOTBNB + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 9000000.00000000 + margin: False + """ name: str = "DOTBNB" precision: int = 8 minimum_margin: float = None @@ -15086,11 +20995,20 @@ def __call__(self): return "DOTBNB" -DOTBNB = DOTBNB() +DOTBRL = DOTBRL() @dataclass(slots=True, frozen=True) class DOTBRL: + """ + name: DOTBRL + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 922327.00000000 + margin: False + """ name: str = "DOTBRL" precision: int = 8 minimum_margin: float = None @@ -15109,11 +21027,20 @@ def __call__(self): return "DOTBRL" -DOTBRL = DOTBRL() +DOTBTC = DOTBTC() @dataclass(slots=True, frozen=True) class DOTBTC: + """ + name: DOTBTC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 90000000.00000000 + margin: True + """ name: str = "DOTBTC" precision: int = 8 minimum_margin: float = None @@ -15132,11 +21059,20 @@ def __call__(self): return "DOTBTC" -DOTBTC = DOTBTC() +DOTBUSD = DOTBUSD() @dataclass(slots=True, frozen=True) class DOTBUSD: + """ + name: DOTBUSD + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 90000.00000000 + margin: True + """ name: str = "DOTBUSD" precision: int = 8 minimum_margin: float = None @@ -15155,11 +21091,20 @@ def __call__(self): return "DOTBUSD" -DOTBUSD = DOTBUSD() +DOTDOWNUSDT = DOTDOWNUSDT() @dataclass(slots=True, frozen=True) class DOTDOWNUSDT: + """ + name: DOTDOWNUSDT + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 100000000.00000000 + margin: False + """ name: str = "DOTDOWNUSDT" precision: int = 8 minimum_margin: float = None @@ -15178,11 +21123,20 @@ def __call__(self): return "DOTDOWNUSDT" -DOTDOWNUSDT = DOTDOWNUSDT() +DOTETH = DOTETH() @dataclass(slots=True, frozen=True) class DOTETH: + """ + name: DOTETH + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 92141578.00000000 + margin: False + """ name: str = "DOTETH" precision: int = 8 minimum_margin: float = None @@ -15201,11 +21155,20 @@ def __call__(self): return "DOTETH" -DOTETH = DOTETH() +DOTEUR = DOTEUR() @dataclass(slots=True, frozen=True) class DOTEUR: + """ + name: DOTEUR + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 90000.00000000 + margin: False + """ name: str = "DOTEUR" precision: int = 8 minimum_margin: float = None @@ -15224,11 +21187,20 @@ def __call__(self): return "DOTEUR" -DOTEUR = DOTEUR() +DOTGBP = DOTGBP() @dataclass(slots=True, frozen=True) class DOTGBP: + """ + name: DOTGBP + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 90000.00000000 + margin: False + """ name: str = "DOTGBP" precision: int = 8 minimum_margin: float = None @@ -15247,11 +21219,20 @@ def __call__(self): return "DOTGBP" -DOTGBP = DOTGBP() +DOTNGN = DOTNGN() @dataclass(slots=True, frozen=True) class DOTNGN: + """ + name: DOTNGN + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.00001000 + maximum_order_size: 92232.00000000 + margin: False + """ name: str = "DOTNGN" precision: int = 8 minimum_margin: float = None @@ -15270,11 +21251,20 @@ def __call__(self): return "DOTNGN" -DOTNGN = DOTNGN() +DOTRUB = DOTRUB() @dataclass(slots=True, frozen=True) class DOTRUB: + """ + name: DOTRUB + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 92233.00000000 + margin: False + """ name: str = "DOTRUB" precision: int = 8 minimum_margin: float = None @@ -15293,11 +21283,20 @@ def __call__(self): return "DOTRUB" -DOTRUB = DOTRUB() +DOTTRY = DOTTRY() @dataclass(slots=True, frozen=True) class DOTTRY: + """ + name: DOTTRY + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 922327.00000000 + margin: False + """ name: str = "DOTTRY" precision: int = 8 minimum_margin: float = None @@ -15316,11 +21315,20 @@ def __call__(self): return "DOTTRY" -DOTTRY = DOTTRY() +DOTUPUSDT = DOTUPUSDT() @dataclass(slots=True, frozen=True) class DOTUPUSDT: + """ + name: DOTUPUSDT + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 920000.00000000 + margin: False + """ name: str = "DOTUPUSDT" precision: int = 8 minimum_margin: float = None @@ -15339,11 +21347,20 @@ def __call__(self): return "DOTUPUSDT" -DOTUPUSDT = DOTUPUSDT() +DOTUSDT = DOTUSDT() @dataclass(slots=True, frozen=True) class DOTUSDT: + """ + name: DOTUSDT + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 90000.00000000 + margin: True + """ name: str = "DOTUSDT" precision: int = 8 minimum_margin: float = None @@ -15362,11 +21379,20 @@ def __call__(self): return "DOTUSDT" -DOTUSDT = DOTUSDT() +DREPBNB = DREPBNB() @dataclass(slots=True, frozen=True) class DREPBNB: + """ + name: DREPBNB + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 9000000.00000000 + margin: False + """ name: str = "DREPBNB" precision: int = 8 minimum_margin: float = None @@ -15385,11 +21411,20 @@ def __call__(self): return "DREPBNB" -DREPBNB = DREPBNB() +DREPBTC = DREPBTC() @dataclass(slots=True, frozen=True) class DREPBTC: + """ + name: DREPBTC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 90000000.00000000 + margin: False + """ name: str = "DREPBTC" precision: int = 8 minimum_margin: float = None @@ -15408,11 +21443,20 @@ def __call__(self): return "DREPBTC" -DREPBTC = DREPBTC() +DREPBUSD = DREPBUSD() @dataclass(slots=True, frozen=True) class DREPBUSD: + """ + name: DREPBUSD + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 92141578.00000000 + margin: False + """ name: str = "DREPBUSD" precision: int = 8 minimum_margin: float = None @@ -15431,11 +21475,20 @@ def __call__(self): return "DREPBUSD" -DREPBUSD = DREPBUSD() +DREPUSDT = DREPUSDT() @dataclass(slots=True, frozen=True) class DREPUSDT: + """ + name: DREPUSDT + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 92141578.00000000 + margin: False + """ name: str = "DREPUSDT" precision: int = 8 minimum_margin: float = None @@ -15454,11 +21507,20 @@ def __call__(self): return "DREPUSDT" -DREPUSDT = DREPUSDT() +DUSKBNB = DUSKBNB() @dataclass(slots=True, frozen=True) class DUSKBNB: + """ + name: DUSKBNB + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 9000000.00000000 + margin: False + """ name: str = "DUSKBNB" precision: int = 8 minimum_margin: float = None @@ -15477,11 +21539,20 @@ def __call__(self): return "DUSKBNB" -DUSKBNB = DUSKBNB() +DUSKBTC = DUSKBTC() @dataclass(slots=True, frozen=True) class DUSKBTC: + """ + name: DUSKBTC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 90000000.00000000 + margin: True + """ name: str = "DUSKBTC" precision: int = 8 minimum_margin: float = None @@ -15500,11 +21571,20 @@ def __call__(self): return "DUSKBTC" -DUSKBTC = DUSKBTC() +DUSKBUSD = DUSKBUSD() @dataclass(slots=True, frozen=True) class DUSKBUSD: + """ + name: DUSKBUSD + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 92141578.00000000 + margin: False + """ name: str = "DUSKBUSD" precision: int = 8 minimum_margin: float = None @@ -15523,11 +21603,20 @@ def __call__(self): return "DUSKBUSD" -DUSKBUSD = DUSKBUSD() +DUSKPAX = DUSKPAX() @dataclass(slots=True, frozen=True) class DUSKPAX: + """ + name: DUSKPAX + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 900000.00000000 + margin: False + """ name: str = "DUSKPAX" precision: int = 8 minimum_margin: float = None @@ -15546,11 +21635,20 @@ def __call__(self): return "DUSKPAX" -DUSKPAX = DUSKPAX() +DUSKUSDC = DUSKUSDC() @dataclass(slots=True, frozen=True) class DUSKUSDC: + """ + name: DUSKUSDC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 900000.00000000 + margin: False + """ name: str = "DUSKUSDC" precision: int = 8 minimum_margin: float = None @@ -15569,11 +21667,20 @@ def __call__(self): return "DUSKUSDC" -DUSKUSDC = DUSKUSDC() +DUSKUSDT = DUSKUSDT() @dataclass(slots=True, frozen=True) class DUSKUSDT: + """ + name: DUSKUSDT + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 9222449.00000000 + margin: True + """ name: str = "DUSKUSDT" precision: int = 8 minimum_margin: float = None @@ -15592,11 +21699,20 @@ def __call__(self): return "DUSKUSDT" -DUSKUSDT = DUSKUSDT() +DYDXBNB = DYDXBNB() @dataclass(slots=True, frozen=True) class DYDXBNB: + """ + name: DYDXBNB + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 8384883677.00000000 + margin: False + """ name: str = "DYDXBNB" precision: int = 8 minimum_margin: float = None @@ -15615,11 +21731,20 @@ def __call__(self): return "DYDXBNB" -DYDXBNB = DYDXBNB() +DYDXBTC = DYDXBTC() @dataclass(slots=True, frozen=True) class DYDXBTC: + """ + name: DYDXBTC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 46116860414.00000000 + margin: False + """ name: str = "DYDXBTC" precision: int = 8 minimum_margin: float = None @@ -15638,11 +21763,20 @@ def __call__(self): return "DYDXBTC" -DYDXBTC = DYDXBTC() +DYDXBUSD = DYDXBUSD() @dataclass(slots=True, frozen=True) class DYDXBUSD: + """ + name: DYDXBUSD + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 9222449.00000000 + margin: True + """ name: str = "DYDXBUSD" precision: int = 8 minimum_margin: float = None @@ -15661,11 +21795,20 @@ def __call__(self): return "DYDXBUSD" -DYDXBUSD = DYDXBUSD() +DYDXETH = DYDXETH() @dataclass(slots=True, frozen=True) class DYDXETH: + """ + name: DYDXETH + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 92141578.00000000 + margin: False + """ name: str = "DYDXETH" precision: int = 8 minimum_margin: float = None @@ -15684,11 +21827,20 @@ def __call__(self): return "DYDXETH" -DYDXETH = DYDXETH() +DYDXUSDT = DYDXUSDT() @dataclass(slots=True, frozen=True) class DYDXUSDT: + """ + name: DYDXUSDT + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 9222449.00000000 + margin: True + """ name: str = "DYDXUSDT" precision: int = 8 minimum_margin: float = None @@ -15707,11 +21859,20 @@ def __call__(self): return "DYDXUSDT" -DYDXUSDT = DYDXUSDT() +EASYBTC = EASYBTC() @dataclass(slots=True, frozen=True) class EASYBTC: + """ + name: EASYBTC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 90000000.00000000 + margin: False + """ name: str = "EASYBTC" precision: int = 8 minimum_margin: float = None @@ -15730,11 +21891,20 @@ def __call__(self): return "EASYBTC" -EASYBTC = EASYBTC() +EASYETH = EASYETH() @dataclass(slots=True, frozen=True) class EASYETH: + """ + name: EASYETH + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 90000000.00000000 + margin: False + """ name: str = "EASYETH" precision: int = 8 minimum_margin: float = None @@ -15753,11 +21923,20 @@ def __call__(self): return "EASYETH" -EASYETH = EASYETH() +EDOBTC = EDOBTC() @dataclass(slots=True, frozen=True) class EDOBTC: + """ + name: EDOBTC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 90000000.00000000 + margin: False + """ name: str = "EDOBTC" precision: int = 8 minimum_margin: float = None @@ -15776,11 +21955,20 @@ def __call__(self): return "EDOBTC" -EDOBTC = EDOBTC() +EDOETH = EDOETH() @dataclass(slots=True, frozen=True) class EDOETH: + """ + name: EDOETH + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 90000000.00000000 + margin: False + """ name: str = "EDOETH" precision: int = 8 minimum_margin: float = None @@ -15799,11 +21987,20 @@ def __call__(self): return "EDOETH" -EDOETH = EDOETH() +EGLDBNB = EGLDBNB() @dataclass(slots=True, frozen=True) class EGLDBNB: + """ + name: EGLDBNB + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 900000.00000000 + margin: False + """ name: str = "EGLDBNB" precision: int = 8 minimum_margin: float = None @@ -15822,11 +22019,20 @@ def __call__(self): return "EGLDBNB" -EGLDBNB = EGLDBNB() +EGLDBTC = EGLDBTC() @dataclass(slots=True, frozen=True) class EGLDBTC: + """ + name: EGLDBTC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 10000000.00000000 + margin: True + """ name: str = "EGLDBTC" precision: int = 8 minimum_margin: float = None @@ -15845,11 +22051,20 @@ def __call__(self): return "EGLDBTC" -EGLDBTC = EGLDBTC() +EGLDBUSD = EGLDBUSD() @dataclass(slots=True, frozen=True) class EGLDBUSD: + """ + name: EGLDBUSD + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 900000.00000000 + margin: True + """ name: str = "EGLDBUSD" precision: int = 8 minimum_margin: float = None @@ -15868,11 +22083,20 @@ def __call__(self): return "EGLDBUSD" -EGLDBUSD = EGLDBUSD() +EGLDETH = EGLDETH() @dataclass(slots=True, frozen=True) class EGLDETH: + """ + name: EGLDETH + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.00010000 + maximum_order_size: 92141578.00000000 + margin: False + """ name: str = "EGLDETH" precision: int = 8 minimum_margin: float = None @@ -15891,11 +22115,20 @@ def __call__(self): return "EGLDETH" -EGLDETH = EGLDETH() +EGLDEUR = EGLDEUR() @dataclass(slots=True, frozen=True) class EGLDEUR: + """ + name: EGLDEUR + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 90000.00000000 + margin: False + """ name: str = "EGLDEUR" precision: int = 8 minimum_margin: float = None @@ -15914,11 +22147,20 @@ def __call__(self): return "EGLDEUR" -EGLDEUR = EGLDEUR() +EGLDUSDT = EGLDUSDT() @dataclass(slots=True, frozen=True) class EGLDUSDT: + """ + name: EGLDUSDT + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 900000.00000000 + margin: True + """ name: str = "EGLDUSDT" precision: int = 8 minimum_margin: float = None @@ -15937,11 +22179,20 @@ def __call__(self): return "EGLDUSDT" -EGLDUSDT = EGLDUSDT() +ELFBTC = ELFBTC() @dataclass(slots=True, frozen=True) class ELFBTC: + """ + name: ELFBTC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 90000000.00000000 + margin: False + """ name: str = "ELFBTC" precision: int = 8 minimum_margin: float = None @@ -15960,11 +22211,20 @@ def __call__(self): return "ELFBTC" -ELFBTC = ELFBTC() +ELFBUSD = ELFBUSD() @dataclass(slots=True, frozen=True) class ELFBUSD: + """ + name: ELFBUSD + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 913205152.00000000 + margin: False + """ name: str = "ELFBUSD" precision: int = 8 minimum_margin: float = None @@ -15983,11 +22243,20 @@ def __call__(self): return "ELFBUSD" -ELFBUSD = ELFBUSD() +ELFETH = ELFETH() @dataclass(slots=True, frozen=True) class ELFETH: + """ + name: ELFETH + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 90000000.00000000 + margin: False + """ name: str = "ELFETH" precision: int = 8 minimum_margin: float = None @@ -16006,11 +22275,20 @@ def __call__(self): return "ELFETH" -ELFETH = ELFETH() +ELFUSDT = ELFUSDT() @dataclass(slots=True, frozen=True) class ELFUSDT: + """ + name: ELFUSDT + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 92141578.00000000 + margin: False + """ name: str = "ELFUSDT" precision: int = 8 minimum_margin: float = None @@ -16029,11 +22307,20 @@ def __call__(self): return "ELFUSDT" -ELFUSDT = ELFUSDT() +ENGBTC = ENGBTC() @dataclass(slots=True, frozen=True) class ENGBTC: + """ + name: ENGBTC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 90000000.00000000 + margin: False + """ name: str = "ENGBTC" precision: int = 8 minimum_margin: float = None @@ -16052,11 +22339,20 @@ def __call__(self): return "ENGBTC" -ENGBTC = ENGBTC() +ENGETH = ENGETH() @dataclass(slots=True, frozen=True) class ENGETH: + """ + name: ENGETH + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 90000000.00000000 + margin: False + """ name: str = "ENGETH" precision: int = 8 minimum_margin: float = None @@ -16075,11 +22371,20 @@ def __call__(self): return "ENGETH" -ENGETH = ENGETH() +ENJBNB = ENJBNB() @dataclass(slots=True, frozen=True) class ENJBNB: + """ + name: ENJBNB + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 9000000.00000000 + margin: False + """ name: str = "ENJBNB" precision: int = 8 minimum_margin: float = None @@ -16098,11 +22403,20 @@ def __call__(self): return "ENJBNB" -ENJBNB = ENJBNB() +ENJBRL = ENJBRL() @dataclass(slots=True, frozen=True) class ENJBRL: + """ + name: ENJBRL + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 9222449.00000000 + margin: False + """ name: str = "ENJBRL" precision: int = 8 minimum_margin: float = None @@ -16121,11 +22435,20 @@ def __call__(self): return "ENJBRL" -ENJBRL = ENJBRL() +ENJBTC = ENJBTC() @dataclass(slots=True, frozen=True) class ENJBTC: + """ + name: ENJBTC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 90000000.00000000 + margin: True + """ name: str = "ENJBTC" precision: int = 8 minimum_margin: float = None @@ -16144,11 +22467,20 @@ def __call__(self): return "ENJBTC" -ENJBTC = ENJBTC() +ENJBUSD = ENJBUSD() @dataclass(slots=True, frozen=True) class ENJBUSD: + """ + name: ENJBUSD + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 900000.00000000 + margin: True + """ name: str = "ENJBUSD" precision: int = 8 minimum_margin: float = None @@ -16167,11 +22499,20 @@ def __call__(self): return "ENJBUSD" -ENJBUSD = ENJBUSD() +ENJETH = ENJETH() @dataclass(slots=True, frozen=True) class ENJETH: + """ + name: ENJETH + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 90000000.00000000 + margin: False + """ name: str = "ENJETH" precision: int = 8 minimum_margin: float = None @@ -16190,11 +22531,20 @@ def __call__(self): return "ENJETH" -ENJETH = ENJETH() +ENJEUR = ENJEUR() @dataclass(slots=True, frozen=True) class ENJEUR: + """ + name: ENJEUR + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 9222449.00000000 + margin: False + """ name: str = "ENJEUR" precision: int = 8 minimum_margin: float = None @@ -16213,11 +22563,20 @@ def __call__(self): return "ENJEUR" -ENJEUR = ENJEUR() +ENJGBP = ENJGBP() @dataclass(slots=True, frozen=True) class ENJGBP: + """ + name: ENJGBP + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 900000.00000000 + margin: False + """ name: str = "ENJGBP" precision: int = 8 minimum_margin: float = None @@ -16236,11 +22595,20 @@ def __call__(self): return "ENJGBP" -ENJGBP = ENJGBP() +ENJTRY = ENJTRY() @dataclass(slots=True, frozen=True) class ENJTRY: + """ + name: ENJTRY + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 9222449.00000000 + margin: False + """ name: str = "ENJTRY" precision: int = 8 minimum_margin: float = None @@ -16259,11 +22627,20 @@ def __call__(self): return "ENJTRY" -ENJTRY = ENJTRY() +ENJUSDT = ENJUSDT() @dataclass(slots=True, frozen=True) class ENJUSDT: + """ + name: ENJUSDT + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 900000.00000000 + margin: True + """ name: str = "ENJUSDT" precision: int = 8 minimum_margin: float = None @@ -16282,11 +22659,20 @@ def __call__(self): return "ENJUSDT" -ENJUSDT = ENJUSDT() +ENSBNB = ENSBNB() @dataclass(slots=True, frozen=True) class ENSBNB: + """ + name: ENSBNB + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 92141578.00000000 + margin: False + """ name: str = "ENSBNB" precision: int = 8 minimum_margin: float = None @@ -16305,11 +22691,20 @@ def __call__(self): return "ENSBNB" -ENSBNB = ENSBNB() +ENSBTC = ENSBTC() @dataclass(slots=True, frozen=True) class ENSBTC: + """ + name: ENSBTC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 92141578.00000000 + margin: True + """ name: str = "ENSBTC" precision: int = 8 minimum_margin: float = None @@ -16328,11 +22723,20 @@ def __call__(self): return "ENSBTC" -ENSBTC = ENSBTC() +ENSBUSD = ENSBUSD() @dataclass(slots=True, frozen=True) class ENSBUSD: + """ + name: ENSBUSD + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 9222449.00000000 + margin: True + """ name: str = "ENSBUSD" precision: int = 8 minimum_margin: float = None @@ -16351,11 +22755,20 @@ def __call__(self): return "ENSBUSD" -ENSBUSD = ENSBUSD() +ENSTRY = ENSTRY() @dataclass(slots=True, frozen=True) class ENSTRY: + """ + name: ENSTRY + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.00100000 + maximum_order_size: 922327.00000000 + margin: False + """ name: str = "ENSTRY" precision: int = 8 minimum_margin: float = None @@ -16374,11 +22787,20 @@ def __call__(self): return "ENSTRY" -ENSTRY = ENSTRY() +ENSUSDT = ENSUSDT() @dataclass(slots=True, frozen=True) class ENSUSDT: + """ + name: ENSUSDT + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 9222449.00000000 + margin: True + """ name: str = "ENSUSDT" precision: int = 8 minimum_margin: float = None @@ -16397,11 +22819,20 @@ def __call__(self): return "ENSUSDT" -ENSUSDT = ENSUSDT() +EOSAUD = EOSAUD() @dataclass(slots=True, frozen=True) class EOSAUD: + """ + name: EOSAUD + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 92141578.00000000 + margin: False + """ name: str = "EOSAUD" precision: int = 8 minimum_margin: float = None @@ -16420,11 +22851,20 @@ def __call__(self): return "EOSAUD" -EOSAUD = EOSAUD() +EOSBEARBUSD = EOSBEARBUSD() @dataclass(slots=True, frozen=True) class EOSBEARBUSD: + """ + name: EOSBEARBUSD + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.00001000 + maximum_order_size: 90000.00000000 + margin: False + """ name: str = "EOSBEARBUSD" precision: int = 8 minimum_margin: float = None @@ -16443,11 +22883,20 @@ def __call__(self): return "EOSBEARBUSD" -EOSBEARBUSD = EOSBEARBUSD() +EOSBEARUSDT = EOSBEARUSDT() @dataclass(slots=True, frozen=True) class EOSBEARUSDT: + """ + name: EOSBEARUSDT + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.00001000 + maximum_order_size: 90000.00000000 + margin: False + """ name: str = "EOSBEARUSDT" precision: int = 8 minimum_margin: float = None @@ -16466,11 +22915,20 @@ def __call__(self): return "EOSBEARUSDT" -EOSBEARUSDT = EOSBEARUSDT() +EOSBNB = EOSBNB() @dataclass(slots=True, frozen=True) class EOSBNB: + """ + name: EOSBNB + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 9000000.00000000 + margin: False + """ name: str = "EOSBNB" precision: int = 8 minimum_margin: float = None @@ -16489,11 +22947,20 @@ def __call__(self): return "EOSBNB" -EOSBNB = EOSBNB() +EOSBTC = EOSBTC() @dataclass(slots=True, frozen=True) class EOSBTC: + """ + name: EOSBTC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 90000000.00000000 + margin: True + """ name: str = "EOSBTC" precision: int = 8 minimum_margin: float = None @@ -16512,11 +22979,20 @@ def __call__(self): return "EOSBTC" -EOSBTC = EOSBTC() +EOSBULLBUSD = EOSBULLBUSD() @dataclass(slots=True, frozen=True) class EOSBULLBUSD: + """ + name: EOSBULLBUSD + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.00001000 + maximum_order_size: 90000.00000000 + margin: False + """ name: str = "EOSBULLBUSD" precision: int = 8 minimum_margin: float = None @@ -16535,11 +23011,20 @@ def __call__(self): return "EOSBULLBUSD" -EOSBULLBUSD = EOSBULLBUSD() +EOSBULLUSDT = EOSBULLUSDT() @dataclass(slots=True, frozen=True) class EOSBULLUSDT: + """ + name: EOSBULLUSDT + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.00001000 + maximum_order_size: 92232.00000000 + margin: False + """ name: str = "EOSBULLUSDT" precision: int = 8 minimum_margin: float = None @@ -16558,11 +23043,20 @@ def __call__(self): return "EOSBULLUSDT" -EOSBULLUSDT = EOSBULLUSDT() +EOSBUSD = EOSBUSD() @dataclass(slots=True, frozen=True) class EOSBUSD: + """ + name: EOSBUSD + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 900000.00000000 + margin: True + """ name: str = "EOSBUSD" precision: int = 8 minimum_margin: float = None @@ -16581,11 +23075,20 @@ def __call__(self): return "EOSBUSD" -EOSBUSD = EOSBUSD() +EOSDOWNUSDT = EOSDOWNUSDT() @dataclass(slots=True, frozen=True) class EOSDOWNUSDT: + """ + name: EOSDOWNUSDT + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 69980060.00000000 + margin: False + """ name: str = "EOSDOWNUSDT" precision: int = 8 minimum_margin: float = None @@ -16604,11 +23107,20 @@ def __call__(self): return "EOSDOWNUSDT" -EOSDOWNUSDT = EOSDOWNUSDT() +EOSETH = EOSETH() @dataclass(slots=True, frozen=True) class EOSETH: + """ + name: EOSETH + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 92141578.00000000 + margin: True + """ name: str = "EOSETH" precision: int = 8 minimum_margin: float = None @@ -16627,11 +23139,20 @@ def __call__(self): return "EOSETH" -EOSETH = EOSETH() +EOSEUR = EOSEUR() @dataclass(slots=True, frozen=True) class EOSEUR: + """ + name: EOSEUR + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 90000.00000000 + margin: False + """ name: str = "EOSEUR" precision: int = 8 minimum_margin: float = None @@ -16650,11 +23171,20 @@ def __call__(self): return "EOSEUR" -EOSEUR = EOSEUR() +EOSPAX = EOSPAX() @dataclass(slots=True, frozen=True) class EOSPAX: + """ + name: EOSPAX + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 900000.00000000 + margin: False + """ name: str = "EOSPAX" precision: int = 8 minimum_margin: float = None @@ -16673,11 +23203,20 @@ def __call__(self): return "EOSPAX" -EOSPAX = EOSPAX() +EOSTRY = EOSTRY() @dataclass(slots=True, frozen=True) class EOSTRY: + """ + name: EOSTRY + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 9222449.00000000 + margin: False + """ name: str = "EOSTRY" precision: int = 8 minimum_margin: float = None @@ -16696,11 +23235,20 @@ def __call__(self): return "EOSTRY" -EOSTRY = EOSTRY() +EOSTUSD = EOSTUSD() @dataclass(slots=True, frozen=True) class EOSTUSD: + """ + name: EOSTUSD + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 900000.00000000 + margin: False + """ name: str = "EOSTUSD" precision: int = 8 minimum_margin: float = None @@ -16719,11 +23267,20 @@ def __call__(self): return "EOSTUSD" -EOSTUSD = EOSTUSD() +EOSUPUSDT = EOSUPUSDT() @dataclass(slots=True, frozen=True) class EOSUPUSDT: + """ + name: EOSUPUSDT + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 920000.00000000 + margin: False + """ name: str = "EOSUPUSDT" precision: int = 8 minimum_margin: float = None @@ -16742,11 +23299,20 @@ def __call__(self): return "EOSUPUSDT" -EOSUPUSDT = EOSUPUSDT() +EOSUSDC = EOSUSDC() @dataclass(slots=True, frozen=True) class EOSUSDC: + """ + name: EOSUSDC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 900000.00000000 + margin: False + """ name: str = "EOSUSDC" precision: int = 8 minimum_margin: float = None @@ -16765,11 +23331,20 @@ def __call__(self): return "EOSUSDC" -EOSUSDC = EOSUSDC() +EOSUSDT = EOSUSDT() @dataclass(slots=True, frozen=True) class EOSUSDT: + """ + name: EOSUSDT + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 900000.00000000 + margin: True + """ name: str = "EOSUSDT" precision: int = 8 minimum_margin: float = None @@ -16788,11 +23363,20 @@ def __call__(self): return "EOSUSDT" -EOSUSDT = EOSUSDT() +EPSBTC = EPSBTC() @dataclass(slots=True, frozen=True) class EPSBTC: + """ + name: EPSBTC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 90000000.00000000 + margin: False + """ name: str = "EPSBTC" precision: int = 8 minimum_margin: float = None @@ -16811,11 +23395,20 @@ def __call__(self): return "EPSBTC" -EPSBTC = EPSBTC() +EPSBUSD = EPSBUSD() @dataclass(slots=True, frozen=True) class EPSBUSD: + """ + name: EPSBUSD + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 92141578.00000000 + margin: False + """ name: str = "EPSBUSD" precision: int = 8 minimum_margin: float = None @@ -16834,11 +23427,20 @@ def __call__(self): return "EPSBUSD" -EPSBUSD = EPSBUSD() +EPSUSDT = EPSUSDT() @dataclass(slots=True, frozen=True) class EPSUSDT: + """ + name: EPSUSDT + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 92141578.00000000 + margin: False + """ name: str = "EPSUSDT" precision: int = 8 minimum_margin: float = None @@ -16857,11 +23459,20 @@ def __call__(self): return "EPSUSDT" -EPSUSDT = EPSUSDT() +EPXBUSD = EPXBUSD() @dataclass(slots=True, frozen=True) class EPXBUSD: + """ + name: EPXBUSD + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 913205152.00000000 + margin: True + """ name: str = "EPXBUSD" precision: int = 8 minimum_margin: float = None @@ -16880,11 +23491,20 @@ def __call__(self): return "EPXBUSD" -EPXBUSD = EPXBUSD() +EPXUSDT = EPXUSDT() @dataclass(slots=True, frozen=True) class EPXUSDT: + """ + name: EPXUSDT + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 913205152.00000000 + margin: True + """ name: str = "EPXUSDT" precision: int = 8 minimum_margin: float = None @@ -16903,11 +23523,20 @@ def __call__(self): return "EPXUSDT" -EPXUSDT = EPXUSDT() +ERDBNB = ERDBNB() @dataclass(slots=True, frozen=True) class ERDBNB: + """ + name: ERDBNB + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 90000000.00000000 + margin: False + """ name: str = "ERDBNB" precision: int = 8 minimum_margin: float = None @@ -16926,11 +23555,20 @@ def __call__(self): return "ERDBNB" -ERDBNB = ERDBNB() +ERDBTC = ERDBTC() @dataclass(slots=True, frozen=True) class ERDBTC: + """ + name: ERDBTC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 92141578.00000000 + margin: False + """ name: str = "ERDBTC" precision: int = 8 minimum_margin: float = None @@ -16949,11 +23587,20 @@ def __call__(self): return "ERDBTC" -ERDBTC = ERDBTC() +ERDBUSD = ERDBUSD() @dataclass(slots=True, frozen=True) class ERDBUSD: + """ + name: ERDBUSD + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 9000000.00000000 + margin: False + """ name: str = "ERDBUSD" precision: int = 8 minimum_margin: float = None @@ -16972,11 +23619,20 @@ def __call__(self): return "ERDBUSD" -ERDBUSD = ERDBUSD() +ERDPAX = ERDPAX() @dataclass(slots=True, frozen=True) class ERDPAX: + """ + name: ERDPAX + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 90000000.00000000 + margin: False + """ name: str = "ERDPAX" precision: int = 8 minimum_margin: float = None @@ -16995,11 +23651,20 @@ def __call__(self): return "ERDPAX" -ERDPAX = ERDPAX() +ERDUSDC = ERDUSDC() @dataclass(slots=True, frozen=True) class ERDUSDC: + """ + name: ERDUSDC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 90000000.00000000 + margin: False + """ name: str = "ERDUSDC" precision: int = 8 minimum_margin: float = None @@ -17018,11 +23683,20 @@ def __call__(self): return "ERDUSDC" -ERDUSDC = ERDUSDC() +ERDUSDT = ERDUSDT() @dataclass(slots=True, frozen=True) class ERDUSDT: + """ + name: ERDUSDT + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 9000000.00000000 + margin: False + """ name: str = "ERDUSDT" precision: int = 8 minimum_margin: float = None @@ -17041,11 +23715,20 @@ def __call__(self): return "ERDUSDT" -ERDUSDT = ERDUSDT() +ERNBNB = ERNBNB() @dataclass(slots=True, frozen=True) class ERNBNB: + """ + name: ERNBNB + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 92141578.00000000 + margin: False + """ name: str = "ERNBNB" precision: int = 8 minimum_margin: float = None @@ -17064,11 +23747,20 @@ def __call__(self): return "ERNBNB" -ERNBNB = ERNBNB() +ERNBUSD = ERNBUSD() @dataclass(slots=True, frozen=True) class ERNBUSD: + """ + name: ERNBUSD + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 9222449.00000000 + margin: True + """ name: str = "ERNBUSD" precision: int = 8 minimum_margin: float = None @@ -17087,11 +23779,20 @@ def __call__(self): return "ERNBUSD" -ERNBUSD = ERNBUSD() +ERNUSDT = ERNUSDT() @dataclass(slots=True, frozen=True) class ERNUSDT: + """ + name: ERNUSDT + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 9222449.00000000 + margin: True + """ name: str = "ERNUSDT" precision: int = 8 minimum_margin: float = None @@ -17110,11 +23811,20 @@ def __call__(self): return "ERNUSDT" -ERNUSDT = ERNUSDT() +ETCBNB = ETCBNB() @dataclass(slots=True, frozen=True) class ETCBNB: + """ + name: ETCBNB + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 9000000.00000000 + margin: False + """ name: str = "ETCBNB" precision: int = 8 minimum_margin: float = None @@ -17133,11 +23843,20 @@ def __call__(self): return "ETCBNB" -ETCBNB = ETCBNB() +ETCBRL = ETCBRL() @dataclass(slots=True, frozen=True) class ETCBRL: + """ + name: ETCBRL + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 9222449.00000000 + margin: False + """ name: str = "ETCBRL" precision: int = 8 minimum_margin: float = None @@ -17156,11 +23875,20 @@ def __call__(self): return "ETCBRL" -ETCBRL = ETCBRL() +ETCBTC = ETCBTC() @dataclass(slots=True, frozen=True) class ETCBTC: + """ + name: ETCBTC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 90000000.00000000 + margin: True + """ name: str = "ETCBTC" precision: int = 8 minimum_margin: float = None @@ -17179,11 +23907,20 @@ def __call__(self): return "ETCBTC" -ETCBTC = ETCBTC() +ETCBUSD = ETCBUSD() @dataclass(slots=True, frozen=True) class ETCBUSD: + """ + name: ETCBUSD + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 90000.00000000 + margin: True + """ name: str = "ETCBUSD" precision: int = 8 minimum_margin: float = None @@ -17202,11 +23939,20 @@ def __call__(self): return "ETCBUSD" -ETCBUSD = ETCBUSD() +ETCETH = ETCETH() @dataclass(slots=True, frozen=True) class ETCETH: + """ + name: ETCETH + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 92141578.00000000 + margin: False + """ name: str = "ETCETH" precision: int = 8 minimum_margin: float = None @@ -17225,11 +23971,20 @@ def __call__(self): return "ETCETH" -ETCETH = ETCETH() +ETCEUR = ETCEUR() @dataclass(slots=True, frozen=True) class ETCEUR: + """ + name: ETCEUR + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 9222449.00000000 + margin: False + """ name: str = "ETCEUR" precision: int = 8 minimum_margin: float = None @@ -17248,11 +24003,20 @@ def __call__(self): return "ETCEUR" -ETCEUR = ETCEUR() +ETCGBP = ETCGBP() @dataclass(slots=True, frozen=True) class ETCGBP: + """ + name: ETCGBP + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 9222449.00000000 + margin: False + """ name: str = "ETCGBP" precision: int = 8 minimum_margin: float = None @@ -17271,11 +24035,20 @@ def __call__(self): return "ETCGBP" -ETCGBP = ETCGBP() +ETCPAX = ETCPAX() @dataclass(slots=True, frozen=True) class ETCPAX: + """ + name: ETCPAX + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.00100000 + maximum_order_size: 90000.00000000 + margin: False + """ name: str = "ETCPAX" precision: int = 8 minimum_margin: float = None @@ -17294,11 +24067,20 @@ def __call__(self): return "ETCPAX" -ETCPAX = ETCPAX() +ETCTRY = ETCTRY() @dataclass(slots=True, frozen=True) class ETCTRY: + """ + name: ETCTRY + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.00100000 + maximum_order_size: 922327.00000000 + margin: False + """ name: str = "ETCTRY" precision: int = 8 minimum_margin: float = None @@ -17317,11 +24099,20 @@ def __call__(self): return "ETCTRY" -ETCTRY = ETCTRY() +ETCTUSD = ETCTUSD() @dataclass(slots=True, frozen=True) class ETCTUSD: + """ + name: ETCTUSD + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.00100000 + maximum_order_size: 90000.00000000 + margin: False + """ name: str = "ETCTUSD" precision: int = 8 minimum_margin: float = None @@ -17340,11 +24131,20 @@ def __call__(self): return "ETCTUSD" -ETCTUSD = ETCTUSD() +ETCUSDC = ETCUSDC() @dataclass(slots=True, frozen=True) class ETCUSDC: + """ + name: ETCUSDC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.00100000 + maximum_order_size: 90000.00000000 + margin: False + """ name: str = "ETCUSDC" precision: int = 8 minimum_margin: float = None @@ -17363,11 +24163,20 @@ def __call__(self): return "ETCUSDC" -ETCUSDC = ETCUSDC() +ETCUSDT = ETCUSDT() @dataclass(slots=True, frozen=True) class ETCUSDT: + """ + name: ETCUSDT + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 90000.00000000 + margin: True + """ name: str = "ETCUSDT" precision: int = 8 minimum_margin: float = None @@ -17386,11 +24195,20 @@ def __call__(self): return "ETCUSDT" -ETCUSDT = ETCUSDT() +ETHAUD = ETHAUD() @dataclass(slots=True, frozen=True) class ETHAUD: + """ + name: ETHAUD + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.00010000 + maximum_order_size: 90000.00000000 + margin: False + """ name: str = "ETHAUD" precision: int = 8 minimum_margin: float = None @@ -17409,11 +24227,20 @@ def __call__(self): return "ETHAUD" -ETHAUD = ETHAUD() +ETHBEARBUSD = ETHBEARBUSD() @dataclass(slots=True, frozen=True) class ETHBEARBUSD: + """ + name: ETHBEARBUSD + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.00001000 + maximum_order_size: 90000.00000000 + margin: False + """ name: str = "ETHBEARBUSD" precision: int = 8 minimum_margin: float = None @@ -17432,11 +24259,20 @@ def __call__(self): return "ETHBEARBUSD" -ETHBEARBUSD = ETHBEARBUSD() +ETHBEARUSDT = ETHBEARUSDT() @dataclass(slots=True, frozen=True) class ETHBEARUSDT: + """ + name: ETHBEARUSDT + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.00001000 + maximum_order_size: 90000.00000000 + margin: False + """ name: str = "ETHBEARUSDT" precision: int = 8 minimum_margin: float = None @@ -17455,11 +24291,20 @@ def __call__(self): return "ETHBEARUSDT" -ETHBEARUSDT = ETHBEARUSDT() +ETHBIDR = ETHBIDR() @dataclass(slots=True, frozen=True) class ETHBIDR: + """ + name: ETHBIDR + precision: 2 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.00010000 + maximum_order_size: 100000.00000000 + margin: False + """ name: str = "ETHBIDR" precision: int = 2 minimum_margin: float = None @@ -17478,11 +24323,20 @@ def __call__(self): return "ETHBIDR" -ETHBIDR = ETHBIDR() +ETHBKRW = ETHBKRW() @dataclass(slots=True, frozen=True) class ETHBKRW: + """ + name: ETHBKRW + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.00001000 + maximum_order_size: 8000.00000000 + margin: False + """ name: str = "ETHBKRW" precision: int = 8 minimum_margin: float = None @@ -17501,11 +24355,20 @@ def __call__(self): return "ETHBKRW" -ETHBKRW = ETHBKRW() +ETHBRL = ETHBRL() @dataclass(slots=True, frozen=True) class ETHBRL: + """ + name: ETHBRL + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.00010000 + maximum_order_size: 45000.00000000 + margin: False + """ name: str = "ETHBRL" precision: int = 8 minimum_margin: float = None @@ -17524,11 +24387,20 @@ def __call__(self): return "ETHBRL" -ETHBRL = ETHBRL() +ETHBTC = ETHBTC() @dataclass(slots=True, frozen=True) class ETHBTC: + """ + name: ETHBTC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.00010000 + maximum_order_size: 100000.00000000 + margin: True + """ name: str = "ETHBTC" precision: int = 8 minimum_margin: float = None @@ -17547,11 +24419,20 @@ def __call__(self): return "ETHBTC" -ETHBTC = ETHBTC() +ETHBULLBUSD = ETHBULLBUSD() @dataclass(slots=True, frozen=True) class ETHBULLBUSD: + """ + name: ETHBULLBUSD + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.00000100 + maximum_order_size: 9000.00000000 + margin: False + """ name: str = "ETHBULLBUSD" precision: int = 8 minimum_margin: float = None @@ -17570,11 +24451,20 @@ def __call__(self): return "ETHBULLBUSD" -ETHBULLBUSD = ETHBULLBUSD() +ETHBULLUSDT = ETHBULLUSDT() @dataclass(slots=True, frozen=True) class ETHBULLUSDT: + """ + name: ETHBULLUSDT + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.00000100 + maximum_order_size: 9000.00000000 + margin: False + """ name: str = "ETHBULLUSDT" precision: int = 8 minimum_margin: float = None @@ -17593,11 +24483,20 @@ def __call__(self): return "ETHBULLUSDT" -ETHBULLUSDT = ETHBULLUSDT() +ETHBUSD = ETHBUSD() @dataclass(slots=True, frozen=True) class ETHBUSD: + """ + name: ETHBUSD + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.00010000 + maximum_order_size: 90000.00000000 + margin: True + """ name: str = "ETHBUSD" precision: int = 8 minimum_margin: float = None @@ -17616,11 +24515,20 @@ def __call__(self): return "ETHBUSD" -ETHBUSD = ETHBUSD() +ETHDAI = ETHDAI() @dataclass(slots=True, frozen=True) class ETHDAI: + """ + name: ETHDAI + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.00010000 + maximum_order_size: 90000.00000000 + margin: False + """ name: str = "ETHDAI" precision: int = 8 minimum_margin: float = None @@ -17639,11 +24547,20 @@ def __call__(self): return "ETHDAI" -ETHDAI = ETHDAI() +ETHDOWNUSDT = ETHDOWNUSDT() @dataclass(slots=True, frozen=True) class ETHDOWNUSDT: + """ + name: ETHDOWNUSDT + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 100000000.00000000 + margin: False + """ name: str = "ETHDOWNUSDT" precision: int = 8 minimum_margin: float = None @@ -17662,11 +24579,20 @@ def __call__(self): return "ETHDOWNUSDT" -ETHDOWNUSDT = ETHDOWNUSDT() +ETHEUR = ETHEUR() @dataclass(slots=True, frozen=True) class ETHEUR: + """ + name: ETHEUR + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.00010000 + maximum_order_size: 90000.00000000 + margin: False + """ name: str = "ETHEUR" precision: int = 8 minimum_margin: float = None @@ -17685,11 +24611,20 @@ def __call__(self): return "ETHEUR" -ETHEUR = ETHEUR() +ETHGBP = ETHGBP() @dataclass(slots=True, frozen=True) class ETHGBP: + """ + name: ETHGBP + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.00010000 + maximum_order_size: 90000.00000000 + margin: False + """ name: str = "ETHGBP" precision: int = 8 minimum_margin: float = None @@ -17708,11 +24643,20 @@ def __call__(self): return "ETHGBP" -ETHGBP = ETHGBP() +ETHNGN = ETHNGN() @dataclass(slots=True, frozen=True) class ETHNGN: + """ + name: ETHNGN + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.00001000 + maximum_order_size: 900.00000000 + margin: False + """ name: str = "ETHNGN" precision: int = 8 minimum_margin: float = None @@ -17731,11 +24675,20 @@ def __call__(self): return "ETHNGN" -ETHNGN = ETHNGN() +ETHPAX = ETHPAX() @dataclass(slots=True, frozen=True) class ETHPAX: + """ + name: ETHPAX + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.00010000 + maximum_order_size: 90000.00000000 + margin: False + """ name: str = "ETHPAX" precision: int = 8 minimum_margin: float = None @@ -17754,11 +24707,20 @@ def __call__(self): return "ETHPAX" -ETHPAX = ETHPAX() +ETHPLN = ETHPLN() @dataclass(slots=True, frozen=True) class ETHPLN: + """ + name: ETHPLN + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.00010000 + maximum_order_size: 92233.00000000 + margin: False + """ name: str = "ETHPLN" precision: int = 8 minimum_margin: float = None @@ -17777,11 +24739,20 @@ def __call__(self): return "ETHPLN" -ETHPLN = ETHPLN() +ETHRUB = ETHRUB() @dataclass(slots=True, frozen=True) class ETHRUB: + """ + name: ETHRUB + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.00010000 + maximum_order_size: 23055.00000000 + margin: False + """ name: str = "ETHRUB" precision: int = 8 minimum_margin: float = None @@ -17800,11 +24771,20 @@ def __call__(self): return "ETHRUB" -ETHRUB = ETHRUB() +ETHTRY = ETHTRY() @dataclass(slots=True, frozen=True) class ETHTRY: + """ + name: ETHTRY + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.00010000 + maximum_order_size: 153719.00000000 + margin: False + """ name: str = "ETHTRY" precision: int = 8 minimum_margin: float = None @@ -17823,11 +24803,20 @@ def __call__(self): return "ETHTRY" -ETHTRY = ETHTRY() +ETHTUSD = ETHTUSD() @dataclass(slots=True, frozen=True) class ETHTUSD: + """ + name: ETHTUSD + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.00010000 + maximum_order_size: 90000.00000000 + margin: False + """ name: str = "ETHTUSD" precision: int = 8 minimum_margin: float = None @@ -17846,11 +24835,20 @@ def __call__(self): return "ETHTUSD" -ETHTUSD = ETHTUSD() +ETHUAH = ETHUAH() @dataclass(slots=True, frozen=True) class ETHUAH: + """ + name: ETHUAH + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.00010000 + maximum_order_size: 9220.00000000 + margin: False + """ name: str = "ETHUAH" precision: int = 8 minimum_margin: float = None @@ -17869,11 +24867,20 @@ def __call__(self): return "ETHUAH" -ETHUAH = ETHUAH() +ETHUPUSDT = ETHUPUSDT() @dataclass(slots=True, frozen=True) class ETHUPUSDT: + """ + name: ETHUPUSDT + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 3000.00000000 + margin: False + """ name: str = "ETHUPUSDT" precision: int = 8 minimum_margin: float = None @@ -17892,11 +24899,20 @@ def __call__(self): return "ETHUPUSDT" -ETHUPUSDT = ETHUPUSDT() +ETHUSDC = ETHUSDC() @dataclass(slots=True, frozen=True) class ETHUSDC: + """ + name: ETHUSDC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.00010000 + maximum_order_size: 90000.00000000 + margin: False + """ name: str = "ETHUSDC" precision: int = 8 minimum_margin: float = None @@ -17915,11 +24931,20 @@ def __call__(self): return "ETHUSDC" -ETHUSDC = ETHUSDC() +ETHUSDP = ETHUSDP() @dataclass(slots=True, frozen=True) class ETHUSDP: + """ + name: ETHUSDP + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.00010000 + maximum_order_size: 92233.00000000 + margin: False + """ name: str = "ETHUSDP" precision: int = 8 minimum_margin: float = None @@ -17938,11 +24963,20 @@ def __call__(self): return "ETHUSDP" -ETHUSDP = ETHUSDP() +ETHUSDT = ETHUSDT() @dataclass(slots=True, frozen=True) class ETHUSDT: + """ + name: ETHUSDT + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.00010000 + maximum_order_size: 9000.00000000 + margin: True + """ name: str = "ETHUSDT" precision: int = 8 minimum_margin: float = None @@ -17961,11 +24995,20 @@ def __call__(self): return "ETHUSDT" -ETHUSDT = ETHUSDT() +ETHUST = ETHUST() @dataclass(slots=True, frozen=True) class ETHUST: + """ + name: ETHUST + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.00010000 + maximum_order_size: 92233.00000000 + margin: False + """ name: str = "ETHUST" precision: int = 8 minimum_margin: float = None @@ -17984,11 +25027,20 @@ def __call__(self): return "ETHUST" -ETHUST = ETHUST() +ETHZAR = ETHZAR() @dataclass(slots=True, frozen=True) class ETHZAR: + """ + name: ETHZAR + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.00010000 + maximum_order_size: 9223.00000000 + margin: False + """ name: str = "ETHZAR" precision: int = 8 minimum_margin: float = None @@ -18007,11 +25059,20 @@ def __call__(self): return "ETHZAR" -ETHZAR = ETHZAR() +EURBUSD = EURBUSD() @dataclass(slots=True, frozen=True) class EURBUSD: + """ + name: EURBUSD + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 900000.00000000 + margin: False + """ name: str = "EURBUSD" precision: int = 8 minimum_margin: float = None @@ -18030,11 +25091,20 @@ def __call__(self): return "EURBUSD" -EURBUSD = EURBUSD() +EURUSDT = EURUSDT() @dataclass(slots=True, frozen=True) class EURUSDT: + """ + name: EURUSDT + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 6000000.00000000 + margin: False + """ name: str = "EURUSDT" precision: int = 8 minimum_margin: float = None @@ -18053,11 +25123,20 @@ def __call__(self): return "EURUSDT" -EURUSDT = EURUSDT() +EVXBTC = EVXBTC() @dataclass(slots=True, frozen=True) class EVXBTC: + """ + name: EVXBTC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 90000000.00000000 + margin: False + """ name: str = "EVXBTC" precision: int = 8 minimum_margin: float = None @@ -18076,11 +25155,20 @@ def __call__(self): return "EVXBTC" -EVXBTC = EVXBTC() +EVXETH = EVXETH() @dataclass(slots=True, frozen=True) class EVXETH: + """ + name: EVXETH + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 90000000.00000000 + margin: False + """ name: str = "EVXETH" precision: int = 8 minimum_margin: float = None @@ -18099,11 +25187,20 @@ def __call__(self): return "EVXETH" -EVXETH = EVXETH() +EZBTC = EZBTC() @dataclass(slots=True, frozen=True) class EZBTC: + """ + name: EZBTC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 90000000.00000000 + margin: False + """ name: str = "EZBTC" precision: int = 8 minimum_margin: float = None @@ -18122,11 +25219,20 @@ def __call__(self): return "EZBTC" -EZBTC = EZBTC() +EZETH = EZETH() @dataclass(slots=True, frozen=True) class EZETH: + """ + name: EZETH + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 90000000.00000000 + margin: False + """ name: str = "EZETH" precision: int = 8 minimum_margin: float = None @@ -18145,11 +25251,20 @@ def __call__(self): return "EZETH" -EZETH = EZETH() +FARMBNB = FARMBNB() @dataclass(slots=True, frozen=True) class FARMBNB: + """ + name: FARMBNB + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.00100000 + maximum_order_size: 92141578.00000000 + margin: False + """ name: str = "FARMBNB" precision: int = 8 minimum_margin: float = None @@ -18168,11 +25283,20 @@ def __call__(self): return "FARMBNB" -FARMBNB = FARMBNB() +FARMBTC = FARMBTC() @dataclass(slots=True, frozen=True) class FARMBTC: + """ + name: FARMBTC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.00100000 + maximum_order_size: 92141578.00000000 + margin: False + """ name: str = "FARMBTC" precision: int = 8 minimum_margin: float = None @@ -18191,11 +25315,20 @@ def __call__(self): return "FARMBTC" -FARMBTC = FARMBTC() +FARMBUSD = FARMBUSD() @dataclass(slots=True, frozen=True) class FARMBUSD: + """ + name: FARMBUSD + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.00100000 + maximum_order_size: 922327.00000000 + margin: False + """ name: str = "FARMBUSD" precision: int = 8 minimum_margin: float = None @@ -18214,11 +25347,20 @@ def __call__(self): return "FARMBUSD" -FARMBUSD = FARMBUSD() +FARMETH = FARMETH() @dataclass(slots=True, frozen=True) class FARMETH: + """ + name: FARMETH + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.00010000 + maximum_order_size: 92141578.00000000 + margin: False + """ name: str = "FARMETH" precision: int = 8 minimum_margin: float = None @@ -18237,11 +25379,20 @@ def __call__(self): return "FARMETH" -FARMETH = FARMETH() +FARMUSDT = FARMUSDT() @dataclass(slots=True, frozen=True) class FARMUSDT: + """ + name: FARMUSDT + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.00100000 + maximum_order_size: 922327.00000000 + margin: False + """ name: str = "FARMUSDT" precision: int = 8 minimum_margin: float = None @@ -18260,11 +25411,20 @@ def __call__(self): return "FARMUSDT" -FARMUSDT = FARMUSDT() +FETBNB = FETBNB() @dataclass(slots=True, frozen=True) class FETBNB: + """ + name: FETBNB + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 9000000.00000000 + margin: False + """ name: str = "FETBNB" precision: int = 8 minimum_margin: float = None @@ -18283,11 +25443,20 @@ def __call__(self): return "FETBNB" -FETBNB = FETBNB() +FETBTC = FETBTC() @dataclass(slots=True, frozen=True) class FETBTC: + """ + name: FETBTC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 90000000.00000000 + margin: False + """ name: str = "FETBTC" precision: int = 8 minimum_margin: float = None @@ -18306,11 +25475,20 @@ def __call__(self): return "FETBTC" -FETBTC = FETBTC() +FETBUSD = FETBUSD() @dataclass(slots=True, frozen=True) class FETBUSD: + """ + name: FETBUSD + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 92141578.00000000 + margin: False + """ name: str = "FETBUSD" precision: int = 8 minimum_margin: float = None @@ -18329,11 +25507,20 @@ def __call__(self): return "FETBUSD" -FETBUSD = FETBUSD() +FETUSDT = FETUSDT() @dataclass(slots=True, frozen=True) class FETUSDT: + """ + name: FETUSDT + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 9000000.00000000 + margin: False + """ name: str = "FETUSDT" precision: int = 8 minimum_margin: float = None @@ -18352,11 +25539,20 @@ def __call__(self): return "FETUSDT" -FETUSDT = FETUSDT() +FIDABNB = FIDABNB() @dataclass(slots=True, frozen=True) class FIDABNB: + """ + name: FIDABNB + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 92141578.00000000 + margin: False + """ name: str = "FIDABNB" precision: int = 8 minimum_margin: float = None @@ -18375,11 +25571,20 @@ def __call__(self): return "FIDABNB" -FIDABNB = FIDABNB() +FIDABTC = FIDABTC() @dataclass(slots=True, frozen=True) class FIDABTC: + """ + name: FIDABTC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 92141578.00000000 + margin: False + """ name: str = "FIDABTC" precision: int = 8 minimum_margin: float = None @@ -18398,11 +25603,20 @@ def __call__(self): return "FIDABTC" -FIDABTC = FIDABTC() +FIDABUSD = FIDABUSD() @dataclass(slots=True, frozen=True) class FIDABUSD: + """ + name: FIDABUSD + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 92141578.00000000 + margin: True + """ name: str = "FIDABUSD" precision: int = 8 minimum_margin: float = None @@ -18421,11 +25635,20 @@ def __call__(self): return "FIDABUSD" -FIDABUSD = FIDABUSD() +FIDAUSDT = FIDAUSDT() @dataclass(slots=True, frozen=True) class FIDAUSDT: + """ + name: FIDAUSDT + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 92141578.00000000 + margin: True + """ name: str = "FIDAUSDT" precision: int = 8 minimum_margin: float = None @@ -18444,11 +25667,20 @@ def __call__(self): return "FIDAUSDT" -FIDAUSDT = FIDAUSDT() +FILBNB = FILBNB() @dataclass(slots=True, frozen=True) class FILBNB: + """ + name: FILBNB + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 9000000.00000000 + margin: False + """ name: str = "FILBNB" precision: int = 8 minimum_margin: float = None @@ -18467,11 +25699,20 @@ def __call__(self): return "FILBNB" -FILBNB = FILBNB() +FILBTC = FILBTC() @dataclass(slots=True, frozen=True) class FILBTC: + """ + name: FILBTC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 90000000.00000000 + margin: True + """ name: str = "FILBTC" precision: int = 8 minimum_margin: float = None @@ -18490,11 +25731,20 @@ def __call__(self): return "FILBTC" -FILBTC = FILBTC() +FILBUSD = FILBUSD() @dataclass(slots=True, frozen=True) class FILBUSD: + """ + name: FILBUSD + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 92141578.00000000 + margin: True + """ name: str = "FILBUSD" precision: int = 8 minimum_margin: float = None @@ -18513,11 +25763,20 @@ def __call__(self): return "FILBUSD" -FILBUSD = FILBUSD() +FILDOWNUSDT = FILDOWNUSDT() @dataclass(slots=True, frozen=True) class FILDOWNUSDT: + """ + name: FILDOWNUSDT + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 19998638.00000000 + margin: False + """ name: str = "FILDOWNUSDT" precision: int = 8 minimum_margin: float = None @@ -18536,11 +25795,20 @@ def __call__(self): return "FILDOWNUSDT" -FILDOWNUSDT = FILDOWNUSDT() +FILETH = FILETH() @dataclass(slots=True, frozen=True) class FILETH: + """ + name: FILETH + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 913205152.00000000 + margin: False + """ name: str = "FILETH" precision: int = 8 minimum_margin: float = None @@ -18559,11 +25827,20 @@ def __call__(self): return "FILETH" -FILETH = FILETH() +FILTRY = FILTRY() @dataclass(slots=True, frozen=True) class FILTRY: + """ + name: FILTRY + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.00100000 + maximum_order_size: 922327.00000000 + margin: False + """ name: str = "FILTRY" precision: int = 8 minimum_margin: float = None @@ -18582,11 +25859,20 @@ def __call__(self): return "FILTRY" -FILTRY = FILTRY() +FILUPUSDT = FILUPUSDT() @dataclass(slots=True, frozen=True) class FILUPUSDT: + """ + name: FILUPUSDT + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 920000.00000000 + margin: False + """ name: str = "FILUPUSDT" precision: int = 8 minimum_margin: float = None @@ -18605,11 +25891,20 @@ def __call__(self): return "FILUPUSDT" -FILUPUSDT = FILUPUSDT() +FILUSDT = FILUSDT() @dataclass(slots=True, frozen=True) class FILUSDT: + """ + name: FILUSDT + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 9222449.00000000 + margin: True + """ name: str = "FILUSDT" precision: int = 8 minimum_margin: float = None @@ -18628,11 +25923,20 @@ def __call__(self): return "FILUSDT" -FILUSDT = FILUSDT() +FIOBNB = FIOBNB() @dataclass(slots=True, frozen=True) class FIOBNB: + """ + name: FIOBNB + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 9000000.00000000 + margin: False + """ name: str = "FIOBNB" precision: int = 8 minimum_margin: float = None @@ -18651,11 +25955,20 @@ def __call__(self): return "FIOBNB" -FIOBNB = FIOBNB() +FIOBTC = FIOBTC() @dataclass(slots=True, frozen=True) class FIOBTC: + """ + name: FIOBTC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 90000000.00000000 + margin: False + """ name: str = "FIOBTC" precision: int = 8 minimum_margin: float = None @@ -18674,11 +25987,20 @@ def __call__(self): return "FIOBTC" -FIOBTC = FIOBTC() +FIOBUSD = FIOBUSD() @dataclass(slots=True, frozen=True) class FIOBUSD: + """ + name: FIOBUSD + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 9222449.00000000 + margin: True + """ name: str = "FIOBUSD" precision: int = 8 minimum_margin: float = None @@ -18697,11 +26019,20 @@ def __call__(self): return "FIOBUSD" -FIOBUSD = FIOBUSD() +FIOUSDT = FIOUSDT() @dataclass(slots=True, frozen=True) class FIOUSDT: + """ + name: FIOUSDT + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 9222449.00000000 + margin: True + """ name: str = "FIOUSDT" precision: int = 8 minimum_margin: float = None @@ -18720,11 +26051,20 @@ def __call__(self): return "FIOUSDT" -FIOUSDT = FIOUSDT() +FIROBTC = FIROBTC() @dataclass(slots=True, frozen=True) class FIROBTC: + """ + name: FIROBTC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 90000000.00000000 + margin: False + """ name: str = "FIROBTC" precision: int = 8 minimum_margin: float = None @@ -18743,11 +26083,20 @@ def __call__(self): return "FIROBTC" -FIROBTC = FIROBTC() +FIROBUSD = FIROBUSD() @dataclass(slots=True, frozen=True) class FIROBUSD: + """ + name: FIROBUSD + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 9222449.00000000 + margin: False + """ name: str = "FIROBUSD" precision: int = 8 minimum_margin: float = None @@ -18766,11 +26115,20 @@ def __call__(self): return "FIROBUSD" -FIROBUSD = FIROBUSD() +FIROETH = FIROETH() @dataclass(slots=True, frozen=True) class FIROETH: + """ + name: FIROETH + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 92141578.00000000 + margin: False + """ name: str = "FIROETH" precision: int = 8 minimum_margin: float = None @@ -18789,11 +26147,20 @@ def __call__(self): return "FIROETH" -FIROETH = FIROETH() +FIROUSDT = FIROUSDT() @dataclass(slots=True, frozen=True) class FIROUSDT: + """ + name: FIROUSDT + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 90000.00000000 + margin: False + """ name: str = "FIROUSDT" precision: int = 8 minimum_margin: float = None @@ -18812,11 +26179,20 @@ def __call__(self): return "FIROUSDT" -FIROUSDT = FIROUSDT() +FISBIDR = FISBIDR() @dataclass(slots=True, frozen=True) class FISBIDR: + """ + name: FISBIDR + precision: 2 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 9223371114.00000000 + margin: False + """ name: str = "FISBIDR" precision: int = 2 minimum_margin: float = None @@ -18835,11 +26211,20 @@ def __call__(self): return "FISBIDR" -FISBIDR = FISBIDR() +FISBRL = FISBRL() @dataclass(slots=True, frozen=True) class FISBRL: + """ + name: FISBRL + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 9222449.00000000 + margin: False + """ name: str = "FISBRL" precision: int = 8 minimum_margin: float = None @@ -18858,11 +26243,20 @@ def __call__(self): return "FISBRL" -FISBRL = FISBRL() +FISBTC = FISBTC() @dataclass(slots=True, frozen=True) class FISBTC: + """ + name: FISBTC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 90000000.00000000 + margin: False + """ name: str = "FISBTC" precision: int = 8 minimum_margin: float = None @@ -18881,11 +26275,20 @@ def __call__(self): return "FISBTC" -FISBTC = FISBTC() +FISBUSD = FISBUSD() @dataclass(slots=True, frozen=True) class FISBUSD: + """ + name: FISBUSD + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 9222449.00000000 + margin: False + """ name: str = "FISBUSD" precision: int = 8 minimum_margin: float = None @@ -18904,11 +26307,20 @@ def __call__(self): return "FISBUSD" -FISBUSD = FISBUSD() +FISTRY = FISTRY() @dataclass(slots=True, frozen=True) class FISTRY: + """ + name: FISTRY + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 9222449.00000000 + margin: False + """ name: str = "FISTRY" precision: int = 8 minimum_margin: float = None @@ -18927,11 +26339,20 @@ def __call__(self): return "FISTRY" -FISTRY = FISTRY() +FISUSDT = FISUSDT() @dataclass(slots=True, frozen=True) class FISUSDT: + """ + name: FISUSDT + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 9222449.00000000 + margin: False + """ name: str = "FISUSDT" precision: int = 8 minimum_margin: float = None @@ -18950,11 +26371,20 @@ def __call__(self): return "FISUSDT" -FISUSDT = FISUSDT() +FLMBNB = FLMBNB() @dataclass(slots=True, frozen=True) class FLMBNB: + """ + name: FLMBNB + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 9000000.00000000 + margin: False + """ name: str = "FLMBNB" precision: int = 8 minimum_margin: float = None @@ -18973,11 +26403,20 @@ def __call__(self): return "FLMBNB" -FLMBNB = FLMBNB() +FLMBTC = FLMBTC() @dataclass(slots=True, frozen=True) class FLMBTC: + """ + name: FLMBTC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 90000000.00000000 + margin: False + """ name: str = "FLMBTC" precision: int = 8 minimum_margin: float = None @@ -18996,11 +26435,20 @@ def __call__(self): return "FLMBTC" -FLMBTC = FLMBTC() +FLMBUSD = FLMBUSD() @dataclass(slots=True, frozen=True) class FLMBUSD: + """ + name: FLMBUSD + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 900000.00000000 + margin: False + """ name: str = "FLMBUSD" precision: int = 8 minimum_margin: float = None @@ -19019,11 +26467,20 @@ def __call__(self): return "FLMBUSD" -FLMBUSD = FLMBUSD() +FLMUSDT = FLMUSDT() @dataclass(slots=True, frozen=True) class FLMUSDT: + """ + name: FLMUSDT + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 900000.00000000 + margin: True + """ name: str = "FLMUSDT" precision: int = 8 minimum_margin: float = None @@ -19042,11 +26499,20 @@ def __call__(self): return "FLMUSDT" -FLMUSDT = FLMUSDT() +FLOWBNB = FLOWBNB() @dataclass(slots=True, frozen=True) class FLOWBNB: + """ + name: FLOWBNB + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 92141578.00000000 + margin: False + """ name: str = "FLOWBNB" precision: int = 8 minimum_margin: float = None @@ -19065,11 +26531,20 @@ def __call__(self): return "FLOWBNB" -FLOWBNB = FLOWBNB() +FLOWBTC = FLOWBTC() @dataclass(slots=True, frozen=True) class FLOWBTC: + """ + name: FLOWBTC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 92141578.00000000 + margin: True + """ name: str = "FLOWBTC" precision: int = 8 minimum_margin: float = None @@ -19088,11 +26563,20 @@ def __call__(self): return "FLOWBTC" -FLOWBTC = FLOWBTC() +FLOWBUSD = FLOWBUSD() @dataclass(slots=True, frozen=True) class FLOWBUSD: + """ + name: FLOWBUSD + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 922327.00000000 + margin: True + """ name: str = "FLOWBUSD" precision: int = 8 minimum_margin: float = None @@ -19111,11 +26595,20 @@ def __call__(self): return "FLOWBUSD" -FLOWBUSD = FLOWBUSD() +FLOWUSDT = FLOWUSDT() @dataclass(slots=True, frozen=True) class FLOWUSDT: + """ + name: FLOWUSDT + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 922327.00000000 + margin: True + """ name: str = "FLOWUSDT" precision: int = 8 minimum_margin: float = None @@ -19134,11 +26627,20 @@ def __call__(self): return "FLOWUSDT" -FLOWUSDT = FLOWUSDT() +FLUXBTC = FLUXBTC() @dataclass(slots=True, frozen=True) class FLUXBTC: + """ + name: FLUXBTC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 92141578.00000000 + margin: False + """ name: str = "FLUXBTC" precision: int = 8 minimum_margin: float = None @@ -19157,11 +26659,20 @@ def __call__(self): return "FLUXBTC" -FLUXBTC = FLUXBTC() +FLUXBUSD = FLUXBUSD() @dataclass(slots=True, frozen=True) class FLUXBUSD: + """ + name: FLUXBUSD + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 92141578.00000000 + margin: True + """ name: str = "FLUXBUSD" precision: int = 8 minimum_margin: float = None @@ -19180,11 +26691,20 @@ def __call__(self): return "FLUXBUSD" -FLUXBUSD = FLUXBUSD() +FLUXUSDT = FLUXUSDT() @dataclass(slots=True, frozen=True) class FLUXUSDT: + """ + name: FLUXUSDT + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 92141578.00000000 + margin: True + """ name: str = "FLUXUSDT" precision: int = 8 minimum_margin: float = None @@ -19203,11 +26723,20 @@ def __call__(self): return "FLUXUSDT" -FLUXUSDT = FLUXUSDT() +FORBNB = FORBNB() @dataclass(slots=True, frozen=True) class FORBNB: + """ + name: FORBNB + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 92141578.00000000 + margin: False + """ name: str = "FORBNB" precision: int = 8 minimum_margin: float = None @@ -19226,11 +26755,20 @@ def __call__(self): return "FORBNB" -FORBNB = FORBNB() +FORBTC = FORBTC() @dataclass(slots=True, frozen=True) class FORBTC: + """ + name: FORBTC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 90000000.00000000 + margin: False + """ name: str = "FORBTC" precision: int = 8 minimum_margin: float = None @@ -19249,11 +26787,20 @@ def __call__(self): return "FORBTC" -FORBTC = FORBTC() +FORBUSD = FORBUSD() @dataclass(slots=True, frozen=True) class FORBUSD: + """ + name: FORBUSD + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 9000000.00000000 + margin: False + """ name: str = "FORBUSD" precision: int = 8 minimum_margin: float = None @@ -19272,11 +26819,20 @@ def __call__(self): return "FORBUSD" -FORBUSD = FORBUSD() +FORTHBTC = FORTHBTC() @dataclass(slots=True, frozen=True) class FORTHBTC: + """ + name: FORTHBTC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 90000000.00000000 + margin: False + """ name: str = "FORTHBTC" precision: int = 8 minimum_margin: float = None @@ -19295,11 +26851,20 @@ def __call__(self): return "FORTHBTC" -FORTHBTC = FORTHBTC() +FORTHBUSD = FORTHBUSD() @dataclass(slots=True, frozen=True) class FORTHBUSD: + """ + name: FORTHBUSD + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 90000.00000000 + margin: False + """ name: str = "FORTHBUSD" precision: int = 8 minimum_margin: float = None @@ -19318,11 +26883,20 @@ def __call__(self): return "FORTHBUSD" -FORTHBUSD = FORTHBUSD() +FORTHUSDT = FORTHUSDT() @dataclass(slots=True, frozen=True) class FORTHUSDT: + """ + name: FORTHUSDT + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 90000.00000000 + margin: False + """ name: str = "FORTHUSDT" precision: int = 8 minimum_margin: float = None @@ -19341,11 +26915,20 @@ def __call__(self): return "FORTHUSDT" -FORTHUSDT = FORTHUSDT() +FORUSDT = FORUSDT() @dataclass(slots=True, frozen=True) class FORUSDT: + """ + name: FORUSDT + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 92141578.00000000 + margin: False + """ name: str = "FORUSDT" precision: int = 8 minimum_margin: float = None @@ -19364,11 +26947,20 @@ def __call__(self): return "FORUSDT" -FORUSDT = FORUSDT() +FRONTBTC = FRONTBTC() @dataclass(slots=True, frozen=True) class FRONTBTC: + """ + name: FRONTBTC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 90000000.00000000 + margin: False + """ name: str = "FRONTBTC" precision: int = 8 minimum_margin: float = None @@ -19387,11 +26979,20 @@ def __call__(self): return "FRONTBTC" -FRONTBTC = FRONTBTC() +FRONTBUSD = FRONTBUSD() @dataclass(slots=True, frozen=True) class FRONTBUSD: + """ + name: FRONTBUSD + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 900000.00000000 + margin: True + """ name: str = "FRONTBUSD" precision: int = 8 minimum_margin: float = None @@ -19410,11 +27011,20 @@ def __call__(self): return "FRONTBUSD" -FRONTBUSD = FRONTBUSD() +FRONTETH = FRONTETH() @dataclass(slots=True, frozen=True) class FRONTETH: + """ + name: FRONTETH + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 90000000.00000000 + margin: False + """ name: str = "FRONTETH" precision: int = 8 minimum_margin: float = None @@ -19433,11 +27043,20 @@ def __call__(self): return "FRONTETH" -FRONTETH = FRONTETH() +FRONTUSDT = FRONTUSDT() @dataclass(slots=True, frozen=True) class FRONTUSDT: + """ + name: FRONTUSDT + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 92141578.00000000 + margin: False + """ name: str = "FRONTUSDT" precision: int = 8 minimum_margin: float = None @@ -19456,11 +27075,20 @@ def __call__(self): return "FRONTUSDT" -FRONTUSDT = FRONTUSDT() +FTMAUD = FTMAUD() @dataclass(slots=True, frozen=True) class FTMAUD: + """ + name: FTMAUD + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 92141578.00000000 + margin: False + """ name: str = "FTMAUD" precision: int = 8 minimum_margin: float = None @@ -19479,11 +27107,20 @@ def __call__(self): return "FTMAUD" -FTMAUD = FTMAUD() +FTMBIDR = FTMBIDR() @dataclass(slots=True, frozen=True) class FTMBIDR: + """ + name: FTMBIDR + precision: 2 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 9223371114.00000000 + margin: False + """ name: str = "FTMBIDR" precision: int = 2 minimum_margin: float = None @@ -19502,11 +27139,20 @@ def __call__(self): return "FTMBIDR" -FTMBIDR = FTMBIDR() +FTMBNB = FTMBNB() @dataclass(slots=True, frozen=True) class FTMBNB: + """ + name: FTMBNB + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 9000000.00000000 + margin: False + """ name: str = "FTMBNB" precision: int = 8 minimum_margin: float = None @@ -19525,11 +27171,20 @@ def __call__(self): return "FTMBNB" -FTMBNB = FTMBNB() +FTMBRL = FTMBRL() @dataclass(slots=True, frozen=True) class FTMBRL: + """ + name: FTMBRL + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 9222449.00000000 + margin: False + """ name: str = "FTMBRL" precision: int = 8 minimum_margin: float = None @@ -19548,11 +27203,20 @@ def __call__(self): return "FTMBRL" -FTMBRL = FTMBRL() +FTMBTC = FTMBTC() @dataclass(slots=True, frozen=True) class FTMBTC: + """ + name: FTMBTC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 90000000.00000000 + margin: True + """ name: str = "FTMBTC" precision: int = 8 minimum_margin: float = None @@ -19571,11 +27235,20 @@ def __call__(self): return "FTMBTC" -FTMBTC = FTMBTC() +FTMBUSD = FTMBUSD() @dataclass(slots=True, frozen=True) class FTMBUSD: + """ + name: FTMBUSD + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 9222449.00000000 + margin: True + """ name: str = "FTMBUSD" precision: int = 8 minimum_margin: float = None @@ -19594,11 +27267,20 @@ def __call__(self): return "FTMBUSD" -FTMBUSD = FTMBUSD() +FTMETH = FTMETH() @dataclass(slots=True, frozen=True) class FTMETH: + """ + name: FTMETH + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 92141578.00000000 + margin: False + """ name: str = "FTMETH" precision: int = 8 minimum_margin: float = None @@ -19617,11 +27299,20 @@ def __call__(self): return "FTMETH" -FTMETH = FTMETH() +FTMEUR = FTMEUR() @dataclass(slots=True, frozen=True) class FTMEUR: + """ + name: FTMEUR + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 9222449.00000000 + margin: False + """ name: str = "FTMEUR" precision: int = 8 minimum_margin: float = None @@ -19640,11 +27331,20 @@ def __call__(self): return "FTMEUR" -FTMEUR = FTMEUR() +FTMPAX = FTMPAX() @dataclass(slots=True, frozen=True) class FTMPAX: + """ + name: FTMPAX + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 9000000.00000000 + margin: False + """ name: str = "FTMPAX" precision: int = 8 minimum_margin: float = None @@ -19663,11 +27363,20 @@ def __call__(self): return "FTMPAX" -FTMPAX = FTMPAX() +FTMRUB = FTMRUB() @dataclass(slots=True, frozen=True) class FTMRUB: + """ + name: FTMRUB + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 922327.00000000 + margin: False + """ name: str = "FTMRUB" precision: int = 8 minimum_margin: float = None @@ -19686,11 +27395,20 @@ def __call__(self): return "FTMRUB" -FTMRUB = FTMRUB() +FTMTRY = FTMTRY() @dataclass(slots=True, frozen=True) class FTMTRY: + """ + name: FTMTRY + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 9222449.00000000 + margin: False + """ name: str = "FTMTRY" precision: int = 8 minimum_margin: float = None @@ -19709,11 +27427,20 @@ def __call__(self): return "FTMTRY" -FTMTRY = FTMTRY() +FTMTUSD = FTMTUSD() @dataclass(slots=True, frozen=True) class FTMTUSD: + """ + name: FTMTUSD + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 9000000.00000000 + margin: False + """ name: str = "FTMTUSD" precision: int = 8 minimum_margin: float = None @@ -19732,11 +27459,20 @@ def __call__(self): return "FTMTUSD" -FTMTUSD = FTMTUSD() +FTMUSDC = FTMUSDC() @dataclass(slots=True, frozen=True) class FTMUSDC: + """ + name: FTMUSDC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 9000000.00000000 + margin: False + """ name: str = "FTMUSDC" precision: int = 8 minimum_margin: float = None @@ -19755,11 +27491,20 @@ def __call__(self): return "FTMUSDC" -FTMUSDC = FTMUSDC() +FTMUSDT = FTMUSDT() @dataclass(slots=True, frozen=True) class FTMUSDT: + """ + name: FTMUSDT + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 9000000.00000000 + margin: True + """ name: str = "FTMUSDT" precision: int = 8 minimum_margin: float = None @@ -19778,11 +27523,20 @@ def __call__(self): return "FTMUSDT" -FTMUSDT = FTMUSDT() +FTTBNB = FTTBNB() @dataclass(slots=True, frozen=True) class FTTBNB: + """ + name: FTTBNB + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 92141578.00000000 + margin: False + """ name: str = "FTTBNB" precision: int = 8 minimum_margin: float = None @@ -19801,11 +27555,20 @@ def __call__(self): return "FTTBNB" -FTTBNB = FTTBNB() +FTTBTC = FTTBTC() @dataclass(slots=True, frozen=True) class FTTBTC: + """ + name: FTTBTC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 90000000.00000000 + margin: False + """ name: str = "FTTBTC" precision: int = 8 minimum_margin: float = None @@ -19824,11 +27587,20 @@ def __call__(self): return "FTTBTC" -FTTBTC = FTTBTC() +FTTBUSD = FTTBUSD() @dataclass(slots=True, frozen=True) class FTTBUSD: + """ + name: FTTBUSD + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 922327.00000000 + margin: False + """ name: str = "FTTBUSD" precision: int = 8 minimum_margin: float = None @@ -19847,11 +27619,20 @@ def __call__(self): return "FTTBUSD" -FTTBUSD = FTTBUSD() +FTTETH = FTTETH() @dataclass(slots=True, frozen=True) class FTTETH: + """ + name: FTTETH + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.00100000 + maximum_order_size: 92141578.00000000 + margin: False + """ name: str = "FTTETH" precision: int = 8 minimum_margin: float = None @@ -19870,11 +27651,20 @@ def __call__(self): return "FTTETH" -FTTETH = FTTETH() +FTTUSDT = FTTUSDT() @dataclass(slots=True, frozen=True) class FTTUSDT: + """ + name: FTTUSDT + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 90000.00000000 + margin: False + """ name: str = "FTTUSDT" precision: int = 8 minimum_margin: float = None @@ -19893,11 +27683,20 @@ def __call__(self): return "FTTUSDT" -FTTUSDT = FTTUSDT() +FUELBTC = FUELBTC() @dataclass(slots=True, frozen=True) class FUELBTC: + """ + name: FUELBTC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 92141578.00000000 + margin: False + """ name: str = "FUELBTC" precision: int = 8 minimum_margin: float = None @@ -19916,11 +27715,20 @@ def __call__(self): return "FUELBTC" -FUELBTC = FUELBTC() +FUELETH = FUELETH() @dataclass(slots=True, frozen=True) class FUELETH: + """ + name: FUELETH + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 90000000.00000000 + margin: False + """ name: str = "FUELETH" precision: int = 8 minimum_margin: float = None @@ -19939,11 +27747,20 @@ def __call__(self): return "FUELETH" -FUELETH = FUELETH() +FUNBNB = FUNBNB() @dataclass(slots=True, frozen=True) class FUNBNB: + """ + name: FUNBNB + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 92141578.00000000 + margin: False + """ name: str = "FUNBNB" precision: int = 8 minimum_margin: float = None @@ -19962,11 +27779,20 @@ def __call__(self): return "FUNBNB" -FUNBNB = FUNBNB() +FUNBTC = FUNBTC() @dataclass(slots=True, frozen=True) class FUNBTC: + """ + name: FUNBTC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 90000000.00000000 + margin: False + """ name: str = "FUNBTC" precision: int = 8 minimum_margin: float = None @@ -19985,11 +27811,20 @@ def __call__(self): return "FUNBTC" -FUNBTC = FUNBTC() +FUNETH = FUNETH() @dataclass(slots=True, frozen=True) class FUNETH: + """ + name: FUNETH + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 90000000.00000000 + margin: False + """ name: str = "FUNETH" precision: int = 8 minimum_margin: float = None @@ -20008,11 +27843,20 @@ def __call__(self): return "FUNETH" -FUNETH = FUNETH() +FUNUSDT = FUNUSDT() @dataclass(slots=True, frozen=True) class FUNUSDT: + """ + name: FUNUSDT + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 92141578.00000000 + margin: False + """ name: str = "FUNUSDT" precision: int = 8 minimum_margin: float = None @@ -20031,11 +27875,20 @@ def __call__(self): return "FUNUSDT" -FUNUSDT = FUNUSDT() +FXSBTC = FXSBTC() @dataclass(slots=True, frozen=True) class FXSBTC: + """ + name: FXSBTC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 90000000.00000000 + margin: False + """ name: str = "FXSBTC" precision: int = 8 minimum_margin: float = None @@ -20054,11 +27907,20 @@ def __call__(self): return "FXSBTC" -FXSBTC = FXSBTC() +FXSBUSD = FXSBUSD() @dataclass(slots=True, frozen=True) class FXSBUSD: + """ + name: FXSBUSD + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 90000.00000000 + margin: False + """ name: str = "FXSBUSD" precision: int = 8 minimum_margin: float = None @@ -20077,11 +27939,20 @@ def __call__(self): return "FXSBUSD" -FXSBUSD = FXSBUSD() +FXSUSDT = FXSUSDT() @dataclass(slots=True, frozen=True) class FXSUSDT: + """ + name: FXSUSDT + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 9222449.00000000 + margin: False + """ name: str = "FXSUSDT" precision: int = 8 minimum_margin: float = None @@ -20100,11 +27971,20 @@ def __call__(self): return "FXSUSDT" -FXSUSDT = FXSUSDT() +GALAAUD = GALAAUD() @dataclass(slots=True, frozen=True) class GALAAUD: + """ + name: GALAAUD + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 92141578.00000000 + margin: False + """ name: str = "GALAAUD" precision: int = 8 minimum_margin: float = None @@ -20123,11 +28003,20 @@ def __call__(self): return "GALAAUD" -GALAAUD = GALAAUD() +GALABNB = GALABNB() @dataclass(slots=True, frozen=True) class GALABNB: + """ + name: GALABNB + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 913205152.00000000 + margin: False + """ name: str = "GALABNB" precision: int = 8 minimum_margin: float = None @@ -20146,11 +28035,20 @@ def __call__(self): return "GALABNB" -GALABNB = GALABNB() +GALABRL = GALABRL() @dataclass(slots=True, frozen=True) class GALABRL: + """ + name: GALABRL + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 92141578.00000000 + margin: False + """ name: str = "GALABRL" precision: int = 8 minimum_margin: float = None @@ -20169,11 +28067,20 @@ def __call__(self): return "GALABRL" -GALABRL = GALABRL() +GALABTC = GALABTC() @dataclass(slots=True, frozen=True) class GALABTC: + """ + name: GALABTC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 913205152.00000000 + margin: True + """ name: str = "GALABTC" precision: int = 8 minimum_margin: float = None @@ -20192,11 +28099,20 @@ def __call__(self): return "GALABTC" -GALABTC = GALABTC() +GALABUSD = GALABUSD() @dataclass(slots=True, frozen=True) class GALABUSD: + """ + name: GALABUSD + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 92141578.00000000 + margin: True + """ name: str = "GALABUSD" precision: int = 8 minimum_margin: float = None @@ -20215,11 +28131,20 @@ def __call__(self): return "GALABUSD" -GALABUSD = GALABUSD() +GALAETH = GALAETH() @dataclass(slots=True, frozen=True) class GALAETH: + """ + name: GALAETH + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 92141578.00000000 + margin: False + """ name: str = "GALAETH" precision: int = 8 minimum_margin: float = None @@ -20238,11 +28163,20 @@ def __call__(self): return "GALAETH" -GALAETH = GALAETH() +GALAEUR = GALAEUR() @dataclass(slots=True, frozen=True) class GALAEUR: + """ + name: GALAEUR + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 92141578.00000000 + margin: False + """ name: str = "GALAEUR" precision: int = 8 minimum_margin: float = None @@ -20261,11 +28195,20 @@ def __call__(self): return "GALAEUR" -GALAEUR = GALAEUR() +GALATRY = GALATRY() @dataclass(slots=True, frozen=True) class GALATRY: + """ + name: GALATRY + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 92141578.00000000 + margin: False + """ name: str = "GALATRY" precision: int = 8 minimum_margin: float = None @@ -20284,11 +28227,20 @@ def __call__(self): return "GALATRY" -GALATRY = GALATRY() +GALAUSDT = GALAUSDT() @dataclass(slots=True, frozen=True) class GALAUSDT: + """ + name: GALAUSDT + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 92141578.00000000 + margin: True + """ name: str = "GALAUSDT" precision: int = 8 minimum_margin: float = None @@ -20307,11 +28259,20 @@ def __call__(self): return "GALAUSDT" -GALAUSDT = GALAUSDT() +GALBNB = GALBNB() @dataclass(slots=True, frozen=True) class GALBNB: + """ + name: GALBNB + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.00100000 + maximum_order_size: 92141578.00000000 + margin: False + """ name: str = "GALBNB" precision: int = 8 minimum_margin: float = None @@ -20330,11 +28291,20 @@ def __call__(self): return "GALBNB" -GALBNB = GALBNB() +GALBRL = GALBRL() @dataclass(slots=True, frozen=True) class GALBRL: + """ + name: GALBRL + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 9222449.00000000 + margin: False + """ name: str = "GALBRL" precision: int = 8 minimum_margin: float = None @@ -20353,11 +28323,20 @@ def __call__(self): return "GALBRL" -GALBRL = GALBRL() +GALBTC = GALBTC() @dataclass(slots=True, frozen=True) class GALBTC: + """ + name: GALBTC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.00100000 + maximum_order_size: 92141578.00000000 + margin: False + """ name: str = "GALBTC" precision: int = 8 minimum_margin: float = None @@ -20376,11 +28355,20 @@ def __call__(self): return "GALBTC" -GALBTC = GALBTC() +GALBUSD = GALBUSD() @dataclass(slots=True, frozen=True) class GALBUSD: + """ + name: GALBUSD + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.00100000 + maximum_order_size: 92141578.00000000 + margin: True + """ name: str = "GALBUSD" precision: int = 8 minimum_margin: float = None @@ -20399,11 +28387,20 @@ def __call__(self): return "GALBUSD" -GALBUSD = GALBUSD() +GALETH = GALETH() @dataclass(slots=True, frozen=True) class GALETH: + """ + name: GALETH + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 92141578.00000000 + margin: False + """ name: str = "GALETH" precision: int = 8 minimum_margin: float = None @@ -20422,11 +28419,20 @@ def __call__(self): return "GALETH" -GALETH = GALETH() +GALEUR = GALEUR() @dataclass(slots=True, frozen=True) class GALEUR: + """ + name: GALEUR + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.00100000 + maximum_order_size: 92141578.00000000 + margin: False + """ name: str = "GALEUR" precision: int = 8 minimum_margin: float = None @@ -20445,11 +28451,20 @@ def __call__(self): return "GALEUR" -GALEUR = GALEUR() +GALTRY = GALTRY() @dataclass(slots=True, frozen=True) class GALTRY: + """ + name: GALTRY + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.00100000 + maximum_order_size: 922327.00000000 + margin: False + """ name: str = "GALTRY" precision: int = 8 minimum_margin: float = None @@ -20468,11 +28483,20 @@ def __call__(self): return "GALTRY" -GALTRY = GALTRY() +GALUSDT = GALUSDT() @dataclass(slots=True, frozen=True) class GALUSDT: + """ + name: GALUSDT + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.00100000 + maximum_order_size: 92141578.00000000 + margin: True + """ name: str = "GALUSDT" precision: int = 8 minimum_margin: float = None @@ -20491,11 +28515,20 @@ def __call__(self): return "GALUSDT" -GALUSDT = GALUSDT() +GASBTC = GASBTC() @dataclass(slots=True, frozen=True) class GASBTC: + """ + name: GASBTC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 90000000.00000000 + margin: False + """ name: str = "GASBTC" precision: int = 8 minimum_margin: float = None @@ -20514,11 +28547,20 @@ def __call__(self): return "GASBTC" -GASBTC = GASBTC() +GASBUSD = GASBUSD() @dataclass(slots=True, frozen=True) class GASBUSD: + """ + name: GASBUSD + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 92141578.00000000 + margin: False + """ name: str = "GASBUSD" precision: int = 8 minimum_margin: float = None @@ -20537,11 +28579,20 @@ def __call__(self): return "GASBUSD" -GASBUSD = GASBUSD() +GBPBUSD = GBPBUSD() @dataclass(slots=True, frozen=True) class GBPBUSD: + """ + name: GBPBUSD + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 900000.00000000 + margin: False + """ name: str = "GBPBUSD" precision: int = 8 minimum_margin: float = None @@ -20560,11 +28611,20 @@ def __call__(self): return "GBPBUSD" -GBPBUSD = GBPBUSD() +GBPUSDT = GBPUSDT() @dataclass(slots=True, frozen=True) class GBPUSDT: + """ + name: GBPUSDT + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 900000.00000000 + margin: False + """ name: str = "GBPUSDT" precision: int = 8 minimum_margin: float = None @@ -20583,11 +28643,20 @@ def __call__(self): return "GBPUSDT" -GBPUSDT = GBPUSDT() +GHSTBUSD = GHSTBUSD() @dataclass(slots=True, frozen=True) class GHSTBUSD: + """ + name: GHSTBUSD + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 900000.00000000 + margin: False + """ name: str = "GHSTBUSD" precision: int = 8 minimum_margin: float = None @@ -20606,11 +28675,20 @@ def __call__(self): return "GHSTBUSD" -GHSTBUSD = GHSTBUSD() +GHSTETH = GHSTETH() @dataclass(slots=True, frozen=True) class GHSTETH: + """ + name: GHSTETH + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 90000000.00000000 + margin: False + """ name: str = "GHSTETH" precision: int = 8 minimum_margin: float = None @@ -20629,11 +28707,20 @@ def __call__(self): return "GHSTETH" -GHSTETH = GHSTETH() +GHSTUSDT = GHSTUSDT() @dataclass(slots=True, frozen=True) class GHSTUSDT: + """ + name: GHSTUSDT + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 92141578.00000000 + margin: False + """ name: str = "GHSTUSDT" precision: int = 8 minimum_margin: float = None @@ -20652,11 +28739,20 @@ def __call__(self): return "GHSTUSDT" -GHSTUSDT = GHSTUSDT() +GLMBTC = GLMBTC() @dataclass(slots=True, frozen=True) class GLMBTC: + """ + name: GLMBTC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 90000000.00000000 + margin: True + """ name: str = "GLMBTC" precision: int = 8 minimum_margin: float = None @@ -20675,11 +28771,20 @@ def __call__(self): return "GLMBTC" -GLMBTC = GLMBTC() +GLMBUSD = GLMBUSD() @dataclass(slots=True, frozen=True) class GLMBUSD: + """ + name: GLMBUSD + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 92141578.00000000 + margin: True + """ name: str = "GLMBUSD" precision: int = 8 minimum_margin: float = None @@ -20698,11 +28803,20 @@ def __call__(self): return "GLMBUSD" -GLMBUSD = GLMBUSD() +GLMETH = GLMETH() @dataclass(slots=True, frozen=True) class GLMETH: + """ + name: GLMETH + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 90000000.00000000 + margin: False + """ name: str = "GLMETH" precision: int = 8 minimum_margin: float = None @@ -20721,11 +28835,20 @@ def __call__(self): return "GLMETH" -GLMETH = GLMETH() +GLMRBNB = GLMRBNB() @dataclass(slots=True, frozen=True) class GLMRBNB: + """ + name: GLMRBNB + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 92141578.00000000 + margin: False + """ name: str = "GLMRBNB" precision: int = 8 minimum_margin: float = None @@ -20744,11 +28867,20 @@ def __call__(self): return "GLMRBNB" -GLMRBNB = GLMRBNB() +GLMRBTC = GLMRBTC() @dataclass(slots=True, frozen=True) class GLMRBTC: + """ + name: GLMRBTC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 92141578.00000000 + margin: False + """ name: str = "GLMRBTC" precision: int = 8 minimum_margin: float = None @@ -20767,11 +28899,20 @@ def __call__(self): return "GLMRBTC" -GLMRBTC = GLMRBTC() +GLMRBUSD = GLMRBUSD() @dataclass(slots=True, frozen=True) class GLMRBUSD: + """ + name: GLMRBUSD + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 92141578.00000000 + margin: True + """ name: str = "GLMRBUSD" precision: int = 8 minimum_margin: float = None @@ -20790,11 +28931,20 @@ def __call__(self): return "GLMRBUSD" -GLMRBUSD = GLMRBUSD() +GLMRUSDT = GLMRUSDT() @dataclass(slots=True, frozen=True) class GLMRUSDT: + """ + name: GLMRUSDT + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 92141578.00000000 + margin: True + """ name: str = "GLMRUSDT" precision: int = 8 minimum_margin: float = None @@ -20813,11 +28963,20 @@ def __call__(self): return "GLMRUSDT" -GLMRUSDT = GLMRUSDT() +GMTAUD = GMTAUD() @dataclass(slots=True, frozen=True) class GMTAUD: + """ + name: GMTAUD + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 92141578.00000000 + margin: False + """ name: str = "GMTAUD" precision: int = 8 minimum_margin: float = None @@ -20836,11 +28995,20 @@ def __call__(self): return "GMTAUD" -GMTAUD = GMTAUD() +GMTBNB = GMTBNB() @dataclass(slots=True, frozen=True) class GMTBNB: + """ + name: GMTBNB + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 92141578.00000000 + margin: False + """ name: str = "GMTBNB" precision: int = 8 minimum_margin: float = None @@ -20859,11 +29027,20 @@ def __call__(self): return "GMTBNB" -GMTBNB = GMTBNB() +GMTBRL = GMTBRL() @dataclass(slots=True, frozen=True) class GMTBRL: + """ + name: GMTBRL + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 92141578.00000000 + margin: False + """ name: str = "GMTBRL" precision: int = 8 minimum_margin: float = None @@ -20882,11 +29059,20 @@ def __call__(self): return "GMTBRL" -GMTBRL = GMTBRL() +GMTBTC = GMTBTC() @dataclass(slots=True, frozen=True) class GMTBTC: + """ + name: GMTBTC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 92141578.00000000 + margin: False + """ name: str = "GMTBTC" precision: int = 8 minimum_margin: float = None @@ -20905,11 +29091,20 @@ def __call__(self): return "GMTBTC" -GMTBTC = GMTBTC() +GMTBUSD = GMTBUSD() @dataclass(slots=True, frozen=True) class GMTBUSD: + """ + name: GMTBUSD + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 92141578.00000000 + margin: True + """ name: str = "GMTBUSD" precision: int = 8 minimum_margin: float = None @@ -20928,11 +29123,20 @@ def __call__(self): return "GMTBUSD" -GMTBUSD = GMTBUSD() +GMTETH = GMTETH() @dataclass(slots=True, frozen=True) class GMTETH: + """ + name: GMTETH + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 92141578.00000000 + margin: False + """ name: str = "GMTETH" precision: int = 8 minimum_margin: float = None @@ -20951,11 +29155,20 @@ def __call__(self): return "GMTETH" -GMTETH = GMTETH() +GMTEUR = GMTEUR() @dataclass(slots=True, frozen=True) class GMTEUR: + """ + name: GMTEUR + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 92141578.00000000 + margin: False + """ name: str = "GMTEUR" precision: int = 8 minimum_margin: float = None @@ -20974,11 +29187,20 @@ def __call__(self): return "GMTEUR" -GMTEUR = GMTEUR() +GMTGBP = GMTGBP() @dataclass(slots=True, frozen=True) class GMTGBP: + """ + name: GMTGBP + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 92141578.00000000 + margin: False + """ name: str = "GMTGBP" precision: int = 8 minimum_margin: float = None @@ -20997,11 +29219,20 @@ def __call__(self): return "GMTGBP" -GMTGBP = GMTGBP() +GMTTRY = GMTTRY() @dataclass(slots=True, frozen=True) class GMTTRY: + """ + name: GMTTRY + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 922327.00000000 + margin: False + """ name: str = "GMTTRY" precision: int = 8 minimum_margin: float = None @@ -21020,11 +29251,20 @@ def __call__(self): return "GMTTRY" -GMTTRY = GMTTRY() +GMTUSDT = GMTUSDT() @dataclass(slots=True, frozen=True) class GMTUSDT: + """ + name: GMTUSDT + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 92141578.00000000 + margin: True + """ name: str = "GMTUSDT" precision: int = 8 minimum_margin: float = None @@ -21043,11 +29283,20 @@ def __call__(self): return "GMTUSDT" -GMTUSDT = GMTUSDT() +GMXBTC = GMXBTC() @dataclass(slots=True, frozen=True) class GMXBTC: + """ + name: GMXBTC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.00100000 + maximum_order_size: 913205152.00000000 + margin: False + """ name: str = "GMXBTC" precision: int = 8 minimum_margin: float = None @@ -21066,11 +29315,20 @@ def __call__(self): return "GMXBTC" -GMXBTC = GMXBTC() +GMXBUSD = GMXBUSD() @dataclass(slots=True, frozen=True) class GMXBUSD: + """ + name: GMXBUSD + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.00100000 + maximum_order_size: 9222449.00000000 + margin: True + """ name: str = "GMXBUSD" precision: int = 8 minimum_margin: float = None @@ -21089,11 +29347,20 @@ def __call__(self): return "GMXBUSD" -GMXBUSD = GMXBUSD() +GMXUSDT = GMXUSDT() @dataclass(slots=True, frozen=True) class GMXUSDT: + """ + name: GMXUSDT + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.00100000 + maximum_order_size: 9222449.00000000 + margin: True + """ name: str = "GMXUSDT" precision: int = 8 minimum_margin: float = None @@ -21112,11 +29379,20 @@ def __call__(self): return "GMXUSDT" -GMXUSDT = GMXUSDT() +GNOBNB = GNOBNB() @dataclass(slots=True, frozen=True) class GNOBNB: + """ + name: GNOBNB + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.00100000 + maximum_order_size: 92141578.00000000 + margin: False + """ name: str = "GNOBNB" precision: int = 8 minimum_margin: float = None @@ -21135,11 +29411,20 @@ def __call__(self): return "GNOBNB" -GNOBNB = GNOBNB() +GNOBTC = GNOBTC() @dataclass(slots=True, frozen=True) class GNOBTC: + """ + name: GNOBTC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.00100000 + maximum_order_size: 92141578.00000000 + margin: False + """ name: str = "GNOBTC" precision: int = 8 minimum_margin: float = None @@ -21158,11 +29443,20 @@ def __call__(self): return "GNOBTC" -GNOBTC = GNOBTC() +GNOBUSD = GNOBUSD() @dataclass(slots=True, frozen=True) class GNOBUSD: + """ + name: GNOBUSD + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.00100000 + maximum_order_size: 922327.00000000 + margin: False + """ name: str = "GNOBUSD" precision: int = 8 minimum_margin: float = None @@ -21181,11 +29475,20 @@ def __call__(self): return "GNOBUSD" -GNOBUSD = GNOBUSD() +GNOUSDT = GNOUSDT() @dataclass(slots=True, frozen=True) class GNOUSDT: + """ + name: GNOUSDT + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.00100000 + maximum_order_size: 922327.00000000 + margin: False + """ name: str = "GNOUSDT" precision: int = 8 minimum_margin: float = None @@ -21204,11 +29507,20 @@ def __call__(self): return "GNOUSDT" -GNOUSDT = GNOUSDT() +GNTBNB = GNTBNB() @dataclass(slots=True, frozen=True) class GNTBNB: + """ + name: GNTBNB + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 900000.00000000 + margin: False + """ name: str = "GNTBNB" precision: int = 8 minimum_margin: float = None @@ -21227,11 +29539,20 @@ def __call__(self): return "GNTBNB" -GNTBNB = GNTBNB() +GNTBTC = GNTBTC() @dataclass(slots=True, frozen=True) class GNTBTC: + """ + name: GNTBTC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 90000000.00000000 + margin: False + """ name: str = "GNTBTC" precision: int = 8 minimum_margin: float = None @@ -21250,11 +29571,20 @@ def __call__(self): return "GNTBTC" -GNTBTC = GNTBTC() +GNTETH = GNTETH() @dataclass(slots=True, frozen=True) class GNTETH: + """ + name: GNTETH + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 90000000.00000000 + margin: False + """ name: str = "GNTETH" precision: int = 8 minimum_margin: float = None @@ -21273,11 +29603,20 @@ def __call__(self): return "GNTETH" -GNTETH = GNTETH() +GOBNB = GOBNB() @dataclass(slots=True, frozen=True) class GOBNB: + """ + name: GOBNB + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 9000000.00000000 + margin: False + """ name: str = "GOBNB" precision: int = 8 minimum_margin: float = None @@ -21296,11 +29635,20 @@ def __call__(self): return "GOBNB" -GOBNB = GOBNB() +GOBTC = GOBTC() @dataclass(slots=True, frozen=True) class GOBTC: + """ + name: GOBTC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 90000000.00000000 + margin: False + """ name: str = "GOBTC" precision: int = 8 minimum_margin: float = None @@ -21319,11 +29667,20 @@ def __call__(self): return "GOBTC" -GOBTC = GOBTC() +GRSBTC = GRSBTC() @dataclass(slots=True, frozen=True) class GRSBTC: + """ + name: GRSBTC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 90000000.00000000 + margin: False + """ name: str = "GRSBTC" precision: int = 8 minimum_margin: float = None @@ -21342,11 +29699,20 @@ def __call__(self): return "GRSBTC" -GRSBTC = GRSBTC() +GRSETH = GRSETH() @dataclass(slots=True, frozen=True) class GRSETH: + """ + name: GRSETH + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 90000000.00000000 + margin: False + """ name: str = "GRSETH" precision: int = 8 minimum_margin: float = None @@ -21365,11 +29731,20 @@ def __call__(self): return "GRSETH" -GRSETH = GRSETH() +GRTBTC = GRTBTC() @dataclass(slots=True, frozen=True) class GRTBTC: + """ + name: GRTBTC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 90000000.00000000 + margin: True + """ name: str = "GRTBTC" precision: int = 8 minimum_margin: float = None @@ -21388,11 +29763,20 @@ def __call__(self): return "GRTBTC" -GRTBTC = GRTBTC() +GRTBUSD = GRTBUSD() @dataclass(slots=True, frozen=True) class GRTBUSD: + """ + name: GRTBUSD + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 900000.00000000 + margin: False + """ name: str = "GRTBUSD" precision: int = 8 minimum_margin: float = None @@ -21411,11 +29795,20 @@ def __call__(self): return "GRTBUSD" -GRTBUSD = GRTBUSD() +GRTETH = GRTETH() @dataclass(slots=True, frozen=True) class GRTETH: + """ + name: GRTETH + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 90000000.00000000 + margin: True + """ name: str = "GRTETH" precision: int = 8 minimum_margin: float = None @@ -21434,11 +29827,20 @@ def __call__(self): return "GRTETH" -GRTETH = GRTETH() +GRTEUR = GRTEUR() @dataclass(slots=True, frozen=True) class GRTEUR: + """ + name: GRTEUR + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 900000.00000000 + margin: False + """ name: str = "GRTEUR" precision: int = 8 minimum_margin: float = None @@ -21457,11 +29859,20 @@ def __call__(self): return "GRTEUR" -GRTEUR = GRTEUR() +GRTTRY = GRTTRY() @dataclass(slots=True, frozen=True) class GRTTRY: + """ + name: GRTTRY + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 92141578.00000000 + margin: False + """ name: str = "GRTTRY" precision: int = 8 minimum_margin: float = None @@ -21480,11 +29891,20 @@ def __call__(self): return "GRTTRY" -GRTTRY = GRTTRY() +GRTUSDT = GRTUSDT() @dataclass(slots=True, frozen=True) class GRTUSDT: + """ + name: GRTUSDT + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 900000.00000000 + margin: True + """ name: str = "GRTUSDT" precision: int = 8 minimum_margin: float = None @@ -21503,11 +29923,20 @@ def __call__(self): return "GRTUSDT" -GRTUSDT = GRTUSDT() +GTCBNB = GTCBNB() @dataclass(slots=True, frozen=True) class GTCBNB: + """ + name: GTCBNB + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 92141578.00000000 + margin: False + """ name: str = "GTCBNB" precision: int = 8 minimum_margin: float = None @@ -21526,11 +29955,20 @@ def __call__(self): return "GTCBNB" -GTCBNB = GTCBNB() +GTCBTC = GTCBTC() @dataclass(slots=True, frozen=True) class GTCBTC: + """ + name: GTCBTC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 92141578.00000000 + margin: True + """ name: str = "GTCBTC" precision: int = 8 minimum_margin: float = None @@ -21549,11 +29987,20 @@ def __call__(self): return "GTCBTC" -GTCBTC = GTCBTC() +GTCBUSD = GTCBUSD() @dataclass(slots=True, frozen=True) class GTCBUSD: + """ + name: GTCBUSD + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 9222449.00000000 + margin: True + """ name: str = "GTCBUSD" precision: int = 8 minimum_margin: float = None @@ -21572,11 +30019,20 @@ def __call__(self): return "GTCBUSD" -GTCBUSD = GTCBUSD() +GTCUSDT = GTCUSDT() @dataclass(slots=True, frozen=True) class GTCUSDT: + """ + name: GTCUSDT + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 9222449.00000000 + margin: True + """ name: str = "GTCUSDT" precision: int = 8 minimum_margin: float = None @@ -21595,11 +30051,20 @@ def __call__(self): return "GTCUSDT" -GTCUSDT = GTCUSDT() +GTOBNB = GTOBNB() @dataclass(slots=True, frozen=True) class GTOBNB: + """ + name: GTOBNB + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 9000000.00000000 + margin: False + """ name: str = "GTOBNB" precision: int = 8 minimum_margin: float = None @@ -21618,11 +30083,20 @@ def __call__(self): return "GTOBNB" -GTOBNB = GTOBNB() +GTOBTC = GTOBTC() @dataclass(slots=True, frozen=True) class GTOBTC: + """ + name: GTOBTC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 90000000.00000000 + margin: False + """ name: str = "GTOBTC" precision: int = 8 minimum_margin: float = None @@ -21641,11 +30115,20 @@ def __call__(self): return "GTOBTC" -GTOBTC = GTOBTC() +GTOBUSD = GTOBUSD() @dataclass(slots=True, frozen=True) class GTOBUSD: + """ + name: GTOBUSD + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 92141578.00000000 + margin: False + """ name: str = "GTOBUSD" precision: int = 8 minimum_margin: float = None @@ -21664,11 +30147,20 @@ def __call__(self): return "GTOBUSD" -GTOBUSD = GTOBUSD() +GTOETH = GTOETH() @dataclass(slots=True, frozen=True) class GTOETH: + """ + name: GTOETH + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 90000000.00000000 + margin: False + """ name: str = "GTOETH" precision: int = 8 minimum_margin: float = None @@ -21687,11 +30179,20 @@ def __call__(self): return "GTOETH" -GTOETH = GTOETH() +GTOPAX = GTOPAX() @dataclass(slots=True, frozen=True) class GTOPAX: + """ + name: GTOPAX + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 9000000.00000000 + margin: False + """ name: str = "GTOPAX" precision: int = 8 minimum_margin: float = None @@ -21710,11 +30211,20 @@ def __call__(self): return "GTOPAX" -GTOPAX = GTOPAX() +GTOTUSD = GTOTUSD() @dataclass(slots=True, frozen=True) class GTOTUSD: + """ + name: GTOTUSD + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 9000000.00000000 + margin: False + """ name: str = "GTOTUSD" precision: int = 8 minimum_margin: float = None @@ -21733,11 +30243,20 @@ def __call__(self): return "GTOTUSD" -GTOTUSD = GTOTUSD() +GTOUSDC = GTOUSDC() @dataclass(slots=True, frozen=True) class GTOUSDC: + """ + name: GTOUSDC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 9000000.00000000 + margin: False + """ name: str = "GTOUSDC" precision: int = 8 minimum_margin: float = None @@ -21756,11 +30275,20 @@ def __call__(self): return "GTOUSDC" -GTOUSDC = GTOUSDC() +GTOUSDT = GTOUSDT() @dataclass(slots=True, frozen=True) class GTOUSDT: + """ + name: GTOUSDT + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 9000000.00000000 + margin: False + """ name: str = "GTOUSDT" precision: int = 8 minimum_margin: float = None @@ -21779,11 +30307,20 @@ def __call__(self): return "GTOUSDT" -GTOUSDT = GTOUSDT() +GVTBTC = GVTBTC() @dataclass(slots=True, frozen=True) class GVTBTC: + """ + name: GVTBTC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 90000000.00000000 + margin: False + """ name: str = "GVTBTC" precision: int = 8 minimum_margin: float = None @@ -21802,11 +30339,20 @@ def __call__(self): return "GVTBTC" -GVTBTC = GVTBTC() +GVTETH = GVTETH() @dataclass(slots=True, frozen=True) class GVTETH: + """ + name: GVTETH + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 90000000.00000000 + margin: False + """ name: str = "GVTETH" precision: int = 8 minimum_margin: float = None @@ -21825,11 +30371,20 @@ def __call__(self): return "GVTETH" -GVTETH = GVTETH() +GXSBNB = GXSBNB() @dataclass(slots=True, frozen=True) class GXSBNB: + """ + name: GXSBNB + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 92141578.00000000 + margin: False + """ name: str = "GXSBNB" precision: int = 8 minimum_margin: float = None @@ -21848,11 +30403,20 @@ def __call__(self): return "GXSBNB" -GXSBNB = GXSBNB() +GXSBTC = GXSBTC() @dataclass(slots=True, frozen=True) class GXSBTC: + """ + name: GXSBTC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 90000000.00000000 + margin: False + """ name: str = "GXSBTC" precision: int = 8 minimum_margin: float = None @@ -21871,11 +30435,20 @@ def __call__(self): return "GXSBTC" -GXSBTC = GXSBTC() +GXSETH = GXSETH() @dataclass(slots=True, frozen=True) class GXSETH: + """ + name: GXSETH + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 9000000.00000000 + margin: False + """ name: str = "GXSETH" precision: int = 8 minimum_margin: float = None @@ -21894,11 +30467,20 @@ def __call__(self): return "GXSETH" -GXSETH = GXSETH() +GXSUSDT = GXSUSDT() @dataclass(slots=True, frozen=True) class GXSUSDT: + """ + name: GXSUSDT + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 900000.00000000 + margin: False + """ name: str = "GXSUSDT" precision: int = 8 minimum_margin: float = None @@ -21917,11 +30499,20 @@ def __call__(self): return "GXSUSDT" -GXSUSDT = GXSUSDT() +HARDBNB = HARDBNB() @dataclass(slots=True, frozen=True) class HARDBNB: + """ + name: HARDBNB + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 9000000.00000000 + margin: False + """ name: str = "HARDBNB" precision: int = 8 minimum_margin: float = None @@ -21940,11 +30531,20 @@ def __call__(self): return "HARDBNB" -HARDBNB = HARDBNB() +HARDBTC = HARDBTC() @dataclass(slots=True, frozen=True) class HARDBTC: + """ + name: HARDBTC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 90000000.00000000 + margin: False + """ name: str = "HARDBTC" precision: int = 8 minimum_margin: float = None @@ -21963,11 +30563,20 @@ def __call__(self): return "HARDBTC" -HARDBTC = HARDBTC() +HARDBUSD = HARDBUSD() @dataclass(slots=True, frozen=True) class HARDBUSD: + """ + name: HARDBUSD + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 900000.00000000 + margin: True + """ name: str = "HARDBUSD" precision: int = 8 minimum_margin: float = None @@ -21986,11 +30595,20 @@ def __call__(self): return "HARDBUSD" -HARDBUSD = HARDBUSD() +HARDUSDT = HARDUSDT() @dataclass(slots=True, frozen=True) class HARDUSDT: + """ + name: HARDUSDT + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 900000.00000000 + margin: True + """ name: str = "HARDUSDT" precision: int = 8 minimum_margin: float = None @@ -22009,11 +30627,20 @@ def __call__(self): return "HARDUSDT" -HARDUSDT = HARDUSDT() +HBARBNB = HBARBNB() @dataclass(slots=True, frozen=True) class HBARBNB: + """ + name: HBARBNB + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 9000000.00000000 + margin: False + """ name: str = "HBARBNB" precision: int = 8 minimum_margin: float = None @@ -22032,11 +30659,20 @@ def __call__(self): return "HBARBNB" -HBARBNB = HBARBNB() +HBARBTC = HBARBTC() @dataclass(slots=True, frozen=True) class HBARBTC: + """ + name: HBARBTC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 90000000.00000000 + margin: True + """ name: str = "HBARBTC" precision: int = 8 minimum_margin: float = None @@ -22055,11 +30691,20 @@ def __call__(self): return "HBARBTC" -HBARBTC = HBARBTC() +HBARBUSD = HBARBUSD() @dataclass(slots=True, frozen=True) class HBARBUSD: + """ + name: HBARBUSD + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 9000000.00000000 + margin: True + """ name: str = "HBARBUSD" precision: int = 8 minimum_margin: float = None @@ -22078,11 +30723,20 @@ def __call__(self): return "HBARBUSD" -HBARBUSD = HBARBUSD() +HBARUSDT = HBARUSDT() @dataclass(slots=True, frozen=True) class HBARUSDT: + """ + name: HBARUSDT + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 9000000.00000000 + margin: True + """ name: str = "HBARUSDT" precision: int = 8 minimum_margin: float = None @@ -22101,11 +30755,20 @@ def __call__(self): return "HBARUSDT" -HBARUSDT = HBARUSDT() +HCBTC = HCBTC() @dataclass(slots=True, frozen=True) class HCBTC: + """ + name: HCBTC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 90000000.00000000 + margin: False + """ name: str = "HCBTC" precision: int = 8 minimum_margin: float = None @@ -22124,11 +30787,20 @@ def __call__(self): return "HCBTC" -HCBTC = HCBTC() +HCETH = HCETH() @dataclass(slots=True, frozen=True) class HCETH: + """ + name: HCETH + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 90000000.00000000 + margin: False + """ name: str = "HCETH" precision: int = 8 minimum_margin: float = None @@ -22147,11 +30819,20 @@ def __call__(self): return "HCETH" -HCETH = HCETH() +HCUSDT = HCUSDT() @dataclass(slots=True, frozen=True) class HCUSDT: + """ + name: HCUSDT + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 900000.00000000 + margin: False + """ name: str = "HCUSDT" precision: int = 8 minimum_margin: float = None @@ -22170,11 +30851,20 @@ def __call__(self): return "HCUSDT" -HCUSDT = HCUSDT() +HEGICBUSD = HEGICBUSD() @dataclass(slots=True, frozen=True) class HEGICBUSD: + """ + name: HEGICBUSD + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 9222449.00000000 + margin: False + """ name: str = "HEGICBUSD" precision: int = 8 minimum_margin: float = None @@ -22193,11 +30883,20 @@ def __call__(self): return "HEGICBUSD" -HEGICBUSD = HEGICBUSD() +HEGICETH = HEGICETH() @dataclass(slots=True, frozen=True) class HEGICETH: + """ + name: HEGICETH + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 90000000.00000000 + margin: False + """ name: str = "HEGICETH" precision: int = 8 minimum_margin: float = None @@ -22216,11 +30915,20 @@ def __call__(self): return "HEGICETH" -HEGICETH = HEGICETH() +HFTBTC = HFTBTC() @dataclass(slots=True, frozen=True) class HFTBTC: + """ + name: HFTBTC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 46116860414.00000000 + margin: False + """ name: str = "HFTBTC" precision: int = 8 minimum_margin: float = None @@ -22239,11 +30947,20 @@ def __call__(self): return "HFTBTC" -HFTBTC = HFTBTC() +HFTBUSD = HFTBUSD() @dataclass(slots=True, frozen=True) class HFTBUSD: + """ + name: HFTBUSD + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 92141578.00000000 + margin: False + """ name: str = "HFTBUSD" precision: int = 8 minimum_margin: float = None @@ -22262,11 +30979,20 @@ def __call__(self): return "HFTBUSD" -HFTBUSD = HFTBUSD() +HFTUSDT = HFTUSDT() @dataclass(slots=True, frozen=True) class HFTUSDT: + """ + name: HFTUSDT + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 92141578.00000000 + margin: False + """ name: str = "HFTUSDT" precision: int = 8 minimum_margin: float = None @@ -22285,11 +31011,20 @@ def __call__(self): return "HFTUSDT" -HFTUSDT = HFTUSDT() +HIFIETH = HIFIETH() @dataclass(slots=True, frozen=True) class HIFIETH: + """ + name: HIFIETH + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 92141578.00000000 + margin: False + """ name: str = "HIFIETH" precision: int = 8 minimum_margin: float = None @@ -22308,11 +31043,20 @@ def __call__(self): return "HIFIETH" -HIFIETH = HIFIETH() +HIFIUSDT = HIFIUSDT() @dataclass(slots=True, frozen=True) class HIFIUSDT: + """ + name: HIFIUSDT + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 92141578.00000000 + margin: False + """ name: str = "HIFIUSDT" precision: int = 8 minimum_margin: float = None @@ -22331,11 +31075,20 @@ def __call__(self): return "HIFIUSDT" -HIFIUSDT = HIFIUSDT() +HIGHBNB = HIGHBNB() @dataclass(slots=True, frozen=True) class HIGHBNB: + """ + name: HIGHBNB + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 92141578.00000000 + margin: False + """ name: str = "HIGHBNB" precision: int = 8 minimum_margin: float = None @@ -22354,11 +31107,20 @@ def __call__(self): return "HIGHBNB" -HIGHBNB = HIGHBNB() +HIGHBTC = HIGHBTC() @dataclass(slots=True, frozen=True) class HIGHBTC: + """ + name: HIGHBTC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.00100000 + maximum_order_size: 92141578.00000000 + margin: False + """ name: str = "HIGHBTC" precision: int = 8 minimum_margin: float = None @@ -22377,11 +31139,20 @@ def __call__(self): return "HIGHBTC" -HIGHBTC = HIGHBTC() +HIGHBUSD = HIGHBUSD() @dataclass(slots=True, frozen=True) class HIGHBUSD: + """ + name: HIGHBUSD + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.00100000 + maximum_order_size: 9222449.00000000 + margin: False + """ name: str = "HIGHBUSD" precision: int = 8 minimum_margin: float = None @@ -22400,11 +31171,20 @@ def __call__(self): return "HIGHBUSD" -HIGHBUSD = HIGHBUSD() +HIGHUSDT = HIGHUSDT() @dataclass(slots=True, frozen=True) class HIGHUSDT: + """ + name: HIGHUSDT + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.00100000 + maximum_order_size: 9222449.00000000 + margin: False + """ name: str = "HIGHUSDT" precision: int = 8 minimum_margin: float = None @@ -22423,11 +31203,20 @@ def __call__(self): return "HIGHUSDT" -HIGHUSDT = HIGHUSDT() +HIVEBNB = HIVEBNB() @dataclass(slots=True, frozen=True) class HIVEBNB: + """ + name: HIVEBNB + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 9000000.00000000 + margin: False + """ name: str = "HIVEBNB" precision: int = 8 minimum_margin: float = None @@ -22446,11 +31235,20 @@ def __call__(self): return "HIVEBNB" -HIVEBNB = HIVEBNB() +HIVEBTC = HIVEBTC() @dataclass(slots=True, frozen=True) class HIVEBTC: + """ + name: HIVEBTC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 90000000.00000000 + margin: True + """ name: str = "HIVEBTC" precision: int = 8 minimum_margin: float = None @@ -22469,11 +31267,20 @@ def __call__(self): return "HIVEBTC" -HIVEBTC = HIVEBTC() +HIVEBUSD = HIVEBUSD() @dataclass(slots=True, frozen=True) class HIVEBUSD: + """ + name: HIVEBUSD + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 92141578.00000000 + margin: True + """ name: str = "HIVEBUSD" precision: int = 8 minimum_margin: float = None @@ -22492,11 +31299,20 @@ def __call__(self): return "HIVEBUSD" -HIVEBUSD = HIVEBUSD() +HIVEUSDT = HIVEUSDT() @dataclass(slots=True, frozen=True) class HIVEUSDT: + """ + name: HIVEUSDT + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 900000.00000000 + margin: True + """ name: str = "HIVEUSDT" precision: int = 8 minimum_margin: float = None @@ -22515,11 +31331,20 @@ def __call__(self): return "HIVEUSDT" -HIVEUSDT = HIVEUSDT() +HNTBTC = HNTBTC() @dataclass(slots=True, frozen=True) class HNTBTC: + """ + name: HNTBTC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 90000000.00000000 + margin: False + """ name: str = "HNTBTC" precision: int = 8 minimum_margin: float = None @@ -22538,11 +31363,20 @@ def __call__(self): return "HNTBTC" -HNTBTC = HNTBTC() +HNTBUSD = HNTBUSD() @dataclass(slots=True, frozen=True) class HNTBUSD: + """ + name: HNTBUSD + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 922327.00000000 + margin: False + """ name: str = "HNTBUSD" precision: int = 8 minimum_margin: float = None @@ -22561,11 +31395,20 @@ def __call__(self): return "HNTBUSD" -HNTBUSD = HNTBUSD() +HNTUSDT = HNTUSDT() @dataclass(slots=True, frozen=True) class HNTUSDT: + """ + name: HNTUSDT + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 90000.00000000 + margin: False + """ name: str = "HNTUSDT" precision: int = 8 minimum_margin: float = None @@ -22584,11 +31427,20 @@ def __call__(self): return "HNTUSDT" -HNTUSDT = HNTUSDT() +HOOKBNB = HOOKBNB() @dataclass(slots=True, frozen=True) class HOOKBNB: + """ + name: HOOKBNB + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 913205152.00000000 + margin: False + """ name: str = "HOOKBNB" precision: int = 8 minimum_margin: float = None @@ -22607,11 +31459,20 @@ def __call__(self): return "HOOKBNB" -HOOKBNB = HOOKBNB() +HOOKBTC = HOOKBTC() @dataclass(slots=True, frozen=True) class HOOKBTC: + """ + name: HOOKBTC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 46116860414.00000000 + margin: False + """ name: str = "HOOKBTC" precision: int = 8 minimum_margin: float = None @@ -22630,11 +31491,20 @@ def __call__(self): return "HOOKBTC" -HOOKBTC = HOOKBTC() +HOOKBUSD = HOOKBUSD() @dataclass(slots=True, frozen=True) class HOOKBUSD: + """ + name: HOOKBUSD + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 92141578.00000000 + margin: False + """ name: str = "HOOKBUSD" precision: int = 8 minimum_margin: float = None @@ -22653,11 +31523,20 @@ def __call__(self): return "HOOKBUSD" -HOOKBUSD = HOOKBUSD() +HOOKUSDT = HOOKUSDT() @dataclass(slots=True, frozen=True) class HOOKUSDT: + """ + name: HOOKUSDT + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 92141578.00000000 + margin: False + """ name: str = "HOOKUSDT" precision: int = 8 minimum_margin: float = None @@ -22676,11 +31555,20 @@ def __call__(self): return "HOOKUSDT" -HOOKUSDT = HOOKUSDT() +HOTBNB = HOTBNB() @dataclass(slots=True, frozen=True) class HOTBNB: + """ + name: HOTBNB + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 90000000.00000000 + margin: False + """ name: str = "HOTBNB" precision: int = 8 minimum_margin: float = None @@ -22699,11 +31587,20 @@ def __call__(self): return "HOTBNB" -HOTBNB = HOTBNB() +HOTBRL = HOTBRL() @dataclass(slots=True, frozen=True) class HOTBRL: + """ + name: HOTBRL + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 90000000.00000000 + margin: False + """ name: str = "HOTBRL" precision: int = 8 minimum_margin: float = None @@ -22722,11 +31619,20 @@ def __call__(self): return "HOTBRL" -HOTBRL = HOTBRL() +HOTBTC = HOTBTC() @dataclass(slots=True, frozen=True) class HOTBTC: + """ + name: HOTBTC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 92141578.00000000 + margin: False + """ name: str = "HOTBTC" precision: int = 8 minimum_margin: float = None @@ -22745,11 +31651,20 @@ def __call__(self): return "HOTBTC" -HOTBTC = HOTBTC() +HOTBUSD = HOTBUSD() @dataclass(slots=True, frozen=True) class HOTBUSD: + """ + name: HOTBUSD + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 92141578.00000000 + margin: True + """ name: str = "HOTBUSD" precision: int = 8 minimum_margin: float = None @@ -22768,11 +31683,20 @@ def __call__(self): return "HOTBUSD" -HOTBUSD = HOTBUSD() +HOTETH = HOTETH() @dataclass(slots=True, frozen=True) class HOTETH: + """ + name: HOTETH + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 90000000.00000000 + margin: False + """ name: str = "HOTETH" precision: int = 8 minimum_margin: float = None @@ -22791,11 +31715,20 @@ def __call__(self): return "HOTETH" -HOTETH = HOTETH() +HOTEUR = HOTEUR() @dataclass(slots=True, frozen=True) class HOTEUR: + """ + name: HOTEUR + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 92141578.00000000 + margin: False + """ name: str = "HOTEUR" precision: int = 8 minimum_margin: float = None @@ -22814,11 +31747,20 @@ def __call__(self): return "HOTEUR" -HOTEUR = HOTEUR() +HOTTRY = HOTTRY() @dataclass(slots=True, frozen=True) class HOTTRY: + """ + name: HOTTRY + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 92141578.00000000 + margin: False + """ name: str = "HOTTRY" precision: int = 8 minimum_margin: float = None @@ -22837,11 +31779,20 @@ def __call__(self): return "HOTTRY" -HOTTRY = HOTTRY() +HOTUSDT = HOTUSDT() @dataclass(slots=True, frozen=True) class HOTUSDT: + """ + name: HOTUSDT + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 92141578.00000000 + margin: True + """ name: str = "HOTUSDT" precision: int = 8 minimum_margin: float = None @@ -22860,11 +31811,20 @@ def __call__(self): return "HOTUSDT" -HOTUSDT = HOTUSDT() +HSRBTC = HSRBTC() @dataclass(slots=True, frozen=True) class HSRBTC: + """ + name: HSRBTC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 92141578.00000000 + margin: False + """ name: str = "HSRBTC" precision: int = 8 minimum_margin: float = None @@ -22883,11 +31843,20 @@ def __call__(self): return "HSRBTC" -HSRBTC = HSRBTC() +HSRETH = HSRETH() @dataclass(slots=True, frozen=True) class HSRETH: + """ + name: HSRETH + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 90000000.00000000 + margin: False + """ name: str = "HSRETH" precision: int = 8 minimum_margin: float = None @@ -22906,11 +31875,20 @@ def __call__(self): return "HSRETH" -HSRETH = HSRETH() +ICNBTC = ICNBTC() @dataclass(slots=True, frozen=True) class ICNBTC: + """ + name: ICNBTC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 90000000.00000000 + margin: False + """ name: str = "ICNBTC" precision: int = 8 minimum_margin: float = None @@ -22929,11 +31907,20 @@ def __call__(self): return "ICNBTC" -ICNBTC = ICNBTC() +ICNETH = ICNETH() @dataclass(slots=True, frozen=True) class ICNETH: + """ + name: ICNETH + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 90000000.00000000 + margin: False + """ name: str = "ICNETH" precision: int = 8 minimum_margin: float = None @@ -22952,11 +31939,20 @@ def __call__(self): return "ICNETH" -ICNETH = ICNETH() +ICPBNB = ICPBNB() @dataclass(slots=True, frozen=True) class ICPBNB: + """ + name: ICPBNB + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 92141578.00000000 + margin: False + """ name: str = "ICPBNB" precision: int = 8 minimum_margin: float = None @@ -22975,11 +31971,20 @@ def __call__(self): return "ICPBNB" -ICPBNB = ICPBNB() +ICPBTC = ICPBTC() @dataclass(slots=True, frozen=True) class ICPBTC: + """ + name: ICPBTC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 92141578.00000000 + margin: True + """ name: str = "ICPBTC" precision: int = 8 minimum_margin: float = None @@ -22998,11 +32003,20 @@ def __call__(self): return "ICPBTC" -ICPBTC = ICPBTC() +ICPBUSD = ICPBUSD() @dataclass(slots=True, frozen=True) class ICPBUSD: + """ + name: ICPBUSD + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 922327.00000000 + margin: True + """ name: str = "ICPBUSD" precision: int = 8 minimum_margin: float = None @@ -23021,11 +32035,20 @@ def __call__(self): return "ICPBUSD" -ICPBUSD = ICPBUSD() +ICPETH = ICPETH() @dataclass(slots=True, frozen=True) class ICPETH: + """ + name: ICPETH + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.00100000 + maximum_order_size: 92141578.00000000 + margin: False + """ name: str = "ICPETH" precision: int = 8 minimum_margin: float = None @@ -23044,11 +32067,20 @@ def __call__(self): return "ICPETH" -ICPETH = ICPETH() +ICPEUR = ICPEUR() @dataclass(slots=True, frozen=True) class ICPEUR: + """ + name: ICPEUR + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 9222449.00000000 + margin: False + """ name: str = "ICPEUR" precision: int = 8 minimum_margin: float = None @@ -23067,11 +32099,20 @@ def __call__(self): return "ICPEUR" -ICPEUR = ICPEUR() +ICPRUB = ICPRUB() @dataclass(slots=True, frozen=True) class ICPRUB: + """ + name: ICPRUB + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 92233.00000000 + margin: False + """ name: str = "ICPRUB" precision: int = 8 minimum_margin: float = None @@ -23090,11 +32131,20 @@ def __call__(self): return "ICPRUB" -ICPRUB = ICPRUB() +ICPTRY = ICPTRY() @dataclass(slots=True, frozen=True) class ICPTRY: + """ + name: ICPTRY + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.00100000 + maximum_order_size: 922327.00000000 + margin: False + """ name: str = "ICPTRY" precision: int = 8 minimum_margin: float = None @@ -23113,11 +32163,20 @@ def __call__(self): return "ICPTRY" -ICPTRY = ICPTRY() +ICPUSDT = ICPUSDT() @dataclass(slots=True, frozen=True) class ICPUSDT: + """ + name: ICPUSDT + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 922327.00000000 + margin: True + """ name: str = "ICPUSDT" precision: int = 8 minimum_margin: float = None @@ -23136,11 +32195,20 @@ def __call__(self): return "ICPUSDT" -ICPUSDT = ICPUSDT() +ICXBNB = ICXBNB() @dataclass(slots=True, frozen=True) class ICXBNB: + """ + name: ICXBNB + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 9000000.00000000 + margin: False + """ name: str = "ICXBNB" precision: int = 8 minimum_margin: float = None @@ -23159,11 +32227,20 @@ def __call__(self): return "ICXBNB" -ICXBNB = ICXBNB() +ICXBTC = ICXBTC() @dataclass(slots=True, frozen=True) class ICXBTC: + """ + name: ICXBTC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 90000000.00000000 + margin: False + """ name: str = "ICXBTC" precision: int = 8 minimum_margin: float = None @@ -23182,11 +32259,20 @@ def __call__(self): return "ICXBTC" -ICXBTC = ICXBTC() +ICXBUSD = ICXBUSD() @dataclass(slots=True, frozen=True) class ICXBUSD: + """ + name: ICXBUSD + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 900000.00000000 + margin: True + """ name: str = "ICXBUSD" precision: int = 8 minimum_margin: float = None @@ -23205,11 +32291,20 @@ def __call__(self): return "ICXBUSD" -ICXBUSD = ICXBUSD() +ICXETH = ICXETH() @dataclass(slots=True, frozen=True) class ICXETH: + """ + name: ICXETH + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 92141578.00000000 + margin: False + """ name: str = "ICXETH" precision: int = 8 minimum_margin: float = None @@ -23228,11 +32323,20 @@ def __call__(self): return "ICXETH" -ICXETH = ICXETH() +ICXUSDT = ICXUSDT() @dataclass(slots=True, frozen=True) class ICXUSDT: + """ + name: ICXUSDT + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 900000.00000000 + margin: True + """ name: str = "ICXUSDT" precision: int = 8 minimum_margin: float = None @@ -23251,11 +32355,20 @@ def __call__(self): return "ICXUSDT" -ICXUSDT = ICXUSDT() +IDEXBNB = IDEXBNB() @dataclass(slots=True, frozen=True) class IDEXBNB: + """ + name: IDEXBNB + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 92141578.00000000 + margin: False + """ name: str = "IDEXBNB" precision: int = 8 minimum_margin: float = None @@ -23274,11 +32387,20 @@ def __call__(self): return "IDEXBNB" -IDEXBNB = IDEXBNB() +IDEXBTC = IDEXBTC() @dataclass(slots=True, frozen=True) class IDEXBTC: + """ + name: IDEXBTC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 90000000.00000000 + margin: True + """ name: str = "IDEXBTC" precision: int = 8 minimum_margin: float = None @@ -23297,11 +32419,20 @@ def __call__(self): return "IDEXBTC" -IDEXBTC = IDEXBTC() +IDEXBUSD = IDEXBUSD() @dataclass(slots=True, frozen=True) class IDEXBUSD: + """ + name: IDEXBUSD + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 9000000.00000000 + margin: True + """ name: str = "IDEXBUSD" precision: int = 8 minimum_margin: float = None @@ -23320,11 +32451,20 @@ def __call__(self): return "IDEXBUSD" -IDEXBUSD = IDEXBUSD() +IDEXUSDT = IDEXUSDT() @dataclass(slots=True, frozen=True) class IDEXUSDT: + """ + name: IDEXUSDT + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 913205152.00000000 + margin: True + """ name: str = "IDEXUSDT" precision: int = 8 minimum_margin: float = None @@ -23343,11 +32483,20 @@ def __call__(self): return "IDEXUSDT" -IDEXUSDT = IDEXUSDT() +ILVBNB = ILVBNB() @dataclass(slots=True, frozen=True) class ILVBNB: + """ + name: ILVBNB + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.00100000 + maximum_order_size: 92141578.00000000 + margin: False + """ name: str = "ILVBNB" precision: int = 8 minimum_margin: float = None @@ -23366,11 +32515,20 @@ def __call__(self): return "ILVBNB" -ILVBNB = ILVBNB() +ILVBTC = ILVBTC() @dataclass(slots=True, frozen=True) class ILVBTC: + """ + name: ILVBTC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.00100000 + maximum_order_size: 92141578.00000000 + margin: False + """ name: str = "ILVBTC" precision: int = 8 minimum_margin: float = None @@ -23389,11 +32547,20 @@ def __call__(self): return "ILVBTC" -ILVBTC = ILVBTC() +ILVBUSD = ILVBUSD() @dataclass(slots=True, frozen=True) class ILVBUSD: + """ + name: ILVBUSD + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.00100000 + maximum_order_size: 922327.00000000 + margin: False + """ name: str = "ILVBUSD" precision: int = 8 minimum_margin: float = None @@ -23412,11 +32579,20 @@ def __call__(self): return "ILVBUSD" -ILVBUSD = ILVBUSD() +ILVUSDT = ILVUSDT() @dataclass(slots=True, frozen=True) class ILVUSDT: + """ + name: ILVUSDT + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.00100000 + maximum_order_size: 922327.00000000 + margin: False + """ name: str = "ILVUSDT" precision: int = 8 minimum_margin: float = None @@ -23435,11 +32611,20 @@ def __call__(self): return "ILVUSDT" -ILVUSDT = ILVUSDT() +IMXBNB = IMXBNB() @dataclass(slots=True, frozen=True) class IMXBNB: + """ + name: IMXBNB + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 92141578.00000000 + margin: False + """ name: str = "IMXBNB" precision: int = 8 minimum_margin: float = None @@ -23458,11 +32643,20 @@ def __call__(self): return "IMXBNB" -IMXBNB = IMXBNB() +IMXBTC = IMXBTC() @dataclass(slots=True, frozen=True) class IMXBTC: + """ + name: IMXBTC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 92141578.00000000 + margin: False + """ name: str = "IMXBTC" precision: int = 8 minimum_margin: float = None @@ -23481,11 +32675,20 @@ def __call__(self): return "IMXBTC" -IMXBTC = IMXBTC() +IMXBUSD = IMXBUSD() @dataclass(slots=True, frozen=True) class IMXBUSD: + """ + name: IMXBUSD + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 92141578.00000000 + margin: True + """ name: str = "IMXBUSD" precision: int = 8 minimum_margin: float = None @@ -23504,11 +32707,20 @@ def __call__(self): return "IMXBUSD" -IMXBUSD = IMXBUSD() +IMXUSDT = IMXUSDT() @dataclass(slots=True, frozen=True) class IMXUSDT: + """ + name: IMXUSDT + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 92141578.00000000 + margin: True + """ name: str = "IMXUSDT" precision: int = 8 minimum_margin: float = None @@ -23527,11 +32739,20 @@ def __call__(self): return "IMXUSDT" -IMXUSDT = IMXUSDT() +INJBNB = INJBNB() @dataclass(slots=True, frozen=True) class INJBNB: + """ + name: INJBNB + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 9000000.00000000 + margin: False + """ name: str = "INJBNB" precision: int = 8 minimum_margin: float = None @@ -23550,11 +32771,20 @@ def __call__(self): return "INJBNB" -INJBNB = INJBNB() +INJBTC = INJBTC() @dataclass(slots=True, frozen=True) class INJBTC: + """ + name: INJBTC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 90000000.00000000 + margin: True + """ name: str = "INJBTC" precision: int = 8 minimum_margin: float = None @@ -23573,11 +32803,20 @@ def __call__(self): return "INJBTC" -INJBTC = INJBTC() +INJBUSD = INJBUSD() @dataclass(slots=True, frozen=True) class INJBUSD: + """ + name: INJBUSD + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 90000.00000000 + margin: True + """ name: str = "INJBUSD" precision: int = 8 minimum_margin: float = None @@ -23596,11 +32835,20 @@ def __call__(self): return "INJBUSD" -INJBUSD = INJBUSD() +INJTRY = INJTRY() @dataclass(slots=True, frozen=True) class INJTRY: + """ + name: INJTRY + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 9222449.00000000 + margin: False + """ name: str = "INJTRY" precision: int = 8 minimum_margin: float = None @@ -23619,11 +32867,20 @@ def __call__(self): return "INJTRY" -INJTRY = INJTRY() +INJUSDT = INJUSDT() @dataclass(slots=True, frozen=True) class INJUSDT: + """ + name: INJUSDT + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 90000.00000000 + margin: True + """ name: str = "INJUSDT" precision: int = 8 minimum_margin: float = None @@ -23642,11 +32899,20 @@ def __call__(self): return "INJUSDT" -INJUSDT = INJUSDT() +INSBTC = INSBTC() @dataclass(slots=True, frozen=True) class INSBTC: + """ + name: INSBTC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 90000000.00000000 + margin: False + """ name: str = "INSBTC" precision: int = 8 minimum_margin: float = None @@ -23665,11 +32931,20 @@ def __call__(self): return "INSBTC" -INSBTC = INSBTC() +INSETH = INSETH() @dataclass(slots=True, frozen=True) class INSETH: + """ + name: INSETH + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 90000000.00000000 + margin: False + """ name: str = "INSETH" precision: int = 8 minimum_margin: float = None @@ -23688,11 +32963,20 @@ def __call__(self): return "INSETH" -INSETH = INSETH() +IOSTBTC = IOSTBTC() @dataclass(slots=True, frozen=True) class IOSTBTC: + """ + name: IOSTBTC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 90000000.00000000 + margin: True + """ name: str = "IOSTBTC" precision: int = 8 minimum_margin: float = None @@ -23711,11 +32995,20 @@ def __call__(self): return "IOSTBTC" -IOSTBTC = IOSTBTC() +IOSTBUSD = IOSTBUSD() @dataclass(slots=True, frozen=True) class IOSTBUSD: + """ + name: IOSTBUSD + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 9000000.00000000 + margin: False + """ name: str = "IOSTBUSD" precision: int = 8 minimum_margin: float = None @@ -23734,11 +33027,20 @@ def __call__(self): return "IOSTBUSD" -IOSTBUSD = IOSTBUSD() +IOSTETH = IOSTETH() @dataclass(slots=True, frozen=True) class IOSTETH: + """ + name: IOSTETH + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 90000000.00000000 + margin: False + """ name: str = "IOSTETH" precision: int = 8 minimum_margin: float = None @@ -23757,11 +33059,20 @@ def __call__(self): return "IOSTETH" -IOSTETH = IOSTETH() +IOSTUSDT = IOSTUSDT() @dataclass(slots=True, frozen=True) class IOSTUSDT: + """ + name: IOSTUSDT + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 9000000.00000000 + margin: True + """ name: str = "IOSTUSDT" precision: int = 8 minimum_margin: float = None @@ -23780,11 +33091,20 @@ def __call__(self): return "IOSTUSDT" -IOSTUSDT = IOSTUSDT() +IOTABNB = IOTABNB() @dataclass(slots=True, frozen=True) class IOTABNB: + """ + name: IOTABNB + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 9000000.00000000 + margin: False + """ name: str = "IOTABNB" precision: int = 8 minimum_margin: float = None @@ -23803,11 +33123,20 @@ def __call__(self): return "IOTABNB" -IOTABNB = IOTABNB() +IOTABTC = IOTABTC() @dataclass(slots=True, frozen=True) class IOTABTC: + """ + name: IOTABTC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 90000000.00000000 + margin: True + """ name: str = "IOTABTC" precision: int = 8 minimum_margin: float = None @@ -23826,11 +33155,20 @@ def __call__(self): return "IOTABTC" -IOTABTC = IOTABTC() +IOTABUSD = IOTABUSD() @dataclass(slots=True, frozen=True) class IOTABUSD: + """ + name: IOTABUSD + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 900000.00000000 + margin: False + """ name: str = "IOTABUSD" precision: int = 8 minimum_margin: float = None @@ -23849,11 +33187,20 @@ def __call__(self): return "IOTABUSD" -IOTABUSD = IOTABUSD() +IOTAETH = IOTAETH() @dataclass(slots=True, frozen=True) class IOTAETH: + """ + name: IOTAETH + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 90000000.00000000 + margin: False + """ name: str = "IOTAETH" precision: int = 8 minimum_margin: float = None @@ -23872,11 +33219,20 @@ def __call__(self): return "IOTAETH" -IOTAETH = IOTAETH() +IOTAUSDT = IOTAUSDT() @dataclass(slots=True, frozen=True) class IOTAUSDT: + """ + name: IOTAUSDT + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 900000.00000000 + margin: True + """ name: str = "IOTAUSDT" precision: int = 8 minimum_margin: float = None @@ -23895,11 +33251,20 @@ def __call__(self): return "IOTAUSDT" -IOTAUSDT = IOTAUSDT() +IOTXBTC = IOTXBTC() @dataclass(slots=True, frozen=True) class IOTXBTC: + """ + name: IOTXBTC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 90000000.00000000 + margin: True + """ name: str = "IOTXBTC" precision: int = 8 minimum_margin: float = None @@ -23918,11 +33283,20 @@ def __call__(self): return "IOTXBTC" -IOTXBTC = IOTXBTC() +IOTXBUSD = IOTXBUSD() @dataclass(slots=True, frozen=True) class IOTXBUSD: + """ + name: IOTXBUSD + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 92141578.00000000 + margin: True + """ name: str = "IOTXBUSD" precision: int = 8 minimum_margin: float = None @@ -23941,11 +33315,20 @@ def __call__(self): return "IOTXBUSD" -IOTXBUSD = IOTXBUSD() +IOTXETH = IOTXETH() @dataclass(slots=True, frozen=True) class IOTXETH: + """ + name: IOTXETH + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 90000000.00000000 + margin: False + """ name: str = "IOTXETH" precision: int = 8 minimum_margin: float = None @@ -23964,11 +33347,20 @@ def __call__(self): return "IOTXETH" -IOTXETH = IOTXETH() +IOTXUSDT = IOTXUSDT() @dataclass(slots=True, frozen=True) class IOTXUSDT: + """ + name: IOTXUSDT + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 92141578.00000000 + margin: True + """ name: str = "IOTXUSDT" precision: int = 8 minimum_margin: float = None @@ -23987,11 +33379,20 @@ def __call__(self): return "IOTXUSDT" -IOTXUSDT = IOTXUSDT() +IQBNB = IQBNB() @dataclass(slots=True, frozen=True) class IQBNB: + """ + name: IQBNB + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 90000000.00000000 + margin: False + """ name: str = "IQBNB" precision: int = 8 minimum_margin: float = None @@ -24010,11 +33411,20 @@ def __call__(self): return "IQBNB" -IQBNB = IQBNB() +IQBUSD = IQBUSD() @dataclass(slots=True, frozen=True) class IQBUSD: + """ + name: IQBUSD + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 92141578.00000000 + margin: False + """ name: str = "IQBUSD" precision: int = 8 minimum_margin: float = None @@ -24033,11 +33443,20 @@ def __call__(self): return "IQBUSD" -IQBUSD = IQBUSD() +IRISBNB = IRISBNB() @dataclass(slots=True, frozen=True) class IRISBNB: + """ + name: IRISBNB + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 9000000.00000000 + margin: False + """ name: str = "IRISBNB" precision: int = 8 minimum_margin: float = None @@ -24056,11 +33475,20 @@ def __call__(self): return "IRISBNB" -IRISBNB = IRISBNB() +IRISBTC = IRISBTC() @dataclass(slots=True, frozen=True) class IRISBTC: + """ + name: IRISBTC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 90000000.00000000 + margin: False + """ name: str = "IRISBTC" precision: int = 8 minimum_margin: float = None @@ -24079,11 +33507,20 @@ def __call__(self): return "IRISBTC" -IRISBTC = IRISBTC() +IRISBUSD = IRISBUSD() @dataclass(slots=True, frozen=True) class IRISBUSD: + """ + name: IRISBUSD + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 9000000.00000000 + margin: False + """ name: str = "IRISBUSD" precision: int = 8 minimum_margin: float = None @@ -24102,11 +33539,20 @@ def __call__(self): return "IRISBUSD" -IRISBUSD = IRISBUSD() +IRISUSDT = IRISUSDT() @dataclass(slots=True, frozen=True) class IRISUSDT: + """ + name: IRISUSDT + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 9000000.00000000 + margin: False + """ name: str = "IRISUSDT" precision: int = 8 minimum_margin: float = None @@ -24125,11 +33571,20 @@ def __call__(self): return "IRISUSDT" -IRISUSDT = IRISUSDT() +JASMYBNB = JASMYBNB() @dataclass(slots=True, frozen=True) class JASMYBNB: + """ + name: JASMYBNB + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 92141578.00000000 + margin: False + """ name: str = "JASMYBNB" precision: int = 8 minimum_margin: float = None @@ -24148,11 +33603,20 @@ def __call__(self): return "JASMYBNB" -JASMYBNB = JASMYBNB() +JASMYBTC = JASMYBTC() @dataclass(slots=True, frozen=True) class JASMYBTC: + """ + name: JASMYBTC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 92141578.00000000 + margin: True + """ name: str = "JASMYBTC" precision: int = 8 minimum_margin: float = None @@ -24171,11 +33635,20 @@ def __call__(self): return "JASMYBTC" -JASMYBTC = JASMYBTC() +JASMYBUSD = JASMYBUSD() @dataclass(slots=True, frozen=True) class JASMYBUSD: + """ + name: JASMYBUSD + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 92141578.00000000 + margin: True + """ name: str = "JASMYBUSD" precision: int = 8 minimum_margin: float = None @@ -24194,11 +33667,20 @@ def __call__(self): return "JASMYBUSD" -JASMYBUSD = JASMYBUSD() +JASMYETH = JASMYETH() @dataclass(slots=True, frozen=True) class JASMYETH: + """ + name: JASMYETH + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 92141578.00000000 + margin: False + """ name: str = "JASMYETH" precision: int = 8 minimum_margin: float = None @@ -24217,11 +33699,20 @@ def __call__(self): return "JASMYETH" -JASMYETH = JASMYETH() +JASMYEUR = JASMYEUR() @dataclass(slots=True, frozen=True) class JASMYEUR: + """ + name: JASMYEUR + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 92141578.00000000 + margin: False + """ name: str = "JASMYEUR" precision: int = 8 minimum_margin: float = None @@ -24240,11 +33731,20 @@ def __call__(self): return "JASMYEUR" -JASMYEUR = JASMYEUR() +JASMYTRY = JASMYTRY() @dataclass(slots=True, frozen=True) class JASMYTRY: + """ + name: JASMYTRY + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 92141578.00000000 + margin: False + """ name: str = "JASMYTRY" precision: int = 8 minimum_margin: float = None @@ -24263,11 +33763,20 @@ def __call__(self): return "JASMYTRY" -JASMYTRY = JASMYTRY() +JASMYUSDT = JASMYUSDT() @dataclass(slots=True, frozen=True) class JASMYUSDT: + """ + name: JASMYUSDT + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 92141578.00000000 + margin: True + """ name: str = "JASMYUSDT" precision: int = 8 minimum_margin: float = None @@ -24286,11 +33795,20 @@ def __call__(self): return "JASMYUSDT" -JASMYUSDT = JASMYUSDT() +JOEBTC = JOEBTC() @dataclass(slots=True, frozen=True) class JOEBTC: + """ + name: JOEBTC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 92141578.00000000 + margin: False + """ name: str = "JOEBTC" precision: int = 8 minimum_margin: float = None @@ -24309,11 +33827,20 @@ def __call__(self): return "JOEBTC" -JOEBTC = JOEBTC() +JOEBUSD = JOEBUSD() @dataclass(slots=True, frozen=True) class JOEBUSD: + """ + name: JOEBUSD + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 92141578.00000000 + margin: False + """ name: str = "JOEBUSD" precision: int = 8 minimum_margin: float = None @@ -24332,11 +33859,20 @@ def __call__(self): return "JOEBUSD" -JOEBUSD = JOEBUSD() +JOEUSDT = JOEUSDT() @dataclass(slots=True, frozen=True) class JOEUSDT: + """ + name: JOEUSDT + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 92141578.00000000 + margin: False + """ name: str = "JOEUSDT" precision: int = 8 minimum_margin: float = None @@ -24355,11 +33891,20 @@ def __call__(self): return "JOEUSDT" -JOEUSDT = JOEUSDT() +JSTBNB = JSTBNB() @dataclass(slots=True, frozen=True) class JSTBNB: + """ + name: JSTBNB + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 9000000.00000000 + margin: False + """ name: str = "JSTBNB" precision: int = 8 minimum_margin: float = None @@ -24378,11 +33923,20 @@ def __call__(self): return "JSTBNB" -JSTBNB = JSTBNB() +JSTBTC = JSTBTC() @dataclass(slots=True, frozen=True) class JSTBTC: + """ + name: JSTBTC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 90000000.00000000 + margin: True + """ name: str = "JSTBTC" precision: int = 8 minimum_margin: float = None @@ -24401,11 +33955,20 @@ def __call__(self): return "JSTBTC" -JSTBTC = JSTBTC() +JSTBUSD = JSTBUSD() @dataclass(slots=True, frozen=True) class JSTBUSD: + """ + name: JSTBUSD + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 9000000.00000000 + margin: True + """ name: str = "JSTBUSD" precision: int = 8 minimum_margin: float = None @@ -24424,11 +33987,20 @@ def __call__(self): return "JSTBUSD" -JSTBUSD = JSTBUSD() +JSTUSDT = JSTUSDT() @dataclass(slots=True, frozen=True) class JSTUSDT: + """ + name: JSTUSDT + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 9000000.00000000 + margin: True + """ name: str = "JSTUSDT" precision: int = 8 minimum_margin: float = None @@ -24447,11 +34019,20 @@ def __call__(self): return "JSTUSDT" -JSTUSDT = JSTUSDT() +JUVBTC = JUVBTC() @dataclass(slots=True, frozen=True) class JUVBTC: + """ + name: JUVBTC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 90000000.00000000 + margin: False + """ name: str = "JUVBTC" precision: int = 8 minimum_margin: float = None @@ -24470,11 +34051,20 @@ def __call__(self): return "JUVBTC" -JUVBTC = JUVBTC() +JUVBUSD = JUVBUSD() @dataclass(slots=True, frozen=True) class JUVBUSD: + """ + name: JUVBUSD + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 92141578.00000000 + margin: False + """ name: str = "JUVBUSD" precision: int = 8 minimum_margin: float = None @@ -24493,11 +34083,20 @@ def __call__(self): return "JUVBUSD" -JUVBUSD = JUVBUSD() +JUVUSDT = JUVUSDT() @dataclass(slots=True, frozen=True) class JUVUSDT: + """ + name: JUVUSDT + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 90000.00000000 + margin: False + """ name: str = "JUVUSDT" precision: int = 8 minimum_margin: float = None @@ -24516,11 +34115,20 @@ def __call__(self): return "JUVUSDT" -JUVUSDT = JUVUSDT() +KAVABNB = KAVABNB() @dataclass(slots=True, frozen=True) class KAVABNB: + """ + name: KAVABNB + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 9000000.00000000 + margin: False + """ name: str = "KAVABNB" precision: int = 8 minimum_margin: float = None @@ -24539,11 +34147,20 @@ def __call__(self): return "KAVABNB" -KAVABNB = KAVABNB() +KAVABTC = KAVABTC() @dataclass(slots=True, frozen=True) class KAVABTC: + """ + name: KAVABTC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 90000000.00000000 + margin: True + """ name: str = "KAVABTC" precision: int = 8 minimum_margin: float = None @@ -24562,11 +34179,20 @@ def __call__(self): return "KAVABTC" -KAVABTC = KAVABTC() +KAVABUSD = KAVABUSD() @dataclass(slots=True, frozen=True) class KAVABUSD: + """ + name: KAVABUSD + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 9222449.00000000 + margin: True + """ name: str = "KAVABUSD" precision: int = 8 minimum_margin: float = None @@ -24585,11 +34211,20 @@ def __call__(self): return "KAVABUSD" -KAVABUSD = KAVABUSD() +KAVAETH = KAVAETH() @dataclass(slots=True, frozen=True) class KAVAETH: + """ + name: KAVAETH + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 92141578.00000000 + margin: False + """ name: str = "KAVAETH" precision: int = 8 minimum_margin: float = None @@ -24608,11 +34243,20 @@ def __call__(self): return "KAVAETH" -KAVAETH = KAVAETH() +KAVAUSDT = KAVAUSDT() @dataclass(slots=True, frozen=True) class KAVAUSDT: + """ + name: KAVAUSDT + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 900000.00000000 + margin: True + """ name: str = "KAVAUSDT" precision: int = 8 minimum_margin: float = None @@ -24631,11 +34275,20 @@ def __call__(self): return "KAVAUSDT" -KAVAUSDT = KAVAUSDT() +KDABTC = KDABTC() @dataclass(slots=True, frozen=True) class KDABTC: + """ + name: KDABTC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 92141578.00000000 + margin: False + """ name: str = "KDABTC" precision: int = 8 minimum_margin: float = None @@ -24654,11 +34307,20 @@ def __call__(self): return "KDABTC" -KDABTC = KDABTC() +KDABUSD = KDABUSD() @dataclass(slots=True, frozen=True) class KDABUSD: + """ + name: KDABUSD + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 92141578.00000000 + margin: True + """ name: str = "KDABUSD" precision: int = 8 minimum_margin: float = None @@ -24677,11 +34339,20 @@ def __call__(self): return "KDABUSD" -KDABUSD = KDABUSD() +KDAUSDT = KDAUSDT() @dataclass(slots=True, frozen=True) class KDAUSDT: + """ + name: KDAUSDT + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 92141578.00000000 + margin: True + """ name: str = "KDAUSDT" precision: int = 8 minimum_margin: float = None @@ -24700,11 +34371,20 @@ def __call__(self): return "KDAUSDT" -KDAUSDT = KDAUSDT() +KEEPBNB = KEEPBNB() @dataclass(slots=True, frozen=True) class KEEPBNB: + """ + name: KEEPBNB + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 9222449.00000000 + margin: False + """ name: str = "KEEPBNB" precision: int = 8 minimum_margin: float = None @@ -24723,11 +34403,20 @@ def __call__(self): return "KEEPBNB" -KEEPBNB = KEEPBNB() +KEEPBTC = KEEPBTC() @dataclass(slots=True, frozen=True) class KEEPBTC: + """ + name: KEEPBTC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 92141578.00000000 + margin: False + """ name: str = "KEEPBTC" precision: int = 8 minimum_margin: float = None @@ -24746,11 +34435,20 @@ def __call__(self): return "KEEPBTC" -KEEPBTC = KEEPBTC() +KEEPBUSD = KEEPBUSD() @dataclass(slots=True, frozen=True) class KEEPBUSD: + """ + name: KEEPBUSD + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 922327.00000000 + margin: False + """ name: str = "KEEPBUSD" precision: int = 8 minimum_margin: float = None @@ -24769,11 +34467,20 @@ def __call__(self): return "KEEPBUSD" -KEEPBUSD = KEEPBUSD() +KEEPUSDT = KEEPUSDT() @dataclass(slots=True, frozen=True) class KEEPUSDT: + """ + name: KEEPUSDT + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 922327.00000000 + margin: False + """ name: str = "KEEPUSDT" precision: int = 8 minimum_margin: float = None @@ -24792,11 +34499,20 @@ def __call__(self): return "KEEPUSDT" -KEEPUSDT = KEEPUSDT() +KEYBTC = KEYBTC() @dataclass(slots=True, frozen=True) class KEYBTC: + """ + name: KEYBTC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 92141578.00000000 + margin: False + """ name: str = "KEYBTC" precision: int = 8 minimum_margin: float = None @@ -24815,11 +34531,20 @@ def __call__(self): return "KEYBTC" -KEYBTC = KEYBTC() +KEYBUSD = KEYBUSD() @dataclass(slots=True, frozen=True) class KEYBUSD: + """ + name: KEYBUSD + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 92141578.00000000 + margin: False + """ name: str = "KEYBUSD" precision: int = 8 minimum_margin: float = None @@ -24838,11 +34563,20 @@ def __call__(self): return "KEYBUSD" -KEYBUSD = KEYBUSD() +KEYETH = KEYETH() @dataclass(slots=True, frozen=True) class KEYETH: + """ + name: KEYETH + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 90000000.00000000 + margin: False + """ name: str = "KEYETH" precision: int = 8 minimum_margin: float = None @@ -24861,11 +34595,20 @@ def __call__(self): return "KEYETH" -KEYETH = KEYETH() +KEYUSDT = KEYUSDT() @dataclass(slots=True, frozen=True) class KEYUSDT: + """ + name: KEYUSDT + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 92141578.00000000 + margin: False + """ name: str = "KEYUSDT" precision: int = 8 minimum_margin: float = None @@ -24884,11 +34627,20 @@ def __call__(self): return "KEYUSDT" -KEYUSDT = KEYUSDT() +KLAYBNB = KLAYBNB() @dataclass(slots=True, frozen=True) class KLAYBNB: + """ + name: KLAYBNB + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 92141578.00000000 + margin: False + """ name: str = "KLAYBNB" precision: int = 8 minimum_margin: float = None @@ -24907,11 +34659,20 @@ def __call__(self): return "KLAYBNB" -KLAYBNB = KLAYBNB() +KLAYBTC = KLAYBTC() @dataclass(slots=True, frozen=True) class KLAYBTC: + """ + name: KLAYBTC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 92141578.00000000 + margin: False + """ name: str = "KLAYBTC" precision: int = 8 minimum_margin: float = None @@ -24930,11 +34691,20 @@ def __call__(self): return "KLAYBTC" -KLAYBTC = KLAYBTC() +KLAYBUSD = KLAYBUSD() @dataclass(slots=True, frozen=True) class KLAYBUSD: + """ + name: KLAYBUSD + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 9222449.00000000 + margin: True + """ name: str = "KLAYBUSD" precision: int = 8 minimum_margin: float = None @@ -24953,11 +34723,20 @@ def __call__(self): return "KLAYBUSD" -KLAYBUSD = KLAYBUSD() +KLAYUSDT = KLAYUSDT() @dataclass(slots=True, frozen=True) class KLAYUSDT: + """ + name: KLAYUSDT + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 9222449.00000000 + margin: True + """ name: str = "KLAYUSDT" precision: int = 8 minimum_margin: float = None @@ -24976,11 +34755,20 @@ def __call__(self): return "KLAYUSDT" -KLAYUSDT = KLAYUSDT() +KMDBTC = KMDBTC() @dataclass(slots=True, frozen=True) class KMDBTC: + """ + name: KMDBTC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 9000000.00000000 + margin: False + """ name: str = "KMDBTC" precision: int = 8 minimum_margin: float = None @@ -24999,11 +34787,20 @@ def __call__(self): return "KMDBTC" -KMDBTC = KMDBTC() +KMDBUSD = KMDBUSD() @dataclass(slots=True, frozen=True) class KMDBUSD: + """ + name: KMDBUSD + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 900000.00000000 + margin: False + """ name: str = "KMDBUSD" precision: int = 8 minimum_margin: float = None @@ -25022,11 +34819,20 @@ def __call__(self): return "KMDBUSD" -KMDBUSD = KMDBUSD() +KMDETH = KMDETH() @dataclass(slots=True, frozen=True) class KMDETH: + """ + name: KMDETH + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 92141578.00000000 + margin: False + """ name: str = "KMDETH" precision: int = 8 minimum_margin: float = None @@ -25045,11 +34851,20 @@ def __call__(self): return "KMDETH" -KMDETH = KMDETH() +KMDUSDT = KMDUSDT() @dataclass(slots=True, frozen=True) class KMDUSDT: + """ + name: KMDUSDT + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 900000.00000000 + margin: True + """ name: str = "KMDUSDT" precision: int = 8 minimum_margin: float = None @@ -25068,11 +34883,20 @@ def __call__(self): return "KMDUSDT" -KMDUSDT = KMDUSDT() +KNCBNB = KNCBNB() @dataclass(slots=True, frozen=True) class KNCBNB: + """ + name: KNCBNB + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 92141578.00000000 + margin: False + """ name: str = "KNCBNB" precision: int = 8 minimum_margin: float = None @@ -25091,11 +34915,20 @@ def __call__(self): return "KNCBNB" -KNCBNB = KNCBNB() +KNCBTC = KNCBTC() @dataclass(slots=True, frozen=True) class KNCBTC: + """ + name: KNCBTC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 90000000.00000000 + margin: True + """ name: str = "KNCBTC" precision: int = 8 minimum_margin: float = None @@ -25114,11 +34947,20 @@ def __call__(self): return "KNCBTC" -KNCBTC = KNCBTC() +KNCBUSD = KNCBUSD() @dataclass(slots=True, frozen=True) class KNCBUSD: + """ + name: KNCBUSD + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 9222449.00000000 + margin: True + """ name: str = "KNCBUSD" precision: int = 8 minimum_margin: float = None @@ -25137,11 +34979,20 @@ def __call__(self): return "KNCBUSD" -KNCBUSD = KNCBUSD() +KNCETH = KNCETH() @dataclass(slots=True, frozen=True) class KNCETH: + """ + name: KNCETH + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 90000000.00000000 + margin: False + """ name: str = "KNCETH" precision: int = 8 minimum_margin: float = None @@ -25160,11 +35011,20 @@ def __call__(self): return "KNCETH" -KNCETH = KNCETH() +KNCUSDT = KNCUSDT() @dataclass(slots=True, frozen=True) class KNCUSDT: + """ + name: KNCUSDT + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 9222449.00000000 + margin: True + """ name: str = "KNCUSDT" precision: int = 8 minimum_margin: float = None @@ -25183,11 +35043,20 @@ def __call__(self): return "KNCUSDT" -KNCUSDT = KNCUSDT() +KP3RBNB = KP3RBNB() @dataclass(slots=True, frozen=True) class KP3RBNB: + """ + name: KP3RBNB + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 900000.00000000 + margin: False + """ name: str = "KP3RBNB" precision: int = 8 minimum_margin: float = None @@ -25206,11 +35075,20 @@ def __call__(self): return "KP3RBNB" -KP3RBNB = KP3RBNB() +KP3RBUSD = KP3RBUSD() @dataclass(slots=True, frozen=True) class KP3RBUSD: + """ + name: KP3RBUSD + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 90000.00000000 + margin: True + """ name: str = "KP3RBUSD" precision: int = 8 minimum_margin: float = None @@ -25229,11 +35107,20 @@ def __call__(self): return "KP3RBUSD" -KP3RBUSD = KP3RBUSD() +KP3RUSDT = KP3RUSDT() @dataclass(slots=True, frozen=True) class KP3RUSDT: + """ + name: KP3RUSDT + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 92230.00000000 + margin: True + """ name: str = "KP3RUSDT" precision: int = 8 minimum_margin: float = None @@ -25252,11 +35139,20 @@ def __call__(self): return "KP3RUSDT" -KP3RUSDT = KP3RUSDT() +KSMAUD = KSMAUD() @dataclass(slots=True, frozen=True) class KSMAUD: + """ + name: KSMAUD + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.00100000 + maximum_order_size: 922327.00000000 + margin: False + """ name: str = "KSMAUD" precision: int = 8 minimum_margin: float = None @@ -25275,11 +35171,20 @@ def __call__(self): return "KSMAUD" -KSMAUD = KSMAUD() +KSMBNB = KSMBNB() @dataclass(slots=True, frozen=True) class KSMBNB: + """ + name: KSMBNB + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.00100000 + maximum_order_size: 900000.00000000 + margin: False + """ name: str = "KSMBNB" precision: int = 8 minimum_margin: float = None @@ -25298,11 +35203,20 @@ def __call__(self): return "KSMBNB" -KSMBNB = KSMBNB() +KSMBTC = KSMBTC() @dataclass(slots=True, frozen=True) class KSMBTC: + """ + name: KSMBTC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.00100000 + maximum_order_size: 10000000.00000000 + margin: True + """ name: str = "KSMBTC" precision: int = 8 minimum_margin: float = None @@ -25321,11 +35235,20 @@ def __call__(self): return "KSMBTC" -KSMBTC = KSMBTC() +KSMBUSD = KSMBUSD() @dataclass(slots=True, frozen=True) class KSMBUSD: + """ + name: KSMBUSD + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.00100000 + maximum_order_size: 900000.00000000 + margin: True + """ name: str = "KSMBUSD" precision: int = 8 minimum_margin: float = None @@ -25344,11 +35267,20 @@ def __call__(self): return "KSMBUSD" -KSMBUSD = KSMBUSD() +KSMETH = KSMETH() @dataclass(slots=True, frozen=True) class KSMETH: + """ + name: KSMETH + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.00010000 + maximum_order_size: 92141578.00000000 + margin: False + """ name: str = "KSMETH" precision: int = 8 minimum_margin: float = None @@ -25367,11 +35299,20 @@ def __call__(self): return "KSMETH" -KSMETH = KSMETH() +KSMUSDT = KSMUSDT() @dataclass(slots=True, frozen=True) class KSMUSDT: + """ + name: KSMUSDT + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.00100000 + maximum_order_size: 900000.00000000 + margin: True + """ name: str = "KSMUSDT" precision: int = 8 minimum_margin: float = None @@ -25390,11 +35331,20 @@ def __call__(self): return "KSMUSDT" -KSMUSDT = KSMUSDT() +LAZIOBTC = LAZIOBTC() @dataclass(slots=True, frozen=True) class LAZIOBTC: + """ + name: LAZIOBTC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 92141578.00000000 + margin: False + """ name: str = "LAZIOBTC" precision: int = 8 minimum_margin: float = None @@ -25413,11 +35363,20 @@ def __call__(self): return "LAZIOBTC" -LAZIOBTC = LAZIOBTC() +LAZIOBUSD = LAZIOBUSD() @dataclass(slots=True, frozen=True) class LAZIOBUSD: + """ + name: LAZIOBUSD + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 922327.00000000 + margin: True + """ name: str = "LAZIOBUSD" precision: int = 8 minimum_margin: float = None @@ -25436,11 +35395,20 @@ def __call__(self): return "LAZIOBUSD" -LAZIOBUSD = LAZIOBUSD() +LAZIOEUR = LAZIOEUR() @dataclass(slots=True, frozen=True) class LAZIOEUR: + """ + name: LAZIOEUR + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 92141578.00000000 + margin: False + """ name: str = "LAZIOEUR" precision: int = 8 minimum_margin: float = None @@ -25459,11 +35427,20 @@ def __call__(self): return "LAZIOEUR" -LAZIOEUR = LAZIOEUR() +LAZIOTRY = LAZIOTRY() @dataclass(slots=True, frozen=True) class LAZIOTRY: + """ + name: LAZIOTRY + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 92141578.00000000 + margin: False + """ name: str = "LAZIOTRY" precision: int = 8 minimum_margin: float = None @@ -25482,11 +35459,20 @@ def __call__(self): return "LAZIOTRY" -LAZIOTRY = LAZIOTRY() +LAZIOUSDT = LAZIOUSDT() @dataclass(slots=True, frozen=True) class LAZIOUSDT: + """ + name: LAZIOUSDT + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 92141578.00000000 + margin: True + """ name: str = "LAZIOUSDT" precision: int = 8 minimum_margin: float = None @@ -25505,11 +35491,20 @@ def __call__(self): return "LAZIOUSDT" -LAZIOUSDT = LAZIOUSDT() +LDOBTC = LDOBTC() @dataclass(slots=True, frozen=True) class LDOBTC: + """ + name: LDOBTC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 92141578.00000000 + margin: False + """ name: str = "LDOBTC" precision: int = 8 minimum_margin: float = None @@ -25528,11 +35523,20 @@ def __call__(self): return "LDOBTC" -LDOBTC = LDOBTC() +LDOBUSD = LDOBUSD() @dataclass(slots=True, frozen=True) class LDOBUSD: + """ + name: LDOBUSD + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 92141578.00000000 + margin: True + """ name: str = "LDOBUSD" precision: int = 8 minimum_margin: float = None @@ -25551,11 +35555,20 @@ def __call__(self): return "LDOBUSD" -LDOBUSD = LDOBUSD() +LDOUSDT = LDOUSDT() @dataclass(slots=True, frozen=True) class LDOUSDT: + """ + name: LDOUSDT + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 92141578.00000000 + margin: True + """ name: str = "LDOUSDT" precision: int = 8 minimum_margin: float = None @@ -25574,11 +35587,20 @@ def __call__(self): return "LDOUSDT" -LDOUSDT = LDOUSDT() +LENDBKRW = LENDBKRW() @dataclass(slots=True, frozen=True) class LENDBKRW: + """ + name: LENDBKRW + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 92232.00000000 + margin: False + """ name: str = "LENDBKRW" precision: int = 8 minimum_margin: float = None @@ -25597,11 +35619,20 @@ def __call__(self): return "LENDBKRW" -LENDBKRW = LENDBKRW() +LENDBTC = LENDBTC() @dataclass(slots=True, frozen=True) class LENDBTC: + """ + name: LENDBTC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 90000000.00000000 + margin: False + """ name: str = "LENDBTC" precision: int = 8 minimum_margin: float = None @@ -25620,11 +35651,20 @@ def __call__(self): return "LENDBTC" -LENDBTC = LENDBTC() +LENDBUSD = LENDBUSD() @dataclass(slots=True, frozen=True) class LENDBUSD: + """ + name: LENDBUSD + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 900000.00000000 + margin: False + """ name: str = "LENDBUSD" precision: int = 8 minimum_margin: float = None @@ -25643,11 +35683,20 @@ def __call__(self): return "LENDBUSD" -LENDBUSD = LENDBUSD() +LENDETH = LENDETH() @dataclass(slots=True, frozen=True) class LENDETH: + """ + name: LENDETH + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 90000000.00000000 + margin: False + """ name: str = "LENDETH" precision: int = 8 minimum_margin: float = None @@ -25666,11 +35715,20 @@ def __call__(self): return "LENDETH" -LENDETH = LENDETH() +LENDUSDT = LENDUSDT() @dataclass(slots=True, frozen=True) class LENDUSDT: + """ + name: LENDUSDT + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 9000000.00000000 + margin: False + """ name: str = "LENDUSDT" precision: int = 8 minimum_margin: float = None @@ -25689,11 +35747,20 @@ def __call__(self): return "LENDUSDT" -LENDUSDT = LENDUSDT() +LEVERBUSD = LEVERBUSD() @dataclass(slots=True, frozen=True) class LEVERBUSD: + """ + name: LEVERBUSD + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 913205152.00000000 + margin: True + """ name: str = "LEVERBUSD" precision: int = 8 minimum_margin: float = None @@ -25712,11 +35779,20 @@ def __call__(self): return "LEVERBUSD" -LEVERBUSD = LEVERBUSD() +LEVERUSDT = LEVERUSDT() @dataclass(slots=True, frozen=True) class LEVERUSDT: + """ + name: LEVERUSDT + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 913205152.00000000 + margin: True + """ name: str = "LEVERUSDT" precision: int = 8 minimum_margin: float = None @@ -25735,11 +35811,20 @@ def __call__(self): return "LEVERUSDT" -LEVERUSDT = LEVERUSDT() +LINABNB = LINABNB() @dataclass(slots=True, frozen=True) class LINABNB: + """ + name: LINABNB + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 92141578.00000000 + margin: False + """ name: str = "LINABNB" precision: int = 8 minimum_margin: float = None @@ -25758,11 +35843,20 @@ def __call__(self): return "LINABNB" -LINABNB = LINABNB() +LINABTC = LINABTC() @dataclass(slots=True, frozen=True) class LINABTC: + """ + name: LINABTC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 90000000.00000000 + margin: True + """ name: str = "LINABTC" precision: int = 8 minimum_margin: float = None @@ -25781,11 +35875,20 @@ def __call__(self): return "LINABTC" -LINABTC = LINABTC() +LINABUSD = LINABUSD() @dataclass(slots=True, frozen=True) class LINABUSD: + """ + name: LINABUSD + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 9222449.00000000 + margin: True + """ name: str = "LINABUSD" precision: int = 8 minimum_margin: float = None @@ -25804,11 +35907,20 @@ def __call__(self): return "LINABUSD" -LINABUSD = LINABUSD() +LINAUSDT = LINAUSDT() @dataclass(slots=True, frozen=True) class LINAUSDT: + """ + name: LINAUSDT + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 9222449.00000000 + margin: True + """ name: str = "LINAUSDT" precision: int = 8 minimum_margin: float = None @@ -25827,11 +35939,20 @@ def __call__(self): return "LINAUSDT" -LINAUSDT = LINAUSDT() +LINKAUD = LINKAUD() @dataclass(slots=True, frozen=True) class LINKAUD: + """ + name: LINKAUD + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 90000.00000000 + margin: False + """ name: str = "LINKAUD" precision: int = 8 minimum_margin: float = None @@ -25850,11 +35971,20 @@ def __call__(self): return "LINKAUD" -LINKAUD = LINKAUD() +LINKBKRW = LINKBKRW() @dataclass(slots=True, frozen=True) class LINKBKRW: + """ + name: LINKBKRW + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 9200.00000000 + margin: False + """ name: str = "LINKBKRW" precision: int = 8 minimum_margin: float = None @@ -25873,11 +36003,20 @@ def __call__(self): return "LINKBKRW" -LINKBKRW = LINKBKRW() +LINKBNB = LINKBNB() @dataclass(slots=True, frozen=True) class LINKBNB: + """ + name: LINKBNB + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.00100000 + maximum_order_size: 92141578.00000000 + margin: False + """ name: str = "LINKBNB" precision: int = 8 minimum_margin: float = None @@ -25896,11 +36035,20 @@ def __call__(self): return "LINKBNB" -LINKBNB = LINKBNB() +LINKBRL = LINKBRL() @dataclass(slots=True, frozen=True) class LINKBRL: + """ + name: LINKBRL + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 45000.00000000 + margin: False + """ name: str = "LINKBRL" precision: int = 8 minimum_margin: float = None @@ -25919,11 +36067,20 @@ def __call__(self): return "LINKBRL" -LINKBRL = LINKBRL() +LINKBTC = LINKBTC() @dataclass(slots=True, frozen=True) class LINKBTC: + """ + name: LINKBTC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 90000000.00000000 + margin: True + """ name: str = "LINKBTC" precision: int = 8 minimum_margin: float = None @@ -25942,11 +36099,20 @@ def __call__(self): return "LINKBTC" -LINKBTC = LINKBTC() +LINKBUSD = LINKBUSD() @dataclass(slots=True, frozen=True) class LINKBUSD: + """ + name: LINKBUSD + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 90000.00000000 + margin: True + """ name: str = "LINKBUSD" precision: int = 8 minimum_margin: float = None @@ -25965,11 +36131,20 @@ def __call__(self): return "LINKBUSD" -LINKBUSD = LINKBUSD() +LINKDOWNUSDT = LINKDOWNUSDT() @dataclass(slots=True, frozen=True) class LINKDOWNUSDT: + """ + name: LINKDOWNUSDT + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 300000.00000000 + margin: False + """ name: str = "LINKDOWNUSDT" precision: int = 8 minimum_margin: float = None @@ -25988,11 +36163,20 @@ def __call__(self): return "LINKDOWNUSDT" -LINKDOWNUSDT = LINKDOWNUSDT() +LINKETH = LINKETH() @dataclass(slots=True, frozen=True) class LINKETH: + """ + name: LINKETH + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 92141578.00000000 + margin: True + """ name: str = "LINKETH" precision: int = 8 minimum_margin: float = None @@ -26011,11 +36195,20 @@ def __call__(self): return "LINKETH" -LINKETH = LINKETH() +LINKEUR = LINKEUR() @dataclass(slots=True, frozen=True) class LINKEUR: + """ + name: LINKEUR + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 90000.00000000 + margin: False + """ name: str = "LINKEUR" precision: int = 8 minimum_margin: float = None @@ -26034,11 +36227,20 @@ def __call__(self): return "LINKEUR" -LINKEUR = LINKEUR() +LINKGBP = LINKGBP() @dataclass(slots=True, frozen=True) class LINKGBP: + """ + name: LINKGBP + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 90000.00000000 + margin: False + """ name: str = "LINKGBP" precision: int = 8 minimum_margin: float = None @@ -26057,11 +36259,20 @@ def __call__(self): return "LINKGBP" -LINKGBP = LINKGBP() +LINKNGN = LINKNGN() @dataclass(slots=True, frozen=True) class LINKNGN: + """ + name: LINKNGN + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.00001000 + maximum_order_size: 92232.00000000 + margin: False + """ name: str = "LINKNGN" precision: int = 8 minimum_margin: float = None @@ -26080,11 +36291,20 @@ def __call__(self): return "LINKNGN" -LINKNGN = LINKNGN() +LINKPAX = LINKPAX() @dataclass(slots=True, frozen=True) class LINKPAX: + """ + name: LINKPAX + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 900000.00000000 + margin: False + """ name: str = "LINKPAX" precision: int = 8 minimum_margin: float = None @@ -26103,11 +36323,20 @@ def __call__(self): return "LINKPAX" -LINKPAX = LINKPAX() +LINKTRY = LINKTRY() @dataclass(slots=True, frozen=True) class LINKTRY: + """ + name: LINKTRY + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 922327.00000000 + margin: False + """ name: str = "LINKTRY" precision: int = 8 minimum_margin: float = None @@ -26126,11 +36355,20 @@ def __call__(self): return "LINKTRY" -LINKTRY = LINKTRY() +LINKTUSD = LINKTUSD() @dataclass(slots=True, frozen=True) class LINKTUSD: + """ + name: LINKTUSD + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 90000.00000000 + margin: False + """ name: str = "LINKTUSD" precision: int = 8 minimum_margin: float = None @@ -26149,11 +36387,20 @@ def __call__(self): return "LINKTUSD" -LINKTUSD = LINKTUSD() +LINKUPUSDT = LINKUPUSDT() @dataclass(slots=True, frozen=True) class LINKUPUSDT: + """ + name: LINKUPUSDT + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 920000.00000000 + margin: False + """ name: str = "LINKUPUSDT" precision: int = 8 minimum_margin: float = None @@ -26172,11 +36419,20 @@ def __call__(self): return "LINKUPUSDT" -LINKUPUSDT = LINKUPUSDT() +LINKUSDC = LINKUSDC() @dataclass(slots=True, frozen=True) class LINKUSDC: + """ + name: LINKUSDC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 90000.00000000 + margin: False + """ name: str = "LINKUSDC" precision: int = 8 minimum_margin: float = None @@ -26195,11 +36451,20 @@ def __call__(self): return "LINKUSDC" -LINKUSDC = LINKUSDC() +LINKUSDT = LINKUSDT() @dataclass(slots=True, frozen=True) class LINKUSDT: + """ + name: LINKUSDT + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 90000.00000000 + margin: True + """ name: str = "LINKUSDT" precision: int = 8 minimum_margin: float = None @@ -26218,11 +36483,20 @@ def __call__(self): return "LINKUSDT" -LINKUSDT = LINKUSDT() +LITBTC = LITBTC() @dataclass(slots=True, frozen=True) class LITBTC: + """ + name: LITBTC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 90000000.00000000 + margin: True + """ name: str = "LITBTC" precision: int = 8 minimum_margin: float = None @@ -26241,11 +36515,20 @@ def __call__(self): return "LITBTC" -LITBTC = LITBTC() +LITBUSD = LITBUSD() @dataclass(slots=True, frozen=True) class LITBUSD: + """ + name: LITBUSD + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 900000.00000000 + margin: True + """ name: str = "LITBUSD" precision: int = 8 minimum_margin: float = None @@ -26264,11 +36547,20 @@ def __call__(self): return "LITBUSD" -LITBUSD = LITBUSD() +LITETH = LITETH() @dataclass(slots=True, frozen=True) class LITETH: + """ + name: LITETH + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 92141578.00000000 + margin: False + """ name: str = "LITETH" precision: int = 8 minimum_margin: float = None @@ -26287,11 +36579,20 @@ def __call__(self): return "LITETH" -LITETH = LITETH() +LITUSDT = LITUSDT() @dataclass(slots=True, frozen=True) class LITUSDT: + """ + name: LITUSDT + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 900000.00000000 + margin: True + """ name: str = "LITUSDT" precision: int = 8 minimum_margin: float = None @@ -26310,11 +36611,20 @@ def __call__(self): return "LITUSDT" -LITUSDT = LITUSDT() +LOKABNB = LOKABNB() @dataclass(slots=True, frozen=True) class LOKABNB: + """ + name: LOKABNB + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 92141578.00000000 + margin: False + """ name: str = "LOKABNB" precision: int = 8 minimum_margin: float = None @@ -26333,11 +36643,20 @@ def __call__(self): return "LOKABNB" -LOKABNB = LOKABNB() +LOKABTC = LOKABTC() @dataclass(slots=True, frozen=True) class LOKABTC: + """ + name: LOKABTC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 92141578.00000000 + margin: False + """ name: str = "LOKABTC" precision: int = 8 minimum_margin: float = None @@ -26356,11 +36675,20 @@ def __call__(self): return "LOKABTC" -LOKABTC = LOKABTC() +LOKABUSD = LOKABUSD() @dataclass(slots=True, frozen=True) class LOKABUSD: + """ + name: LOKABUSD + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 92141578.00000000 + margin: False + """ name: str = "LOKABUSD" precision: int = 8 minimum_margin: float = None @@ -26379,11 +36707,20 @@ def __call__(self): return "LOKABUSD" -LOKABUSD = LOKABUSD() +LOKAUSDT = LOKAUSDT() @dataclass(slots=True, frozen=True) class LOKAUSDT: + """ + name: LOKAUSDT + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 92141578.00000000 + margin: False + """ name: str = "LOKAUSDT" precision: int = 8 minimum_margin: float = None @@ -26402,11 +36739,20 @@ def __call__(self): return "LOKAUSDT" -LOKAUSDT = LOKAUSDT() +LOOMBNB = LOOMBNB() @dataclass(slots=True, frozen=True) class LOOMBNB: + """ + name: LOOMBNB + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 9000000.00000000 + margin: False + """ name: str = "LOOMBNB" precision: int = 8 minimum_margin: float = None @@ -26425,11 +36771,20 @@ def __call__(self): return "LOOMBNB" -LOOMBNB = LOOMBNB() +LOOMBTC = LOOMBTC() @dataclass(slots=True, frozen=True) class LOOMBTC: + """ + name: LOOMBTC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 90000000.00000000 + margin: False + """ name: str = "LOOMBTC" precision: int = 8 minimum_margin: float = None @@ -26448,11 +36803,20 @@ def __call__(self): return "LOOMBTC" -LOOMBTC = LOOMBTC() +LOOMBUSD = LOOMBUSD() @dataclass(slots=True, frozen=True) class LOOMBUSD: + """ + name: LOOMBUSD + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 92141578.00000000 + margin: True + """ name: str = "LOOMBUSD" precision: int = 8 minimum_margin: float = None @@ -26471,11 +36835,20 @@ def __call__(self): return "LOOMBUSD" -LOOMBUSD = LOOMBUSD() +LOOMETH = LOOMETH() @dataclass(slots=True, frozen=True) class LOOMETH: + """ + name: LOOMETH + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 90000000.00000000 + margin: False + """ name: str = "LOOMETH" precision: int = 8 minimum_margin: float = None @@ -26494,11 +36867,20 @@ def __call__(self): return "LOOMETH" -LOOMETH = LOOMETH() +LPTBNB = LPTBNB() @dataclass(slots=True, frozen=True) class LPTBNB: + """ + name: LPTBNB + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 92141570.00000000 + margin: False + """ name: str = "LPTBNB" precision: int = 8 minimum_margin: float = None @@ -26517,11 +36899,20 @@ def __call__(self): return "LPTBNB" -LPTBNB = LPTBNB() +LPTBTC = LPTBTC() @dataclass(slots=True, frozen=True) class LPTBTC: + """ + name: LPTBTC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 92141570.00000000 + margin: True + """ name: str = "LPTBTC" precision: int = 8 minimum_margin: float = None @@ -26540,11 +36931,20 @@ def __call__(self): return "LPTBTC" -LPTBTC = LPTBTC() +LPTBUSD = LPTBUSD() @dataclass(slots=True, frozen=True) class LPTBUSD: + """ + name: LPTBUSD + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 9222440.00000000 + margin: True + """ name: str = "LPTBUSD" precision: int = 8 minimum_margin: float = None @@ -26563,11 +36963,20 @@ def __call__(self): return "LPTBUSD" -LPTBUSD = LPTBUSD() +LPTUSDT = LPTUSDT() @dataclass(slots=True, frozen=True) class LPTUSDT: + """ + name: LPTUSDT + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 9222440.00000000 + margin: True + """ name: str = "LPTUSDT" precision: int = 8 minimum_margin: float = None @@ -26586,11 +36995,20 @@ def __call__(self): return "LPTUSDT" -LPTUSDT = LPTUSDT() +LRCBNB = LRCBNB() @dataclass(slots=True, frozen=True) class LRCBNB: + """ + name: LRCBNB + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 92141578.00000000 + margin: False + """ name: str = "LRCBNB" precision: int = 8 minimum_margin: float = None @@ -26609,11 +37027,20 @@ def __call__(self): return "LRCBNB" -LRCBNB = LRCBNB() +LRCBTC = LRCBTC() @dataclass(slots=True, frozen=True) class LRCBTC: + """ + name: LRCBTC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 90000000.00000000 + margin: True + """ name: str = "LRCBTC" precision: int = 8 minimum_margin: float = None @@ -26632,11 +37059,20 @@ def __call__(self): return "LRCBTC" -LRCBTC = LRCBTC() +LRCBUSD = LRCBUSD() @dataclass(slots=True, frozen=True) class LRCBUSD: + """ + name: LRCBUSD + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 9000000.00000000 + margin: True + """ name: str = "LRCBUSD" precision: int = 8 minimum_margin: float = None @@ -26655,11 +37091,20 @@ def __call__(self): return "LRCBUSD" -LRCBUSD = LRCBUSD() +LRCETH = LRCETH() @dataclass(slots=True, frozen=True) class LRCETH: + """ + name: LRCETH + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 90000000.00000000 + margin: False + """ name: str = "LRCETH" precision: int = 8 minimum_margin: float = None @@ -26678,11 +37123,20 @@ def __call__(self): return "LRCETH" -LRCETH = LRCETH() +LRCTRY = LRCTRY() @dataclass(slots=True, frozen=True) class LRCTRY: + """ + name: LRCTRY + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 9222449.00000000 + margin: False + """ name: str = "LRCTRY" precision: int = 8 minimum_margin: float = None @@ -26701,11 +37155,20 @@ def __call__(self): return "LRCTRY" -LRCTRY = LRCTRY() +LRCUSDT = LRCUSDT() @dataclass(slots=True, frozen=True) class LRCUSDT: + """ + name: LRCUSDT + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 9000000.00000000 + margin: True + """ name: str = "LRCUSDT" precision: int = 8 minimum_margin: float = None @@ -26724,11 +37187,20 @@ def __call__(self): return "LRCUSDT" -LRCUSDT = LRCUSDT() +LSKBNB = LSKBNB() @dataclass(slots=True, frozen=True) class LSKBNB: + """ + name: LSKBNB + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 9000000.00000000 + margin: False + """ name: str = "LSKBNB" precision: int = 8 minimum_margin: float = None @@ -26747,11 +37219,20 @@ def __call__(self): return "LSKBNB" -LSKBNB = LSKBNB() +LSKBTC = LSKBTC() @dataclass(slots=True, frozen=True) class LSKBTC: + """ + name: LSKBTC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 90000000.00000000 + margin: False + """ name: str = "LSKBTC" precision: int = 8 minimum_margin: float = None @@ -26770,11 +37251,20 @@ def __call__(self): return "LSKBTC" -LSKBTC = LSKBTC() +LSKBUSD = LSKBUSD() @dataclass(slots=True, frozen=True) class LSKBUSD: + """ + name: LSKBUSD + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 92141578.00000000 + margin: False + """ name: str = "LSKBUSD" precision: int = 8 minimum_margin: float = None @@ -26793,11 +37283,20 @@ def __call__(self): return "LSKBUSD" -LSKBUSD = LSKBUSD() +LSKETH = LSKETH() @dataclass(slots=True, frozen=True) class LSKETH: + """ + name: LSKETH + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 92141578.00000000 + margin: False + """ name: str = "LSKETH" precision: int = 8 minimum_margin: float = None @@ -26816,11 +37315,20 @@ def __call__(self): return "LSKETH" -LSKETH = LSKETH() +LSKUSDT = LSKUSDT() @dataclass(slots=True, frozen=True) class LSKUSDT: + """ + name: LSKUSDT + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 900000.00000000 + margin: False + """ name: str = "LSKUSDT" precision: int = 8 minimum_margin: float = None @@ -26839,11 +37347,20 @@ def __call__(self): return "LSKUSDT" -LSKUSDT = LSKUSDT() +LTCBNB = LTCBNB() @dataclass(slots=True, frozen=True) class LTCBNB: + """ + name: LTCBNB + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.00100000 + maximum_order_size: 900000.00000000 + margin: False + """ name: str = "LTCBNB" precision: int = 8 minimum_margin: float = None @@ -26862,11 +37379,20 @@ def __call__(self): return "LTCBNB" -LTCBNB = LTCBNB() +LTCBRL = LTCBRL() @dataclass(slots=True, frozen=True) class LTCBRL: + """ + name: LTCBRL + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.00100000 + maximum_order_size: 45000.00000000 + margin: False + """ name: str = "LTCBRL" precision: int = 8 minimum_margin: float = None @@ -26885,11 +37411,20 @@ def __call__(self): return "LTCBRL" -LTCBRL = LTCBRL() +LTCBTC = LTCBTC() @dataclass(slots=True, frozen=True) class LTCBTC: + """ + name: LTCBTC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.00100000 + maximum_order_size: 100000.00000000 + margin: True + """ name: str = "LTCBTC" precision: int = 8 minimum_margin: float = None @@ -26908,11 +37443,20 @@ def __call__(self): return "LTCBTC" -LTCBTC = LTCBTC() +LTCBUSD = LTCBUSD() @dataclass(slots=True, frozen=True) class LTCBUSD: + """ + name: LTCBUSD + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.00100000 + maximum_order_size: 90000.00000000 + margin: True + """ name: str = "LTCBUSD" precision: int = 8 minimum_margin: float = None @@ -26931,11 +37475,20 @@ def __call__(self): return "LTCBUSD" -LTCBUSD = LTCBUSD() +LTCDOWNUSDT = LTCDOWNUSDT() @dataclass(slots=True, frozen=True) class LTCDOWNUSDT: + """ + name: LTCDOWNUSDT + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 610819340.00000000 + margin: False + """ name: str = "LTCDOWNUSDT" precision: int = 8 minimum_margin: float = None @@ -26954,11 +37507,20 @@ def __call__(self): return "LTCDOWNUSDT" -LTCDOWNUSDT = LTCDOWNUSDT() +LTCETH = LTCETH() @dataclass(slots=True, frozen=True) class LTCETH: + """ + name: LTCETH + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.00100000 + maximum_order_size: 9000000.00000000 + margin: True + """ name: str = "LTCETH" precision: int = 8 minimum_margin: float = None @@ -26977,11 +37539,20 @@ def __call__(self): return "LTCETH" -LTCETH = LTCETH() +LTCEUR = LTCEUR() @dataclass(slots=True, frozen=True) class LTCEUR: + """ + name: LTCEUR + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.00100000 + maximum_order_size: 900000.00000000 + margin: False + """ name: str = "LTCEUR" precision: int = 8 minimum_margin: float = None @@ -27000,11 +37571,20 @@ def __call__(self): return "LTCEUR" -LTCEUR = LTCEUR() +LTCGBP = LTCGBP() @dataclass(slots=True, frozen=True) class LTCGBP: + """ + name: LTCGBP + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.00100000 + maximum_order_size: 90000.00000000 + margin: False + """ name: str = "LTCGBP" precision: int = 8 minimum_margin: float = None @@ -27023,11 +37603,20 @@ def __call__(self): return "LTCGBP" -LTCGBP = LTCGBP() +LTCNGN = LTCNGN() @dataclass(slots=True, frozen=True) class LTCNGN: + """ + name: LTCNGN + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.00001000 + maximum_order_size: 9221.00000000 + margin: False + """ name: str = "LTCNGN" precision: int = 8 minimum_margin: float = None @@ -27046,11 +37635,20 @@ def __call__(self): return "LTCNGN" -LTCNGN = LTCNGN() +LTCPAX = LTCPAX() @dataclass(slots=True, frozen=True) class LTCPAX: + """ + name: LTCPAX + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.00001000 + maximum_order_size: 90000.00000000 + margin: False + """ name: str = "LTCPAX" precision: int = 8 minimum_margin: float = None @@ -27069,11 +37667,20 @@ def __call__(self): return "LTCPAX" -LTCPAX = LTCPAX() +LTCRUB = LTCRUB() @dataclass(slots=True, frozen=True) class LTCRUB: + """ + name: LTCRUB + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.00100000 + maximum_order_size: 90000.00000000 + margin: False + """ name: str = "LTCRUB" precision: int = 8 minimum_margin: float = None @@ -27092,11 +37699,20 @@ def __call__(self): return "LTCRUB" -LTCRUB = LTCRUB() +LTCTUSD = LTCTUSD() @dataclass(slots=True, frozen=True) class LTCTUSD: + """ + name: LTCTUSD + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.00100000 + maximum_order_size: 90000.00000000 + margin: False + """ name: str = "LTCTUSD" precision: int = 8 minimum_margin: float = None @@ -27115,11 +37731,20 @@ def __call__(self): return "LTCTUSD" -LTCTUSD = LTCTUSD() +LTCUAH = LTCUAH() @dataclass(slots=True, frozen=True) class LTCUAH: + """ + name: LTCUAH + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.00100000 + maximum_order_size: 92233.00000000 + margin: False + """ name: str = "LTCUAH" precision: int = 8 minimum_margin: float = None @@ -27138,11 +37763,20 @@ def __call__(self): return "LTCUAH" -LTCUAH = LTCUAH() +LTCUPUSDT = LTCUPUSDT() @dataclass(slots=True, frozen=True) class LTCUPUSDT: + """ + name: LTCUPUSDT + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 920000.00000000 + margin: False + """ name: str = "LTCUPUSDT" precision: int = 8 minimum_margin: float = None @@ -27161,11 +37795,20 @@ def __call__(self): return "LTCUPUSDT" -LTCUPUSDT = LTCUPUSDT() +LTCUSDC = LTCUSDC() @dataclass(slots=True, frozen=True) class LTCUSDC: + """ + name: LTCUSDC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.00100000 + maximum_order_size: 90000.00000000 + margin: False + """ name: str = "LTCUSDC" precision: int = 8 minimum_margin: float = None @@ -27184,11 +37827,20 @@ def __call__(self): return "LTCUSDC" -LTCUSDC = LTCUSDC() +LTCUSDT = LTCUSDT() @dataclass(slots=True, frozen=True) class LTCUSDT: + """ + name: LTCUSDT + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.00100000 + maximum_order_size: 90000.00000000 + margin: True + """ name: str = "LTCUSDT" precision: int = 8 minimum_margin: float = None @@ -27207,11 +37859,20 @@ def __call__(self): return "LTCUSDT" -LTCUSDT = LTCUSDT() +LTOBNB = LTOBNB() @dataclass(slots=True, frozen=True) class LTOBNB: + """ + name: LTOBNB + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 9000000.00000000 + margin: False + """ name: str = "LTOBNB" precision: int = 8 minimum_margin: float = None @@ -27230,11 +37891,20 @@ def __call__(self): return "LTOBNB" -LTOBNB = LTOBNB() +LTOBTC = LTOBTC() @dataclass(slots=True, frozen=True) class LTOBTC: + """ + name: LTOBTC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 90000000.00000000 + margin: True + """ name: str = "LTOBTC" precision: int = 8 minimum_margin: float = None @@ -27253,11 +37923,20 @@ def __call__(self): return "LTOBTC" -LTOBTC = LTOBTC() +LTOBUSD = LTOBUSD() @dataclass(slots=True, frozen=True) class LTOBUSD: + """ + name: LTOBUSD + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 92141578.00000000 + margin: False + """ name: str = "LTOBUSD" precision: int = 8 minimum_margin: float = None @@ -27276,11 +37955,20 @@ def __call__(self): return "LTOBUSD" -LTOBUSD = LTOBUSD() +LTOUSDT = LTOUSDT() @dataclass(slots=True, frozen=True) class LTOUSDT: + """ + name: LTOUSDT + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 9000000.00000000 + margin: True + """ name: str = "LTOUSDT" precision: int = 8 minimum_margin: float = None @@ -27299,11 +37987,20 @@ def __call__(self): return "LTOUSDT" -LTOUSDT = LTOUSDT() +LUNAAUD = LUNAAUD() @dataclass(slots=True, frozen=True) class LUNAAUD: + """ + name: LUNAAUD + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 9222449.00000000 + margin: False + """ name: str = "LUNAAUD" precision: int = 8 minimum_margin: float = None @@ -27322,11 +38019,20 @@ def __call__(self): return "LUNAAUD" -LUNAAUD = LUNAAUD() +LUNABIDR = LUNABIDR() @dataclass(slots=True, frozen=True) class LUNABIDR: + """ + name: LUNABIDR + precision: 2 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 922337194.00000000 + margin: False + """ name: str = "LUNABIDR" precision: int = 2 minimum_margin: float = None @@ -27345,11 +38051,20 @@ def __call__(self): return "LUNABIDR" -LUNABIDR = LUNABIDR() +LUNABNB = LUNABNB() @dataclass(slots=True, frozen=True) class LUNABNB: + """ + name: LUNABNB + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 9000000.00000000 + margin: False + """ name: str = "LUNABNB" precision: int = 8 minimum_margin: float = None @@ -27368,11 +38083,20 @@ def __call__(self): return "LUNABNB" -LUNABNB = LUNABNB() +LUNABRL = LUNABRL() @dataclass(slots=True, frozen=True) class LUNABRL: + """ + name: LUNABRL + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.00100000 + maximum_order_size: 9221525.00000000 + margin: False + """ name: str = "LUNABRL" precision: int = 8 minimum_margin: float = None @@ -27391,11 +38115,20 @@ def __call__(self): return "LUNABRL" -LUNABRL = LUNABRL() +LUNABTC = LUNABTC() @dataclass(slots=True, frozen=True) class LUNABTC: + """ + name: LUNABTC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 90000000.00000000 + margin: True + """ name: str = "LUNABTC" precision: int = 8 minimum_margin: float = None @@ -27414,11 +38147,20 @@ def __call__(self): return "LUNABTC" -LUNABTC = LUNABTC() +LUNABUSD = LUNABUSD() @dataclass(slots=True, frozen=True) class LUNABUSD: + """ + name: LUNABUSD + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 92141578.00000000 + margin: True + """ name: str = "LUNABUSD" precision: int = 8 minimum_margin: float = None @@ -27437,11 +38179,20 @@ def __call__(self): return "LUNABUSD" -LUNABUSD = LUNABUSD() +LUNAETH = LUNAETH() @dataclass(slots=True, frozen=True) class LUNAETH: + """ + name: LUNAETH + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.00100000 + maximum_order_size: 92141578.00000000 + margin: False + """ name: str = "LUNAETH" precision: int = 8 minimum_margin: float = None @@ -27460,11 +38211,20 @@ def __call__(self): return "LUNAETH" -LUNAETH = LUNAETH() +LUNAEUR = LUNAEUR() @dataclass(slots=True, frozen=True) class LUNAEUR: + """ + name: LUNAEUR + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 9000000.00000000 + margin: False + """ name: str = "LUNAEUR" precision: int = 8 minimum_margin: float = None @@ -27483,11 +38243,20 @@ def __call__(self): return "LUNAEUR" -LUNAEUR = LUNAEUR() +LUNAGBP = LUNAGBP() @dataclass(slots=True, frozen=True) class LUNAGBP: + """ + name: LUNAGBP + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 9000000.00000000 + margin: False + """ name: str = "LUNAGBP" precision: int = 8 minimum_margin: float = None @@ -27506,11 +38275,20 @@ def __call__(self): return "LUNAGBP" -LUNAGBP = LUNAGBP() +LUNATRY = LUNATRY() @dataclass(slots=True, frozen=True) class LUNATRY: + """ + name: LUNATRY + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 9222449.00000000 + margin: False + """ name: str = "LUNATRY" precision: int = 8 minimum_margin: float = None @@ -27529,11 +38307,20 @@ def __call__(self): return "LUNATRY" -LUNATRY = LUNATRY() +LUNAUSDT = LUNAUSDT() @dataclass(slots=True, frozen=True) class LUNAUSDT: + """ + name: LUNAUSDT + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 92141578.00000000 + margin: True + """ name: str = "LUNAUSDT" precision: int = 8 minimum_margin: float = None @@ -27552,11 +38339,20 @@ def __call__(self): return "LUNAUSDT" -LUNAUSDT = LUNAUSDT() +LUNAUST = LUNAUST() @dataclass(slots=True, frozen=True) class LUNAUST: + """ + name: LUNAUST + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 9222449.00000000 + margin: False + """ name: str = "LUNAUST" precision: int = 8 minimum_margin: float = None @@ -27575,11 +38371,20 @@ def __call__(self): return "LUNAUST" -LUNAUST = LUNAUST() +LUNBTC = LUNBTC() @dataclass(slots=True, frozen=True) class LUNBTC: + """ + name: LUNBTC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 90000000.00000000 + margin: False + """ name: str = "LUNBTC" precision: int = 8 minimum_margin: float = None @@ -27598,11 +38403,20 @@ def __call__(self): return "LUNBTC" -LUNBTC = LUNBTC() +LUNCBUSD = LUNCBUSD() @dataclass(slots=True, frozen=True) class LUNCBUSD: + """ + name: LUNCBUSD + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 8384883677.00000000 + margin: True + """ name: str = "LUNCBUSD" precision: int = 8 minimum_margin: float = None @@ -27621,11 +38435,20 @@ def __call__(self): return "LUNCBUSD" -LUNCBUSD = LUNCBUSD() +LUNCUSDT = LUNCUSDT() @dataclass(slots=True, frozen=True) class LUNCUSDT: + """ + name: LUNCUSDT + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 8384883677.00000000 + margin: True + """ name: str = "LUNCUSDT" precision: int = 8 minimum_margin: float = None @@ -27644,11 +38467,20 @@ def __call__(self): return "LUNCUSDT" -LUNCUSDT = LUNCUSDT() +LUNETH = LUNETH() @dataclass(slots=True, frozen=True) class LUNETH: + """ + name: LUNETH + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 90000000.00000000 + margin: False + """ name: str = "LUNETH" precision: int = 8 minimum_margin: float = None @@ -27667,11 +38499,20 @@ def __call__(self): return "LUNETH" -LUNETH = LUNETH() +MAGICBTC = MAGICBTC() @dataclass(slots=True, frozen=True) class MAGICBTC: + """ + name: MAGICBTC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 92141578.00000000 + margin: False + """ name: str = "MAGICBTC" precision: int = 8 minimum_margin: float = None @@ -27690,11 +38531,20 @@ def __call__(self): return "MAGICBTC" -MAGICBTC = MAGICBTC() +MAGICBUSD = MAGICBUSD() @dataclass(slots=True, frozen=True) class MAGICBUSD: + """ + name: MAGICBUSD + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 92141578.00000000 + margin: False + """ name: str = "MAGICBUSD" precision: int = 8 minimum_margin: float = None @@ -27713,11 +38563,20 @@ def __call__(self): return "MAGICBUSD" -MAGICBUSD = MAGICBUSD() +MAGICUSDT = MAGICUSDT() @dataclass(slots=True, frozen=True) class MAGICUSDT: + """ + name: MAGICUSDT + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 92141578.00000000 + margin: False + """ name: str = "MAGICUSDT" precision: int = 8 minimum_margin: float = None @@ -27736,11 +38595,20 @@ def __call__(self): return "MAGICUSDT" -MAGICUSDT = MAGICUSDT() +MANABIDR = MANABIDR() @dataclass(slots=True, frozen=True) class MANABIDR: + """ + name: MANABIDR + precision: 2 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 9223371110.00000000 + margin: False + """ name: str = "MANABIDR" precision: int = 2 minimum_margin: float = None @@ -27759,11 +38627,20 @@ def __call__(self): return "MANABIDR" -MANABIDR = MANABIDR() +MANABNB = MANABNB() @dataclass(slots=True, frozen=True) class MANABNB: + """ + name: MANABNB + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 92141578.00000000 + margin: False + """ name: str = "MANABNB" precision: int = 8 minimum_margin: float = None @@ -27782,11 +38659,20 @@ def __call__(self): return "MANABNB" -MANABNB = MANABNB() +MANABRL = MANABRL() @dataclass(slots=True, frozen=True) class MANABRL: + """ + name: MANABRL + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 9222449.00000000 + margin: False + """ name: str = "MANABRL" precision: int = 8 minimum_margin: float = None @@ -27805,11 +38691,20 @@ def __call__(self): return "MANABRL" -MANABRL = MANABRL() +MANABTC = MANABTC() @dataclass(slots=True, frozen=True) class MANABTC: + """ + name: MANABTC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 90000000.00000000 + margin: True + """ name: str = "MANABTC" precision: int = 8 minimum_margin: float = None @@ -27828,11 +38723,20 @@ def __call__(self): return "MANABTC" -MANABTC = MANABTC() +MANABUSD = MANABUSD() @dataclass(slots=True, frozen=True) class MANABUSD: + """ + name: MANABUSD + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 900000.00000000 + margin: True + """ name: str = "MANABUSD" precision: int = 8 minimum_margin: float = None @@ -27851,11 +38755,20 @@ def __call__(self): return "MANABUSD" -MANABUSD = MANABUSD() +MANAETH = MANAETH() @dataclass(slots=True, frozen=True) class MANAETH: + """ + name: MANAETH + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 90000000.00000000 + margin: False + """ name: str = "MANAETH" precision: int = 8 minimum_margin: float = None @@ -27874,11 +38787,20 @@ def __call__(self): return "MANAETH" -MANAETH = MANAETH() +MANATRY = MANATRY() @dataclass(slots=True, frozen=True) class MANATRY: + """ + name: MANATRY + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 9222449.00000000 + margin: False + """ name: str = "MANATRY" precision: int = 8 minimum_margin: float = None @@ -27897,11 +38819,20 @@ def __call__(self): return "MANATRY" -MANATRY = MANATRY() +MANAUSDT = MANAUSDT() @dataclass(slots=True, frozen=True) class MANAUSDT: + """ + name: MANAUSDT + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 900000.00000000 + margin: True + """ name: str = "MANAUSDT" precision: int = 8 minimum_margin: float = None @@ -27920,11 +38851,20 @@ def __call__(self): return "MANAUSDT" -MANAUSDT = MANAUSDT() +MASKBNB = MASKBNB() @dataclass(slots=True, frozen=True) class MASKBNB: + """ + name: MASKBNB + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 92141578.00000000 + margin: False + """ name: str = "MASKBNB" precision: int = 8 minimum_margin: float = None @@ -27943,11 +38883,20 @@ def __call__(self): return "MASKBNB" -MASKBNB = MASKBNB() +MASKBUSD = MASKBUSD() @dataclass(slots=True, frozen=True) class MASKBUSD: + """ + name: MASKBUSD + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 9222449.00000000 + margin: True + """ name: str = "MASKBUSD" precision: int = 8 minimum_margin: float = None @@ -27966,11 +38915,20 @@ def __call__(self): return "MASKBUSD" -MASKBUSD = MASKBUSD() +MASKUSDT = MASKUSDT() @dataclass(slots=True, frozen=True) class MASKUSDT: + """ + name: MASKUSDT + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 9222449.00000000 + margin: True + """ name: str = "MASKUSDT" precision: int = 8 minimum_margin: float = None @@ -27989,11 +38947,20 @@ def __call__(self): return "MASKUSDT" -MASKUSDT = MASKUSDT() +MATICAUD = MATICAUD() @dataclass(slots=True, frozen=True) class MATICAUD: + """ + name: MATICAUD + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 9222449.00000000 + margin: False + """ name: str = "MATICAUD" precision: int = 8 minimum_margin: float = None @@ -28012,11 +38979,20 @@ def __call__(self): return "MATICAUD" -MATICAUD = MATICAUD() +MATICBIDR = MATICBIDR() @dataclass(slots=True, frozen=True) class MATICBIDR: + """ + name: MATICBIDR + precision: 2 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 184467.00000000 + margin: False + """ name: str = "MATICBIDR" precision: int = 2 minimum_margin: float = None @@ -28035,11 +39011,20 @@ def __call__(self): return "MATICBIDR" -MATICBIDR = MATICBIDR() +MATICBNB = MATICBNB() @dataclass(slots=True, frozen=True) class MATICBNB: + """ + name: MATICBNB + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 9000000.00000000 + margin: False + """ name: str = "MATICBNB" precision: int = 8 minimum_margin: float = None @@ -28058,11 +39043,20 @@ def __call__(self): return "MATICBNB" -MATICBNB = MATICBNB() +MATICBRL = MATICBRL() @dataclass(slots=True, frozen=True) class MATICBRL: + """ + name: MATICBRL + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 9222440.00000000 + margin: False + """ name: str = "MATICBRL" precision: int = 8 minimum_margin: float = None @@ -28081,11 +39075,20 @@ def __call__(self): return "MATICBRL" -MATICBRL = MATICBRL() +MATICBTC = MATICBTC() @dataclass(slots=True, frozen=True) class MATICBTC: + """ + name: MATICBTC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 90000000.00000000 + margin: True + """ name: str = "MATICBTC" precision: int = 8 minimum_margin: float = None @@ -28104,11 +39107,20 @@ def __call__(self): return "MATICBTC" -MATICBTC = MATICBTC() +MATICBUSD = MATICBUSD() @dataclass(slots=True, frozen=True) class MATICBUSD: + """ + name: MATICBUSD + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 9000000.00000000 + margin: True + """ name: str = "MATICBUSD" precision: int = 8 minimum_margin: float = None @@ -28127,11 +39139,20 @@ def __call__(self): return "MATICBUSD" -MATICBUSD = MATICBUSD() +MATICETH = MATICETH() @dataclass(slots=True, frozen=True) class MATICETH: + """ + name: MATICETH + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 92141578.00000000 + margin: False + """ name: str = "MATICETH" precision: int = 8 minimum_margin: float = None @@ -28150,11 +39171,20 @@ def __call__(self): return "MATICETH" -MATICETH = MATICETH() +MATICEUR = MATICEUR() @dataclass(slots=True, frozen=True) class MATICEUR: + """ + name: MATICEUR + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 900000.00000000 + margin: False + """ name: str = "MATICEUR" precision: int = 8 minimum_margin: float = None @@ -28173,11 +39203,20 @@ def __call__(self): return "MATICEUR" -MATICEUR = MATICEUR() +MATICGBP = MATICGBP() @dataclass(slots=True, frozen=True) class MATICGBP: + """ + name: MATICGBP + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 92141578.00000000 + margin: False + """ name: str = "MATICGBP" precision: int = 8 minimum_margin: float = None @@ -28196,11 +39235,20 @@ def __call__(self): return "MATICGBP" -MATICGBP = MATICGBP() +MATICRUB = MATICRUB() @dataclass(slots=True, frozen=True) class MATICRUB: + """ + name: MATICRUB + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 922327.00000000 + margin: False + """ name: str = "MATICRUB" precision: int = 8 minimum_margin: float = None @@ -28219,11 +39267,20 @@ def __call__(self): return "MATICRUB" -MATICRUB = MATICRUB() +MATICTRY = MATICTRY() @dataclass(slots=True, frozen=True) class MATICTRY: + """ + name: MATICTRY + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 9222449.00000000 + margin: False + """ name: str = "MATICTRY" precision: int = 8 minimum_margin: float = None @@ -28242,11 +39299,20 @@ def __call__(self): return "MATICTRY" -MATICTRY = MATICTRY() +MATICUSDT = MATICUSDT() @dataclass(slots=True, frozen=True) class MATICUSDT: + """ + name: MATICUSDT + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 9000000.00000000 + margin: True + """ name: str = "MATICUSDT" precision: int = 8 minimum_margin: float = None @@ -28265,11 +39331,20 @@ def __call__(self): return "MATICUSDT" -MATICUSDT = MATICUSDT() +MBLBNB = MBLBNB() @dataclass(slots=True, frozen=True) class MBLBNB: + """ + name: MBLBNB + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 90000000.00000000 + margin: False + """ name: str = "MBLBNB" precision: int = 8 minimum_margin: float = None @@ -28288,11 +39363,20 @@ def __call__(self): return "MBLBNB" -MBLBNB = MBLBNB() +MBLBTC = MBLBTC() @dataclass(slots=True, frozen=True) class MBLBTC: + """ + name: MBLBTC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 92141578.00000000 + margin: False + """ name: str = "MBLBTC" precision: int = 8 minimum_margin: float = None @@ -28311,11 +39395,20 @@ def __call__(self): return "MBLBTC" -MBLBTC = MBLBTC() +MBLBUSD = MBLBUSD() @dataclass(slots=True, frozen=True) class MBLBUSD: + """ + name: MBLBUSD + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 92141578.00000000 + margin: True + """ name: str = "MBLBUSD" precision: int = 8 minimum_margin: float = None @@ -28334,11 +39427,20 @@ def __call__(self): return "MBLBUSD" -MBLBUSD = MBLBUSD() +MBLUSDT = MBLUSDT() @dataclass(slots=True, frozen=True) class MBLUSDT: + """ + name: MBLUSDT + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 92141578.00000000 + margin: True + """ name: str = "MBLUSDT" precision: int = 8 minimum_margin: float = None @@ -28357,11 +39459,20 @@ def __call__(self): return "MBLUSDT" -MBLUSDT = MBLUSDT() +MBOXBNB = MBOXBNB() @dataclass(slots=True, frozen=True) class MBOXBNB: + """ + name: MBOXBNB + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 92141578.00000000 + margin: False + """ name: str = "MBOXBNB" precision: int = 8 minimum_margin: float = None @@ -28380,11 +39491,20 @@ def __call__(self): return "MBOXBNB" -MBOXBNB = MBOXBNB() +MBOXBTC = MBOXBTC() @dataclass(slots=True, frozen=True) class MBOXBTC: + """ + name: MBOXBTC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 92141578.00000000 + margin: False + """ name: str = "MBOXBTC" precision: int = 8 minimum_margin: float = None @@ -28403,11 +39523,20 @@ def __call__(self): return "MBOXBTC" -MBOXBTC = MBOXBTC() +MBOXBUSD = MBOXBUSD() @dataclass(slots=True, frozen=True) class MBOXBUSD: + """ + name: MBOXBUSD + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 92141578.00000000 + margin: False + """ name: str = "MBOXBUSD" precision: int = 8 minimum_margin: float = None @@ -28426,11 +39555,20 @@ def __call__(self): return "MBOXBUSD" -MBOXBUSD = MBOXBUSD() +MBOXTRY = MBOXTRY() @dataclass(slots=True, frozen=True) class MBOXTRY: + """ + name: MBOXTRY + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 9222449.00000000 + margin: False + """ name: str = "MBOXTRY" precision: int = 8 minimum_margin: float = None @@ -28449,11 +39587,20 @@ def __call__(self): return "MBOXTRY" -MBOXTRY = MBOXTRY() +MBOXUSDT = MBOXUSDT() @dataclass(slots=True, frozen=True) class MBOXUSDT: + """ + name: MBOXUSDT + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 92141578.00000000 + margin: False + """ name: str = "MBOXUSDT" precision: int = 8 minimum_margin: float = None @@ -28472,11 +39619,20 @@ def __call__(self): return "MBOXUSDT" -MBOXUSDT = MBOXUSDT() +MCBNB = MCBNB() @dataclass(slots=True, frozen=True) class MCBNB: + """ + name: MCBNB + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 92141578.00000000 + margin: False + """ name: str = "MCBNB" precision: int = 8 minimum_margin: float = None @@ -28495,11 +39651,20 @@ def __call__(self): return "MCBNB" -MCBNB = MCBNB() +MCBTC = MCBTC() @dataclass(slots=True, frozen=True) class MCBTC: + """ + name: MCBTC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 92141578.00000000 + margin: False + """ name: str = "MCBTC" precision: int = 8 minimum_margin: float = None @@ -28518,11 +39683,20 @@ def __call__(self): return "MCBTC" -MCBTC = MCBTC() +MCBUSD = MCBUSD() @dataclass(slots=True, frozen=True) class MCBUSD: + """ + name: MCBUSD + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 9222449.00000000 + margin: False + """ name: str = "MCBUSD" precision: int = 8 minimum_margin: float = None @@ -28541,11 +39715,20 @@ def __call__(self): return "MCBUSD" -MCBUSD = MCBUSD() +MCOBNB = MCOBNB() @dataclass(slots=True, frozen=True) class MCOBNB: + """ + name: MCOBNB + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 9000000.00000000 + margin: False + """ name: str = "MCOBNB" precision: int = 8 minimum_margin: float = None @@ -28564,11 +39747,20 @@ def __call__(self): return "MCOBNB" -MCOBNB = MCOBNB() +MCOBTC = MCOBTC() @dataclass(slots=True, frozen=True) class MCOBTC: + """ + name: MCOBTC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 90000000.00000000 + margin: False + """ name: str = "MCOBTC" precision: int = 8 minimum_margin: float = None @@ -28587,11 +39779,20 @@ def __call__(self): return "MCOBTC" -MCOBTC = MCOBTC() +MCOETH = MCOETH() @dataclass(slots=True, frozen=True) class MCOETH: + """ + name: MCOETH + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 90000000.00000000 + margin: False + """ name: str = "MCOETH" precision: int = 8 minimum_margin: float = None @@ -28610,11 +39811,20 @@ def __call__(self): return "MCOETH" -MCOETH = MCOETH() +MCOUSDT = MCOUSDT() @dataclass(slots=True, frozen=True) class MCOUSDT: + """ + name: MCOUSDT + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.00100000 + maximum_order_size: 90000.00000000 + margin: False + """ name: str = "MCOUSDT" precision: int = 8 minimum_margin: float = None @@ -28633,11 +39843,20 @@ def __call__(self): return "MCOUSDT" -MCOUSDT = MCOUSDT() +MCUSDT = MCUSDT() @dataclass(slots=True, frozen=True) class MCUSDT: + """ + name: MCUSDT + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 9222449.00000000 + margin: False + """ name: str = "MCUSDT" precision: int = 8 minimum_margin: float = None @@ -28656,11 +39875,20 @@ def __call__(self): return "MCUSDT" -MCUSDT = MCUSDT() +MDABTC = MDABTC() @dataclass(slots=True, frozen=True) class MDABTC: + """ + name: MDABTC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 90000000.00000000 + margin: False + """ name: str = "MDABTC" precision: int = 8 minimum_margin: float = None @@ -28679,11 +39907,20 @@ def __call__(self): return "MDABTC" -MDABTC = MDABTC() +MDAETH = MDAETH() @dataclass(slots=True, frozen=True) class MDAETH: + """ + name: MDAETH + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 90000000.00000000 + margin: False + """ name: str = "MDAETH" precision: int = 8 minimum_margin: float = None @@ -28702,11 +39939,20 @@ def __call__(self): return "MDAETH" -MDAETH = MDAETH() +MDTBNB = MDTBNB() @dataclass(slots=True, frozen=True) class MDTBNB: + """ + name: MDTBNB + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 9000000.00000000 + margin: False + """ name: str = "MDTBNB" precision: int = 8 minimum_margin: float = None @@ -28725,11 +39971,20 @@ def __call__(self): return "MDTBNB" -MDTBNB = MDTBNB() +MDTBTC = MDTBTC() @dataclass(slots=True, frozen=True) class MDTBTC: + """ + name: MDTBTC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 90000000.00000000 + margin: False + """ name: str = "MDTBTC" precision: int = 8 minimum_margin: float = None @@ -28748,11 +40003,20 @@ def __call__(self): return "MDTBTC" -MDTBTC = MDTBTC() +MDTBUSD = MDTBUSD() @dataclass(slots=True, frozen=True) class MDTBUSD: + """ + name: MDTBUSD + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 92141578.00000000 + margin: False + """ name: str = "MDTBUSD" precision: int = 8 minimum_margin: float = None @@ -28771,11 +40035,20 @@ def __call__(self): return "MDTBUSD" -MDTBUSD = MDTBUSD() +MDTUSDT = MDTUSDT() @dataclass(slots=True, frozen=True) class MDTUSDT: + """ + name: MDTUSDT + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 9000000.00000000 + margin: False + """ name: str = "MDTUSDT" precision: int = 8 minimum_margin: float = None @@ -28794,11 +40067,20 @@ def __call__(self): return "MDTUSDT" -MDTUSDT = MDTUSDT() +MDXBNB = MDXBNB() @dataclass(slots=True, frozen=True) class MDXBNB: + """ + name: MDXBNB + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 92141578.00000000 + margin: False + """ name: str = "MDXBNB" precision: int = 8 minimum_margin: float = None @@ -28817,11 +40099,20 @@ def __call__(self): return "MDXBNB" -MDXBNB = MDXBNB() +MDXBTC = MDXBTC() @dataclass(slots=True, frozen=True) class MDXBTC: + """ + name: MDXBTC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 92141578.00000000 + margin: True + """ name: str = "MDXBTC" precision: int = 8 minimum_margin: float = None @@ -28840,11 +40131,20 @@ def __call__(self): return "MDXBTC" -MDXBTC = MDXBTC() +MDXBUSD = MDXBUSD() @dataclass(slots=True, frozen=True) class MDXBUSD: + """ + name: MDXBUSD + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 92141578.00000000 + margin: True + """ name: str = "MDXBUSD" precision: int = 8 minimum_margin: float = None @@ -28863,11 +40163,20 @@ def __call__(self): return "MDXBUSD" -MDXBUSD = MDXBUSD() +MDXUSDT = MDXUSDT() @dataclass(slots=True, frozen=True) class MDXUSDT: + """ + name: MDXUSDT + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 92141578.00000000 + margin: True + """ name: str = "MDXUSDT" precision: int = 8 minimum_margin: float = None @@ -28886,11 +40195,20 @@ def __call__(self): return "MDXUSDT" -MDXUSDT = MDXUSDT() +MFTBNB = MFTBNB() @dataclass(slots=True, frozen=True) class MFTBNB: + """ + name: MFTBNB + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 90000000.00000000 + margin: False + """ name: str = "MFTBNB" precision: int = 8 minimum_margin: float = None @@ -28909,11 +40227,20 @@ def __call__(self): return "MFTBNB" -MFTBNB = MFTBNB() +MFTBTC = MFTBTC() @dataclass(slots=True, frozen=True) class MFTBTC: + """ + name: MFTBTC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 92141578.00000000 + margin: False + """ name: str = "MFTBTC" precision: int = 8 minimum_margin: float = None @@ -28932,11 +40259,20 @@ def __call__(self): return "MFTBTC" -MFTBTC = MFTBTC() +MFTETH = MFTETH() @dataclass(slots=True, frozen=True) class MFTETH: + """ + name: MFTETH + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 90000000.00000000 + margin: False + """ name: str = "MFTETH" precision: int = 8 minimum_margin: float = None @@ -28955,11 +40291,20 @@ def __call__(self): return "MFTETH" -MFTETH = MFTETH() +MFTUSDT = MFTUSDT() @dataclass(slots=True, frozen=True) class MFTUSDT: + """ + name: MFTUSDT + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 92141578.00000000 + margin: False + """ name: str = "MFTUSDT" precision: int = 8 minimum_margin: float = None @@ -28978,11 +40323,20 @@ def __call__(self): return "MFTUSDT" -MFTUSDT = MFTUSDT() +MINABNB = MINABNB() @dataclass(slots=True, frozen=True) class MINABNB: + """ + name: MINABNB + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 92141578.00000000 + margin: False + """ name: str = "MINABNB" precision: int = 8 minimum_margin: float = None @@ -29001,11 +40355,20 @@ def __call__(self): return "MINABNB" -MINABNB = MINABNB() +MINABTC = MINABTC() @dataclass(slots=True, frozen=True) class MINABTC: + """ + name: MINABTC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 92141578.00000000 + margin: True + """ name: str = "MINABTC" precision: int = 8 minimum_margin: float = None @@ -29024,11 +40387,20 @@ def __call__(self): return "MINABTC" -MINABTC = MINABTC() +MINABUSD = MINABUSD() @dataclass(slots=True, frozen=True) class MINABUSD: + """ + name: MINABUSD + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 9222449.00000000 + margin: True + """ name: str = "MINABUSD" precision: int = 8 minimum_margin: float = None @@ -29047,11 +40419,20 @@ def __call__(self): return "MINABUSD" -MINABUSD = MINABUSD() +MINATRY = MINATRY() @dataclass(slots=True, frozen=True) class MINATRY: + """ + name: MINATRY + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 9222449.00000000 + margin: False + """ name: str = "MINATRY" precision: int = 8 minimum_margin: float = None @@ -29070,11 +40451,20 @@ def __call__(self): return "MINATRY" -MINATRY = MINATRY() +MINAUSDT = MINAUSDT() @dataclass(slots=True, frozen=True) class MINAUSDT: + """ + name: MINAUSDT + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 9222449.00000000 + margin: True + """ name: str = "MINAUSDT" precision: int = 8 minimum_margin: float = None @@ -29093,11 +40483,20 @@ def __call__(self): return "MINAUSDT" -MINAUSDT = MINAUSDT() +MIRBTC = MIRBTC() @dataclass(slots=True, frozen=True) class MIRBTC: + """ + name: MIRBTC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 90000000.00000000 + margin: False + """ name: str = "MIRBTC" precision: int = 8 minimum_margin: float = None @@ -29116,11 +40515,20 @@ def __call__(self): return "MIRBTC" -MIRBTC = MIRBTC() +MIRBUSD = MIRBUSD() @dataclass(slots=True, frozen=True) class MIRBUSD: + """ + name: MIRBUSD + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 90000.00000000 + margin: False + """ name: str = "MIRBUSD" precision: int = 8 minimum_margin: float = None @@ -29139,11 +40547,20 @@ def __call__(self): return "MIRBUSD" -MIRBUSD = MIRBUSD() +MIRUSDT = MIRUSDT() @dataclass(slots=True, frozen=True) class MIRUSDT: + """ + name: MIRUSDT + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 90000.00000000 + margin: False + """ name: str = "MIRUSDT" precision: int = 8 minimum_margin: float = None @@ -29162,11 +40579,20 @@ def __call__(self): return "MIRUSDT" -MIRUSDT = MIRUSDT() +MITHBNB = MITHBNB() @dataclass(slots=True, frozen=True) class MITHBNB: + """ + name: MITHBNB + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 9000000.00000000 + margin: False + """ name: str = "MITHBNB" precision: int = 8 minimum_margin: float = None @@ -29185,11 +40611,20 @@ def __call__(self): return "MITHBNB" -MITHBNB = MITHBNB() +MITHBTC = MITHBTC() @dataclass(slots=True, frozen=True) class MITHBTC: + """ + name: MITHBTC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 90000000.00000000 + margin: False + """ name: str = "MITHBTC" precision: int = 8 minimum_margin: float = None @@ -29208,11 +40643,20 @@ def __call__(self): return "MITHBTC" -MITHBTC = MITHBTC() +MITHUSDT = MITHUSDT() @dataclass(slots=True, frozen=True) class MITHUSDT: + """ + name: MITHUSDT + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 9000000.00000000 + margin: False + """ name: str = "MITHUSDT" precision: int = 8 minimum_margin: float = None @@ -29231,11 +40675,20 @@ def __call__(self): return "MITHUSDT" -MITHUSDT = MITHUSDT() +MKRBNB = MKRBNB() @dataclass(slots=True, frozen=True) class MKRBNB: + """ + name: MKRBNB + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.00010000 + maximum_order_size: 900000.00000000 + margin: False + """ name: str = "MKRBNB" precision: int = 8 minimum_margin: float = None @@ -29254,11 +40707,20 @@ def __call__(self): return "MKRBNB" -MKRBNB = MKRBNB() +MKRBTC = MKRBTC() @dataclass(slots=True, frozen=True) class MKRBTC: + """ + name: MKRBTC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.00010000 + maximum_order_size: 10000000.00000000 + margin: True + """ name: str = "MKRBTC" precision: int = 8 minimum_margin: float = None @@ -29277,11 +40739,20 @@ def __call__(self): return "MKRBTC" -MKRBTC = MKRBTC() +MKRBUSD = MKRBUSD() @dataclass(slots=True, frozen=True) class MKRBUSD: + """ + name: MKRBUSD + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.00010000 + maximum_order_size: 90000.00000000 + margin: True + """ name: str = "MKRBUSD" precision: int = 8 minimum_margin: float = None @@ -29300,11 +40771,20 @@ def __call__(self): return "MKRBUSD" -MKRBUSD = MKRBUSD() +MKRUSDT = MKRUSDT() @dataclass(slots=True, frozen=True) class MKRUSDT: + """ + name: MKRUSDT + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.00010000 + maximum_order_size: 90000.00000000 + margin: True + """ name: str = "MKRUSDT" precision: int = 8 minimum_margin: float = None @@ -29323,11 +40803,20 @@ def __call__(self): return "MKRUSDT" -MKRUSDT = MKRUSDT() +MLNBNB = MLNBNB() @dataclass(slots=True, frozen=True) class MLNBNB: + """ + name: MLNBNB + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.00100000 + maximum_order_size: 92141578.00000000 + margin: False + """ name: str = "MLNBNB" precision: int = 8 minimum_margin: float = None @@ -29346,11 +40835,20 @@ def __call__(self): return "MLNBNB" -MLNBNB = MLNBNB() +MLNBTC = MLNBTC() @dataclass(slots=True, frozen=True) class MLNBTC: + """ + name: MLNBTC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.00100000 + maximum_order_size: 92141578.00000000 + margin: True + """ name: str = "MLNBTC" precision: int = 8 minimum_margin: float = None @@ -29369,11 +40867,20 @@ def __call__(self): return "MLNBTC" -MLNBTC = MLNBTC() +MLNBUSD = MLNBUSD() @dataclass(slots=True, frozen=True) class MLNBUSD: + """ + name: MLNBUSD + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.00100000 + maximum_order_size: 9222449.00000000 + margin: True + """ name: str = "MLNBUSD" precision: int = 8 minimum_margin: float = None @@ -29392,11 +40899,20 @@ def __call__(self): return "MLNBUSD" -MLNBUSD = MLNBUSD() +MLNUSDT = MLNUSDT() @dataclass(slots=True, frozen=True) class MLNUSDT: + """ + name: MLNUSDT + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.00100000 + maximum_order_size: 9222449.00000000 + margin: True + """ name: str = "MLNUSDT" precision: int = 8 minimum_margin: float = None @@ -29415,11 +40931,20 @@ def __call__(self): return "MLNUSDT" -MLNUSDT = MLNUSDT() +MOBBTC = MOBBTC() @dataclass(slots=True, frozen=True) class MOBBTC: + """ + name: MOBBTC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 92141578.00000000 + margin: False + """ name: str = "MOBBTC" precision: int = 8 minimum_margin: float = None @@ -29438,11 +40963,20 @@ def __call__(self): return "MOBBTC" -MOBBTC = MOBBTC() +MOBBUSD = MOBBUSD() @dataclass(slots=True, frozen=True) class MOBBUSD: + """ + name: MOBBUSD + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 92141578.00000000 + margin: False + """ name: str = "MOBBUSD" precision: int = 8 minimum_margin: float = None @@ -29461,11 +40995,20 @@ def __call__(self): return "MOBBUSD" -MOBBUSD = MOBBUSD() +MOBUSDT = MOBUSDT() @dataclass(slots=True, frozen=True) class MOBUSDT: + """ + name: MOBUSDT + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 92141578.00000000 + margin: False + """ name: str = "MOBUSDT" precision: int = 8 minimum_margin: float = None @@ -29484,11 +41027,20 @@ def __call__(self): return "MOBUSDT" -MOBUSDT = MOBUSDT() +MODBTC = MODBTC() @dataclass(slots=True, frozen=True) class MODBTC: + """ + name: MODBTC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 90000000.00000000 + margin: False + """ name: str = "MODBTC" precision: int = 8 minimum_margin: float = None @@ -29507,11 +41059,20 @@ def __call__(self): return "MODBTC" -MODBTC = MODBTC() +MODETH = MODETH() @dataclass(slots=True, frozen=True) class MODETH: + """ + name: MODETH + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 90000000.00000000 + margin: False + """ name: str = "MODETH" precision: int = 8 minimum_margin: float = None @@ -29530,11 +41091,20 @@ def __call__(self): return "MODETH" -MODETH = MODETH() +MOVRBNB = MOVRBNB() @dataclass(slots=True, frozen=True) class MOVRBNB: + """ + name: MOVRBNB + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.00100000 + maximum_order_size: 92141578.00000000 + margin: False + """ name: str = "MOVRBNB" precision: int = 8 minimum_margin: float = None @@ -29553,11 +41123,20 @@ def __call__(self): return "MOVRBNB" -MOVRBNB = MOVRBNB() +MOVRBTC = MOVRBTC() @dataclass(slots=True, frozen=True) class MOVRBTC: + """ + name: MOVRBTC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.00100000 + maximum_order_size: 92141578.00000000 + margin: False + """ name: str = "MOVRBTC" precision: int = 8 minimum_margin: float = None @@ -29576,11 +41155,20 @@ def __call__(self): return "MOVRBTC" -MOVRBTC = MOVRBTC() +MOVRBUSD = MOVRBUSD() @dataclass(slots=True, frozen=True) class MOVRBUSD: + """ + name: MOVRBUSD + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.00100000 + maximum_order_size: 922327.00000000 + margin: False + """ name: str = "MOVRBUSD" precision: int = 8 minimum_margin: float = None @@ -29599,11 +41187,20 @@ def __call__(self): return "MOVRBUSD" -MOVRBUSD = MOVRBUSD() +MOVRUSDT = MOVRUSDT() @dataclass(slots=True, frozen=True) class MOVRUSDT: + """ + name: MOVRUSDT + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.00100000 + maximum_order_size: 922327.00000000 + margin: False + """ name: str = "MOVRUSDT" precision: int = 8 minimum_margin: float = None @@ -29622,11 +41219,20 @@ def __call__(self): return "MOVRUSDT" -MOVRUSDT = MOVRUSDT() +MTHBTC = MTHBTC() @dataclass(slots=True, frozen=True) class MTHBTC: + """ + name: MTHBTC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 90000000.00000000 + margin: False + """ name: str = "MTHBTC" precision: int = 8 minimum_margin: float = None @@ -29645,11 +41251,20 @@ def __call__(self): return "MTHBTC" -MTHBTC = MTHBTC() +MTHETH = MTHETH() @dataclass(slots=True, frozen=True) class MTHETH: + """ + name: MTHETH + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 90000000.00000000 + margin: False + """ name: str = "MTHETH" precision: int = 8 minimum_margin: float = None @@ -29668,11 +41283,20 @@ def __call__(self): return "MTHETH" -MTHETH = MTHETH() +MTLBTC = MTLBTC() @dataclass(slots=True, frozen=True) class MTLBTC: + """ + name: MTLBTC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 90000000.00000000 + margin: True + """ name: str = "MTLBTC" precision: int = 8 minimum_margin: float = None @@ -29691,11 +41315,20 @@ def __call__(self): return "MTLBTC" -MTLBTC = MTLBTC() +MTLBUSD = MTLBUSD() @dataclass(slots=True, frozen=True) class MTLBUSD: + """ + name: MTLBUSD + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 9222449.00000000 + margin: True + """ name: str = "MTLBUSD" precision: int = 8 minimum_margin: float = None @@ -29714,11 +41347,20 @@ def __call__(self): return "MTLBUSD" -MTLBUSD = MTLBUSD() +MTLETH = MTLETH() @dataclass(slots=True, frozen=True) class MTLETH: + """ + name: MTLETH + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 92141578.00000000 + margin: False + """ name: str = "MTLETH" precision: int = 8 minimum_margin: float = None @@ -29737,11 +41379,20 @@ def __call__(self): return "MTLETH" -MTLETH = MTLETH() +MTLUSDT = MTLUSDT() @dataclass(slots=True, frozen=True) class MTLUSDT: + """ + name: MTLUSDT + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 900000.00000000 + margin: True + """ name: str = "MTLUSDT" precision: int = 8 minimum_margin: float = None @@ -29760,11 +41411,20 @@ def __call__(self): return "MTLUSDT" -MTLUSDT = MTLUSDT() +MULTIBTC = MULTIBTC() @dataclass(slots=True, frozen=True) class MULTIBTC: + """ + name: MULTIBTC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.00100000 + maximum_order_size: 92141578.00000000 + margin: False + """ name: str = "MULTIBTC" precision: int = 8 minimum_margin: float = None @@ -29783,11 +41443,20 @@ def __call__(self): return "MULTIBTC" -MULTIBTC = MULTIBTC() +MULTIBUSD = MULTIBUSD() @dataclass(slots=True, frozen=True) class MULTIBUSD: + """ + name: MULTIBUSD + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.00100000 + maximum_order_size: 9222449.00000000 + margin: False + """ name: str = "MULTIBUSD" precision: int = 8 minimum_margin: float = None @@ -29806,11 +41475,20 @@ def __call__(self): return "MULTIBUSD" -MULTIBUSD = MULTIBUSD() +MULTIUSDT = MULTIUSDT() @dataclass(slots=True, frozen=True) class MULTIUSDT: + """ + name: MULTIUSDT + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.00100000 + maximum_order_size: 9222449.00000000 + margin: False + """ name: str = "MULTIUSDT" precision: int = 8 minimum_margin: float = None @@ -29829,11 +41507,20 @@ def __call__(self): return "MULTIUSDT" -MULTIUSDT = MULTIUSDT() +NANOBNB = NANOBNB() @dataclass(slots=True, frozen=True) class NANOBNB: + """ + name: NANOBNB + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 9000000.00000000 + margin: False + """ name: str = "NANOBNB" precision: int = 8 minimum_margin: float = None @@ -29852,11 +41539,20 @@ def __call__(self): return "NANOBNB" -NANOBNB = NANOBNB() +NANOBTC = NANOBTC() @dataclass(slots=True, frozen=True) class NANOBTC: + """ + name: NANOBTC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 90000000.00000000 + margin: False + """ name: str = "NANOBTC" precision: int = 8 minimum_margin: float = None @@ -29875,11 +41571,20 @@ def __call__(self): return "NANOBTC" -NANOBTC = NANOBTC() +NANOBUSD = NANOBUSD() @dataclass(slots=True, frozen=True) class NANOBUSD: + """ + name: NANOBUSD + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 900000.00000000 + margin: False + """ name: str = "NANOBUSD" precision: int = 8 minimum_margin: float = None @@ -29898,11 +41603,20 @@ def __call__(self): return "NANOBUSD" -NANOBUSD = NANOBUSD() +NANOETH = NANOETH() @dataclass(slots=True, frozen=True) class NANOETH: + """ + name: NANOETH + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 90000000.00000000 + margin: False + """ name: str = "NANOETH" precision: int = 8 minimum_margin: float = None @@ -29921,11 +41635,20 @@ def __call__(self): return "NANOETH" -NANOETH = NANOETH() +NANOUSDT = NANOUSDT() @dataclass(slots=True, frozen=True) class NANOUSDT: + """ + name: NANOUSDT + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 900000.00000000 + margin: False + """ name: str = "NANOUSDT" precision: int = 8 minimum_margin: float = None @@ -29944,11 +41667,20 @@ def __call__(self): return "NANOUSDT" -NANOUSDT = NANOUSDT() +NASBNB = NASBNB() @dataclass(slots=True, frozen=True) class NASBNB: + """ + name: NASBNB + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 9000000.00000000 + margin: False + """ name: str = "NASBNB" precision: int = 8 minimum_margin: float = None @@ -29967,11 +41699,20 @@ def __call__(self): return "NASBNB" -NASBNB = NASBNB() +NASBTC = NASBTC() @dataclass(slots=True, frozen=True) class NASBTC: + """ + name: NASBTC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 90000000.00000000 + margin: False + """ name: str = "NASBTC" precision: int = 8 minimum_margin: float = None @@ -29990,11 +41731,20 @@ def __call__(self): return "NASBTC" -NASBTC = NASBTC() +NASETH = NASETH() @dataclass(slots=True, frozen=True) class NASETH: + """ + name: NASETH + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 9000000.00000000 + margin: False + """ name: str = "NASETH" precision: int = 8 minimum_margin: float = None @@ -30013,11 +41763,20 @@ def __call__(self): return "NASETH" -NASETH = NASETH() +NAVBNB = NAVBNB() @dataclass(slots=True, frozen=True) class NAVBNB: + """ + name: NAVBNB + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 9000000.00000000 + margin: False + """ name: str = "NAVBNB" precision: int = 8 minimum_margin: float = None @@ -30036,11 +41795,20 @@ def __call__(self): return "NAVBNB" -NAVBNB = NAVBNB() +NAVBTC = NAVBTC() @dataclass(slots=True, frozen=True) class NAVBTC: + """ + name: NAVBTC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 90000000.00000000 + margin: False + """ name: str = "NAVBTC" precision: int = 8 minimum_margin: float = None @@ -30059,11 +41827,20 @@ def __call__(self): return "NAVBTC" -NAVBTC = NAVBTC() +NAVETH = NAVETH() @dataclass(slots=True, frozen=True) class NAVETH: + """ + name: NAVETH + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 90000000.00000000 + margin: False + """ name: str = "NAVETH" precision: int = 8 minimum_margin: float = None @@ -30082,11 +41859,20 @@ def __call__(self): return "NAVETH" -NAVETH = NAVETH() +NBSBTC = NBSBTC() @dataclass(slots=True, frozen=True) class NBSBTC: + """ + name: NBSBTC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 90000000.00000000 + margin: False + """ name: str = "NBSBTC" precision: int = 8 minimum_margin: float = None @@ -30105,11 +41891,20 @@ def __call__(self): return "NBSBTC" -NBSBTC = NBSBTC() +NBSUSDT = NBSUSDT() @dataclass(slots=True, frozen=True) class NBSUSDT: + """ + name: NBSUSDT + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 92141578.00000000 + margin: False + """ name: str = "NBSUSDT" precision: int = 8 minimum_margin: float = None @@ -30128,11 +41923,20 @@ def __call__(self): return "NBSUSDT" -NBSUSDT = NBSUSDT() +NBTBIDR = NBTBIDR() @dataclass(slots=True, frozen=True) class NBTBIDR: + """ + name: NBTBIDR + precision: 2 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 92232700.00000000 + margin: False + """ name: str = "NBTBIDR" precision: int = 2 minimum_margin: float = None @@ -30151,11 +41955,20 @@ def __call__(self): return "NBTBIDR" -NBTBIDR = NBTBIDR() +NBTUSDT = NBTUSDT() @dataclass(slots=True, frozen=True) class NBTUSDT: + """ + name: NBTUSDT + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 92141578.00000000 + margin: False + """ name: str = "NBTUSDT" precision: int = 8 minimum_margin: float = None @@ -30174,11 +41987,20 @@ def __call__(self): return "NBTUSDT" -NBTUSDT = NBTUSDT() +NCASHBNB = NCASHBNB() @dataclass(slots=True, frozen=True) class NCASHBNB: + """ + name: NCASHBNB + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 9222449.00000000 + margin: False + """ name: str = "NCASHBNB" precision: int = 8 minimum_margin: float = None @@ -30197,11 +42019,20 @@ def __call__(self): return "NCASHBNB" -NCASHBNB = NCASHBNB() +NCASHBTC = NCASHBTC() @dataclass(slots=True, frozen=True) class NCASHBTC: + """ + name: NCASHBTC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 92141578.00000000 + margin: False + """ name: str = "NCASHBTC" precision: int = 8 minimum_margin: float = None @@ -30220,11 +42051,20 @@ def __call__(self): return "NCASHBTC" -NCASHBTC = NCASHBTC() +NCASHETH = NCASHETH() @dataclass(slots=True, frozen=True) class NCASHETH: + """ + name: NCASHETH + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 92141578.00000000 + margin: False + """ name: str = "NCASHETH" precision: int = 8 minimum_margin: float = None @@ -30243,11 +42083,20 @@ def __call__(self): return "NCASHETH" -NCASHETH = NCASHETH() +NEARBNB = NEARBNB() @dataclass(slots=True, frozen=True) class NEARBNB: + """ + name: NEARBNB + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 9000000.00000000 + margin: False + """ name: str = "NEARBNB" precision: int = 8 minimum_margin: float = None @@ -30266,11 +42115,20 @@ def __call__(self): return "NEARBNB" -NEARBNB = NEARBNB() +NEARBTC = NEARBTC() @dataclass(slots=True, frozen=True) class NEARBTC: + """ + name: NEARBTC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 90000000.00000000 + margin: True + """ name: str = "NEARBTC" precision: int = 8 minimum_margin: float = None @@ -30289,11 +42147,20 @@ def __call__(self): return "NEARBTC" -NEARBTC = NEARBTC() +NEARBUSD = NEARBUSD() @dataclass(slots=True, frozen=True) class NEARBUSD: + """ + name: NEARBUSD + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 900000.00000000 + margin: True + """ name: str = "NEARBUSD" precision: int = 8 minimum_margin: float = None @@ -30312,11 +42179,20 @@ def __call__(self): return "NEARBUSD" -NEARBUSD = NEARBUSD() +NEARETH = NEARETH() @dataclass(slots=True, frozen=True) class NEARETH: + """ + name: NEARETH + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.00100000 + maximum_order_size: 92141578.00000000 + margin: False + """ name: str = "NEARETH" precision: int = 8 minimum_margin: float = None @@ -30335,11 +42211,20 @@ def __call__(self): return "NEARETH" -NEARETH = NEARETH() +NEAREUR = NEAREUR() @dataclass(slots=True, frozen=True) class NEAREUR: + """ + name: NEAREUR + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 900000.00000000 + margin: False + """ name: str = "NEAREUR" precision: int = 8 minimum_margin: float = None @@ -30358,11 +42243,20 @@ def __call__(self): return "NEAREUR" -NEAREUR = NEAREUR() +NEARRUB = NEARRUB() @dataclass(slots=True, frozen=True) class NEARRUB: + """ + name: NEARRUB + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.00100000 + maximum_order_size: 92233.00000000 + margin: False + """ name: str = "NEARRUB" precision: int = 8 minimum_margin: float = None @@ -30381,11 +42275,20 @@ def __call__(self): return "NEARRUB" -NEARRUB = NEARRUB() +NEARTRY = NEARTRY() @dataclass(slots=True, frozen=True) class NEARTRY: + """ + name: NEARTRY + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.00100000 + maximum_order_size: 922327.00000000 + margin: False + """ name: str = "NEARTRY" precision: int = 8 minimum_margin: float = None @@ -30404,11 +42307,20 @@ def __call__(self): return "NEARTRY" -NEARTRY = NEARTRY() +NEARUSDT = NEARUSDT() @dataclass(slots=True, frozen=True) class NEARUSDT: + """ + name: NEARUSDT + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 900000.00000000 + margin: True + """ name: str = "NEARUSDT" precision: int = 8 minimum_margin: float = None @@ -30427,11 +42339,20 @@ def __call__(self): return "NEARUSDT" -NEARUSDT = NEARUSDT() +NEBLBNB = NEBLBNB() @dataclass(slots=True, frozen=True) class NEBLBNB: + """ + name: NEBLBNB + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 9000000.00000000 + margin: False + """ name: str = "NEBLBNB" precision: int = 8 minimum_margin: float = None @@ -30450,11 +42371,20 @@ def __call__(self): return "NEBLBNB" -NEBLBNB = NEBLBNB() +NEBLBTC = NEBLBTC() @dataclass(slots=True, frozen=True) class NEBLBTC: + """ + name: NEBLBTC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 90000000.00000000 + margin: False + """ name: str = "NEBLBTC" precision: int = 8 minimum_margin: float = None @@ -30473,11 +42403,20 @@ def __call__(self): return "NEBLBTC" -NEBLBTC = NEBLBTC() +NEBLBUSD = NEBLBUSD() @dataclass(slots=True, frozen=True) class NEBLBUSD: + """ + name: NEBLBUSD + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 92141578.00000000 + margin: True + """ name: str = "NEBLBUSD" precision: int = 8 minimum_margin: float = None @@ -30496,11 +42435,20 @@ def __call__(self): return "NEBLBUSD" -NEBLBUSD = NEBLBUSD() +NEBLUSDT = NEBLUSDT() @dataclass(slots=True, frozen=True) class NEBLUSDT: + """ + name: NEBLUSDT + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 92141578.00000000 + margin: False + """ name: str = "NEBLUSDT" precision: int = 8 minimum_margin: float = None @@ -30519,11 +42467,20 @@ def __call__(self): return "NEBLUSDT" -NEBLUSDT = NEBLUSDT() +NEOBNB = NEOBNB() @dataclass(slots=True, frozen=True) class NEOBNB: + """ + name: NEOBNB + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 900000.00000000 + margin: False + """ name: str = "NEOBNB" precision: int = 8 minimum_margin: float = None @@ -30542,11 +42499,20 @@ def __call__(self): return "NEOBNB" -NEOBNB = NEOBNB() +NEOBTC = NEOBTC() @dataclass(slots=True, frozen=True) class NEOBTC: + """ + name: NEOBTC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 100000.00000000 + margin: True + """ name: str = "NEOBTC" precision: int = 8 minimum_margin: float = None @@ -30565,11 +42531,20 @@ def __call__(self): return "NEOBTC" -NEOBTC = NEOBTC() +NEOBUSD = NEOBUSD() @dataclass(slots=True, frozen=True) class NEOBUSD: + """ + name: NEOBUSD + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 90000.00000000 + margin: True + """ name: str = "NEOBUSD" precision: int = 8 minimum_margin: float = None @@ -30588,11 +42563,20 @@ def __call__(self): return "NEOBUSD" -NEOBUSD = NEOBUSD() +NEOETH = NEOETH() @dataclass(slots=True, frozen=True) class NEOETH: + """ + name: NEOETH + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 90000000.00000000 + margin: False + """ name: str = "NEOETH" precision: int = 8 minimum_margin: float = None @@ -30611,11 +42595,20 @@ def __call__(self): return "NEOETH" -NEOETH = NEOETH() +NEOPAX = NEOPAX() @dataclass(slots=True, frozen=True) class NEOPAX: + """ + name: NEOPAX + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.00100000 + maximum_order_size: 90000.00000000 + margin: False + """ name: str = "NEOPAX" precision: int = 8 minimum_margin: float = None @@ -30634,11 +42627,20 @@ def __call__(self): return "NEOPAX" -NEOPAX = NEOPAX() +NEORUB = NEORUB() @dataclass(slots=True, frozen=True) class NEORUB: + """ + name: NEORUB + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.00100000 + maximum_order_size: 92233.00000000 + margin: False + """ name: str = "NEORUB" precision: int = 8 minimum_margin: float = None @@ -30657,11 +42659,20 @@ def __call__(self): return "NEORUB" -NEORUB = NEORUB() +NEOTRY = NEOTRY() @dataclass(slots=True, frozen=True) class NEOTRY: + """ + name: NEOTRY + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 922327.00000000 + margin: False + """ name: str = "NEOTRY" precision: int = 8 minimum_margin: float = None @@ -30680,11 +42691,20 @@ def __call__(self): return "NEOTRY" -NEOTRY = NEOTRY() +NEOTUSD = NEOTUSD() @dataclass(slots=True, frozen=True) class NEOTUSD: + """ + name: NEOTUSD + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.00100000 + maximum_order_size: 90000.00000000 + margin: False + """ name: str = "NEOTUSD" precision: int = 8 minimum_margin: float = None @@ -30703,11 +42723,20 @@ def __call__(self): return "NEOTUSD" -NEOTUSD = NEOTUSD() +NEOUSDC = NEOUSDC() @dataclass(slots=True, frozen=True) class NEOUSDC: + """ + name: NEOUSDC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 90000.00000000 + margin: False + """ name: str = "NEOUSDC" precision: int = 8 minimum_margin: float = None @@ -30726,11 +42755,20 @@ def __call__(self): return "NEOUSDC" -NEOUSDC = NEOUSDC() +NEOUSDT = NEOUSDT() @dataclass(slots=True, frozen=True) class NEOUSDT: + """ + name: NEOUSDT + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 90000.00000000 + margin: True + """ name: str = "NEOUSDT" precision: int = 8 minimum_margin: float = None @@ -30749,11 +42787,20 @@ def __call__(self): return "NEOUSDT" -NEOUSDT = NEOUSDT() +NEXOBTC = NEXOBTC() @dataclass(slots=True, frozen=True) class NEXOBTC: + """ + name: NEXOBTC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 92141578.00000000 + margin: False + """ name: str = "NEXOBTC" precision: int = 8 minimum_margin: float = None @@ -30772,11 +42819,20 @@ def __call__(self): return "NEXOBTC" -NEXOBTC = NEXOBTC() +NEXOBUSD = NEXOBUSD() @dataclass(slots=True, frozen=True) class NEXOBUSD: + """ + name: NEXOBUSD + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 92141578.00000000 + margin: True + """ name: str = "NEXOBUSD" precision: int = 8 minimum_margin: float = None @@ -30795,11 +42851,20 @@ def __call__(self): return "NEXOBUSD" -NEXOBUSD = NEXOBUSD() +NEXOUSDT = NEXOUSDT() @dataclass(slots=True, frozen=True) class NEXOUSDT: + """ + name: NEXOUSDT + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 92141578.00000000 + margin: True + """ name: str = "NEXOUSDT" precision: int = 8 minimum_margin: float = None @@ -30818,11 +42883,20 @@ def __call__(self): return "NEXOUSDT" -NEXOUSDT = NEXOUSDT() +NKNBNB = NKNBNB() @dataclass(slots=True, frozen=True) class NKNBNB: + """ + name: NKNBNB + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 9000000.00000000 + margin: False + """ name: str = "NKNBNB" precision: int = 8 minimum_margin: float = None @@ -30841,11 +42915,20 @@ def __call__(self): return "NKNBNB" -NKNBNB = NKNBNB() +NKNBTC = NKNBTC() @dataclass(slots=True, frozen=True) class NKNBTC: + """ + name: NKNBTC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 90000000.00000000 + margin: True + """ name: str = "NKNBTC" precision: int = 8 minimum_margin: float = None @@ -30864,11 +42947,20 @@ def __call__(self): return "NKNBTC" -NKNBTC = NKNBTC() +NKNBUSD = NKNBUSD() @dataclass(slots=True, frozen=True) class NKNBUSD: + """ + name: NKNBUSD + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 9000000.00000000 + margin: False + """ name: str = "NKNBUSD" precision: int = 8 minimum_margin: float = None @@ -30887,11 +42979,20 @@ def __call__(self): return "NKNBUSD" -NKNBUSD = NKNBUSD() +NKNUSDT = NKNUSDT() @dataclass(slots=True, frozen=True) class NKNUSDT: + """ + name: NKNUSDT + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 9000000.00000000 + margin: True + """ name: str = "NKNUSDT" precision: int = 8 minimum_margin: float = None @@ -30910,11 +43011,20 @@ def __call__(self): return "NKNUSDT" -NKNUSDT = NKNUSDT() +NMRBTC = NMRBTC() @dataclass(slots=True, frozen=True) class NMRBTC: + """ + name: NMRBTC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 10000000.00000000 + margin: True + """ name: str = "NMRBTC" precision: int = 8 minimum_margin: float = None @@ -30933,11 +43043,20 @@ def __call__(self): return "NMRBTC" -NMRBTC = NMRBTC() +NMRBUSD = NMRBUSD() @dataclass(slots=True, frozen=True) class NMRBUSD: + """ + name: NMRBUSD + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 90000.00000000 + margin: True + """ name: str = "NMRBUSD" precision: int = 8 minimum_margin: float = None @@ -30956,11 +43075,20 @@ def __call__(self): return "NMRBUSD" -NMRBUSD = NMRBUSD() +NMRUSDT = NMRUSDT() @dataclass(slots=True, frozen=True) class NMRUSDT: + """ + name: NMRUSDT + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 90000.00000000 + margin: True + """ name: str = "NMRUSDT" precision: int = 8 minimum_margin: float = None @@ -30979,11 +43107,20 @@ def __call__(self): return "NMRUSDT" -NMRUSDT = NMRUSDT() +NPXSBTC = NPXSBTC() @dataclass(slots=True, frozen=True) class NPXSBTC: + """ + name: NPXSBTC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 92141578.00000000 + margin: False + """ name: str = "NPXSBTC" precision: int = 8 minimum_margin: float = None @@ -31002,11 +43139,20 @@ def __call__(self): return "NPXSBTC" -NPXSBTC = NPXSBTC() +NPXSETH = NPXSETH() @dataclass(slots=True, frozen=True) class NPXSETH: + """ + name: NPXSETH + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 90000000.00000000 + margin: False + """ name: str = "NPXSETH" precision: int = 8 minimum_margin: float = None @@ -31025,11 +43171,20 @@ def __call__(self): return "NPXSETH" -NPXSETH = NPXSETH() +NPXSUSDC = NPXSUSDC() @dataclass(slots=True, frozen=True) class NPXSUSDC: + """ + name: NPXSUSDC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 90000000.00000000 + margin: False + """ name: str = "NPXSUSDC" precision: int = 8 minimum_margin: float = None @@ -31048,11 +43203,20 @@ def __call__(self): return "NPXSUSDC" -NPXSUSDC = NPXSUSDC() +NPXSUSDT = NPXSUSDT() @dataclass(slots=True, frozen=True) class NPXSUSDT: + """ + name: NPXSUSDT + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 92141578.00000000 + margin: False + """ name: str = "NPXSUSDT" precision: int = 8 minimum_margin: float = None @@ -31071,11 +43235,20 @@ def __call__(self): return "NPXSUSDT" -NPXSUSDT = NPXSUSDT() +NUAUD = NUAUD() @dataclass(slots=True, frozen=True) class NUAUD: + """ + name: NUAUD + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 92141578.00000000 + margin: False + """ name: str = "NUAUD" precision: int = 8 minimum_margin: float = None @@ -31094,11 +43267,20 @@ def __call__(self): return "NUAUD" -NUAUD = NUAUD() +NUBNB = NUBNB() @dataclass(slots=True, frozen=True) class NUBNB: + """ + name: NUBNB + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 92141578.00000000 + margin: False + """ name: str = "NUBNB" precision: int = 8 minimum_margin: float = None @@ -31117,11 +43299,20 @@ def __call__(self): return "NUBNB" -NUBNB = NUBNB() +NUBTC = NUBTC() @dataclass(slots=True, frozen=True) class NUBTC: + """ + name: NUBTC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 92141578.00000000 + margin: False + """ name: str = "NUBTC" precision: int = 8 minimum_margin: float = None @@ -31140,11 +43331,20 @@ def __call__(self): return "NUBTC" -NUBTC = NUBTC() +NUBUSD = NUBUSD() @dataclass(slots=True, frozen=True) class NUBUSD: + """ + name: NUBUSD + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 92141578.00000000 + margin: False + """ name: str = "NUBUSD" precision: int = 8 minimum_margin: float = None @@ -31163,11 +43363,20 @@ def __call__(self): return "NUBUSD" -NUBUSD = NUBUSD() +NULSBNB = NULSBNB() @dataclass(slots=True, frozen=True) class NULSBNB: + """ + name: NULSBNB + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 9000000.00000000 + margin: False + """ name: str = "NULSBNB" precision: int = 8 minimum_margin: float = None @@ -31186,11 +43395,20 @@ def __call__(self): return "NULSBNB" -NULSBNB = NULSBNB() +NULSBTC = NULSBTC() @dataclass(slots=True, frozen=True) class NULSBTC: + """ + name: NULSBTC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 90000000.00000000 + margin: True + """ name: str = "NULSBTC" precision: int = 8 minimum_margin: float = None @@ -31209,11 +43427,20 @@ def __call__(self): return "NULSBTC" -NULSBTC = NULSBTC() +NULSBUSD = NULSBUSD() @dataclass(slots=True, frozen=True) class NULSBUSD: + """ + name: NULSBUSD + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 92141578.00000000 + margin: True + """ name: str = "NULSBUSD" precision: int = 8 minimum_margin: float = None @@ -31232,11 +43459,20 @@ def __call__(self): return "NULSBUSD" -NULSBUSD = NULSBUSD() +NULSETH = NULSETH() @dataclass(slots=True, frozen=True) class NULSETH: + """ + name: NULSETH + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 90000000.00000000 + margin: False + """ name: str = "NULSETH" precision: int = 8 minimum_margin: float = None @@ -31255,11 +43491,20 @@ def __call__(self): return "NULSETH" -NULSETH = NULSETH() +NULSUSDT = NULSUSDT() @dataclass(slots=True, frozen=True) class NULSUSDT: + """ + name: NULSUSDT + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 900000.00000000 + margin: True + """ name: str = "NULSUSDT" precision: int = 8 minimum_margin: float = None @@ -31278,11 +43523,20 @@ def __call__(self): return "NULSUSDT" -NULSUSDT = NULSUSDT() +NURUB = NURUB() @dataclass(slots=True, frozen=True) class NURUB: + """ + name: NURUB + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 9222449.00000000 + margin: False + """ name: str = "NURUB" precision: int = 8 minimum_margin: float = None @@ -31301,11 +43555,20 @@ def __call__(self): return "NURUB" -NURUB = NURUB() +NUUSDT = NUUSDT() @dataclass(slots=True, frozen=True) class NUUSDT: + """ + name: NUUSDT + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 92141578.00000000 + margin: False + """ name: str = "NUUSDT" precision: int = 8 minimum_margin: float = None @@ -31324,11 +43587,20 @@ def __call__(self): return "NUUSDT" -NUUSDT = NUUSDT() +NXSBNB = NXSBNB() @dataclass(slots=True, frozen=True) class NXSBNB: + """ + name: NXSBNB + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 9000000.00000000 + margin: False + """ name: str = "NXSBNB" precision: int = 8 minimum_margin: float = None @@ -31347,11 +43619,20 @@ def __call__(self): return "NXSBNB" -NXSBNB = NXSBNB() +NXSBTC = NXSBTC() @dataclass(slots=True, frozen=True) class NXSBTC: + """ + name: NXSBTC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 90000000.00000000 + margin: False + """ name: str = "NXSBTC" precision: int = 8 minimum_margin: float = None @@ -31370,11 +43651,20 @@ def __call__(self): return "NXSBTC" -NXSBTC = NXSBTC() +NXSETH = NXSETH() @dataclass(slots=True, frozen=True) class NXSETH: + """ + name: NXSETH + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 90000000.00000000 + margin: False + """ name: str = "NXSETH" precision: int = 8 minimum_margin: float = None @@ -31393,11 +43683,20 @@ def __call__(self): return "NXSETH" -NXSETH = NXSETH() +OAXBTC = OAXBTC() @dataclass(slots=True, frozen=True) class OAXBTC: + """ + name: OAXBTC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 90000000.00000000 + margin: False + """ name: str = "OAXBTC" precision: int = 8 minimum_margin: float = None @@ -31416,11 +43715,20 @@ def __call__(self): return "OAXBTC" -OAXBTC = OAXBTC() +OAXETH = OAXETH() @dataclass(slots=True, frozen=True) class OAXETH: + """ + name: OAXETH + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 90000000.00000000 + margin: False + """ name: str = "OAXETH" precision: int = 8 minimum_margin: float = None @@ -31439,11 +43747,20 @@ def __call__(self): return "OAXETH" -OAXETH = OAXETH() +OCEANBNB = OCEANBNB() @dataclass(slots=True, frozen=True) class OCEANBNB: + """ + name: OCEANBNB + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 9000000.00000000 + margin: False + """ name: str = "OCEANBNB" precision: int = 8 minimum_margin: float = None @@ -31462,11 +43779,20 @@ def __call__(self): return "OCEANBNB" -OCEANBNB = OCEANBNB() +OCEANBTC = OCEANBTC() @dataclass(slots=True, frozen=True) class OCEANBTC: + """ + name: OCEANBTC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 90000000.00000000 + margin: True + """ name: str = "OCEANBTC" precision: int = 8 minimum_margin: float = None @@ -31485,11 +43811,20 @@ def __call__(self): return "OCEANBTC" -OCEANBTC = OCEANBTC() +OCEANBUSD = OCEANBUSD() @dataclass(slots=True, frozen=True) class OCEANBUSD: + """ + name: OCEANBUSD + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 900000.00000000 + margin: False + """ name: str = "OCEANBUSD" precision: int = 8 minimum_margin: float = None @@ -31508,11 +43843,20 @@ def __call__(self): return "OCEANBUSD" -OCEANBUSD = OCEANBUSD() +OCEANUSDT = OCEANUSDT() @dataclass(slots=True, frozen=True) class OCEANUSDT: + """ + name: OCEANUSDT + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 900000.00000000 + margin: True + """ name: str = "OCEANUSDT" precision: int = 8 minimum_margin: float = None @@ -31531,11 +43875,20 @@ def __call__(self): return "OCEANUSDT" -OCEANUSDT = OCEANUSDT() +OGBTC = OGBTC() @dataclass(slots=True, frozen=True) class OGBTC: + """ + name: OGBTC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 90000000.00000000 + margin: False + """ name: str = "OGBTC" precision: int = 8 minimum_margin: float = None @@ -31554,11 +43907,20 @@ def __call__(self): return "OGBTC" -OGBTC = OGBTC() +OGBUSD = OGBUSD() @dataclass(slots=True, frozen=True) class OGBUSD: + """ + name: OGBUSD + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 90000.00000000 + margin: False + """ name: str = "OGBUSD" precision: int = 8 minimum_margin: float = None @@ -31577,11 +43939,20 @@ def __call__(self): return "OGBUSD" -OGBUSD = OGBUSD() +OGNBNB = OGNBNB() @dataclass(slots=True, frozen=True) class OGNBNB: + """ + name: OGNBNB + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 9000000.00000000 + margin: False + """ name: str = "OGNBNB" precision: int = 8 minimum_margin: float = None @@ -31600,11 +43971,20 @@ def __call__(self): return "OGNBNB" -OGNBNB = OGNBNB() +OGNBTC = OGNBTC() @dataclass(slots=True, frozen=True) class OGNBTC: + """ + name: OGNBTC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 90000000.00000000 + margin: True + """ name: str = "OGNBTC" precision: int = 8 minimum_margin: float = None @@ -31623,11 +44003,20 @@ def __call__(self): return "OGNBTC" -OGNBTC = OGNBTC() +OGNBUSD = OGNBUSD() @dataclass(slots=True, frozen=True) class OGNBUSD: + """ + name: OGNBUSD + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 92141578.00000000 + margin: True + """ name: str = "OGNBUSD" precision: int = 8 minimum_margin: float = None @@ -31646,11 +44035,20 @@ def __call__(self): return "OGNBUSD" -OGNBUSD = OGNBUSD() +OGNUSDT = OGNUSDT() @dataclass(slots=True, frozen=True) class OGNUSDT: + """ + name: OGNUSDT + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 900000.00000000 + margin: True + """ name: str = "OGNUSDT" precision: int = 8 minimum_margin: float = None @@ -31669,11 +44067,20 @@ def __call__(self): return "OGNUSDT" -OGNUSDT = OGNUSDT() +OGUSDT = OGUSDT() @dataclass(slots=True, frozen=True) class OGUSDT: + """ + name: OGUSDT + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 90000.00000000 + margin: False + """ name: str = "OGUSDT" precision: int = 8 minimum_margin: float = None @@ -31692,11 +44099,20 @@ def __call__(self): return "OGUSDT" -OGUSDT = OGUSDT() +OMBTC = OMBTC() @dataclass(slots=True, frozen=True) class OMBTC: + """ + name: OMBTC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 90000000.00000000 + margin: True + """ name: str = "OMBTC" precision: int = 8 minimum_margin: float = None @@ -31715,11 +44131,20 @@ def __call__(self): return "OMBTC" -OMBTC = OMBTC() +OMBUSD = OMBUSD() @dataclass(slots=True, frozen=True) class OMBUSD: + """ + name: OMBUSD + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 9222449.00000000 + margin: True + """ name: str = "OMBUSD" precision: int = 8 minimum_margin: float = None @@ -31738,11 +44163,20 @@ def __call__(self): return "OMBUSD" -OMBUSD = OMBUSD() +OMGBNB = OMGBNB() @dataclass(slots=True, frozen=True) class OMGBNB: + """ + name: OMGBNB + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 9000000.00000000 + margin: False + """ name: str = "OMGBNB" precision: int = 8 minimum_margin: float = None @@ -31761,11 +44195,20 @@ def __call__(self): return "OMGBNB" -OMGBNB = OMGBNB() +OMGBTC = OMGBTC() @dataclass(slots=True, frozen=True) class OMGBTC: + """ + name: OMGBTC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 90000000.00000000 + margin: False + """ name: str = "OMGBTC" precision: int = 8 minimum_margin: float = None @@ -31784,11 +44227,20 @@ def __call__(self): return "OMGBTC" -OMGBTC = OMGBTC() +OMGBUSD = OMGBUSD() @dataclass(slots=True, frozen=True) class OMGBUSD: + """ + name: OMGBUSD + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 900000.00000000 + margin: False + """ name: str = "OMGBUSD" precision: int = 8 minimum_margin: float = None @@ -31807,11 +44259,20 @@ def __call__(self): return "OMGBUSD" -OMGBUSD = OMGBUSD() +OMGETH = OMGETH() @dataclass(slots=True, frozen=True) class OMGETH: + """ + name: OMGETH + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 90000000.00000000 + margin: False + """ name: str = "OMGETH" precision: int = 8 minimum_margin: float = None @@ -31830,11 +44291,20 @@ def __call__(self): return "OMGETH" -OMGETH = OMGETH() +OMGUSDT = OMGUSDT() @dataclass(slots=True, frozen=True) class OMGUSDT: + """ + name: OMGUSDT + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 900000.00000000 + margin: False + """ name: str = "OMGUSDT" precision: int = 8 minimum_margin: float = None @@ -31853,11 +44323,20 @@ def __call__(self): return "OMGUSDT" -OMGUSDT = OMGUSDT() +OMUSDT = OMUSDT() @dataclass(slots=True, frozen=True) class OMUSDT: + """ + name: OMUSDT + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 9222449.00000000 + margin: True + """ name: str = "OMUSDT" precision: int = 8 minimum_margin: float = None @@ -31876,11 +44355,20 @@ def __call__(self): return "OMUSDT" -OMUSDT = OMUSDT() +ONEBIDR = ONEBIDR() @dataclass(slots=True, frozen=True) class ONEBIDR: + """ + name: ONEBIDR + precision: 2 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 90000000.00000000 + margin: False + """ name: str = "ONEBIDR" precision: int = 2 minimum_margin: float = None @@ -31899,11 +44387,20 @@ def __call__(self): return "ONEBIDR" -ONEBIDR = ONEBIDR() +ONEBNB = ONEBNB() @dataclass(slots=True, frozen=True) class ONEBNB: + """ + name: ONEBNB + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 9000000.00000000 + margin: False + """ name: str = "ONEBNB" precision: int = 8 minimum_margin: float = None @@ -31922,11 +44419,20 @@ def __call__(self): return "ONEBNB" -ONEBNB = ONEBNB() +ONEBTC = ONEBTC() @dataclass(slots=True, frozen=True) class ONEBTC: + """ + name: ONEBTC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 90000000.00000000 + margin: True + """ name: str = "ONEBTC" precision: int = 8 minimum_margin: float = None @@ -31945,11 +44451,20 @@ def __call__(self): return "ONEBTC" -ONEBTC = ONEBTC() +ONEBUSD = ONEBUSD() @dataclass(slots=True, frozen=True) class ONEBUSD: + """ + name: ONEBUSD + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 9000000.00000000 + margin: True + """ name: str = "ONEBUSD" precision: int = 8 minimum_margin: float = None @@ -31968,11 +44483,20 @@ def __call__(self): return "ONEBUSD" -ONEBUSD = ONEBUSD() +ONEETH = ONEETH() @dataclass(slots=True, frozen=True) class ONEETH: + """ + name: ONEETH + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 92141578.00000000 + margin: False + """ name: str = "ONEETH" precision: int = 8 minimum_margin: float = None @@ -31991,11 +44515,20 @@ def __call__(self): return "ONEETH" -ONEETH = ONEETH() +ONEPAX = ONEPAX() @dataclass(slots=True, frozen=True) class ONEPAX: + """ + name: ONEPAX + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 9000000.00000000 + margin: False + """ name: str = "ONEPAX" precision: int = 8 minimum_margin: float = None @@ -32014,11 +44547,20 @@ def __call__(self): return "ONEPAX" -ONEPAX = ONEPAX() +ONETRY = ONETRY() @dataclass(slots=True, frozen=True) class ONETRY: + """ + name: ONETRY + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 92141578.00000000 + margin: False + """ name: str = "ONETRY" precision: int = 8 minimum_margin: float = None @@ -32037,11 +44579,20 @@ def __call__(self): return "ONETRY" -ONETRY = ONETRY() +ONETUSD = ONETUSD() @dataclass(slots=True, frozen=True) class ONETUSD: + """ + name: ONETUSD + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 9000000.00000000 + margin: False + """ name: str = "ONETUSD" precision: int = 8 minimum_margin: float = None @@ -32060,11 +44611,20 @@ def __call__(self): return "ONETUSD" -ONETUSD = ONETUSD() +ONEUSDC = ONEUSDC() @dataclass(slots=True, frozen=True) class ONEUSDC: + """ + name: ONEUSDC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 9000000.00000000 + margin: False + """ name: str = "ONEUSDC" precision: int = 8 minimum_margin: float = None @@ -32083,11 +44643,20 @@ def __call__(self): return "ONEUSDC" -ONEUSDC = ONEUSDC() +ONEUSDT = ONEUSDT() @dataclass(slots=True, frozen=True) class ONEUSDT: + """ + name: ONEUSDT + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 9000000.00000000 + margin: True + """ name: str = "ONEUSDT" precision: int = 8 minimum_margin: float = None @@ -32106,11 +44675,20 @@ def __call__(self): return "ONEUSDT" -ONEUSDT = ONEUSDT() +ONGBNB = ONGBNB() @dataclass(slots=True, frozen=True) class ONGBNB: + """ + name: ONGBNB + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 9000000.00000000 + margin: False + """ name: str = "ONGBNB" precision: int = 8 minimum_margin: float = None @@ -32129,11 +44707,20 @@ def __call__(self): return "ONGBNB" -ONGBNB = ONGBNB() +ONGBTC = ONGBTC() @dataclass(slots=True, frozen=True) class ONGBTC: + """ + name: ONGBTC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 90000000.00000000 + margin: False + """ name: str = "ONGBTC" precision: int = 8 minimum_margin: float = None @@ -32152,11 +44739,20 @@ def __call__(self): return "ONGBTC" -ONGBTC = ONGBTC() +ONGUSDT = ONGUSDT() @dataclass(slots=True, frozen=True) class ONGUSDT: + """ + name: ONGUSDT + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 900000.00000000 + margin: False + """ name: str = "ONGUSDT" precision: int = 8 minimum_margin: float = None @@ -32175,11 +44771,20 @@ def __call__(self): return "ONGUSDT" -ONGUSDT = ONGUSDT() +ONTBNB = ONTBNB() @dataclass(slots=True, frozen=True) class ONTBNB: + """ + name: ONTBNB + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 9000000.00000000 + margin: False + """ name: str = "ONTBNB" precision: int = 8 minimum_margin: float = None @@ -32198,11 +44803,20 @@ def __call__(self): return "ONTBNB" -ONTBNB = ONTBNB() +ONTBTC = ONTBTC() @dataclass(slots=True, frozen=True) class ONTBTC: + """ + name: ONTBTC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 9000000.00000000 + margin: True + """ name: str = "ONTBTC" precision: int = 8 minimum_margin: float = None @@ -32221,11 +44835,20 @@ def __call__(self): return "ONTBTC" -ONTBTC = ONTBTC() +ONTBUSD = ONTBUSD() @dataclass(slots=True, frozen=True) class ONTBUSD: + """ + name: ONTBUSD + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 900000.00000000 + margin: True + """ name: str = "ONTBUSD" precision: int = 8 minimum_margin: float = None @@ -32244,11 +44867,20 @@ def __call__(self): return "ONTBUSD" -ONTBUSD = ONTBUSD() +ONTETH = ONTETH() @dataclass(slots=True, frozen=True) class ONTETH: + """ + name: ONTETH + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 90000000.00000000 + margin: False + """ name: str = "ONTETH" precision: int = 8 minimum_margin: float = None @@ -32267,11 +44899,20 @@ def __call__(self): return "ONTETH" -ONTETH = ONTETH() +ONTPAX = ONTPAX() @dataclass(slots=True, frozen=True) class ONTPAX: + """ + name: ONTPAX + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 900000.00000000 + margin: False + """ name: str = "ONTPAX" precision: int = 8 minimum_margin: float = None @@ -32290,11 +44931,20 @@ def __call__(self): return "ONTPAX" -ONTPAX = ONTPAX() +ONTTRY = ONTTRY() @dataclass(slots=True, frozen=True) class ONTTRY: + """ + name: ONTTRY + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 92141578.00000000 + margin: False + """ name: str = "ONTTRY" precision: int = 8 minimum_margin: float = None @@ -32313,11 +44963,20 @@ def __call__(self): return "ONTTRY" -ONTTRY = ONTTRY() +ONTUSDC = ONTUSDC() @dataclass(slots=True, frozen=True) class ONTUSDC: + """ + name: ONTUSDC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 900000.00000000 + margin: False + """ name: str = "ONTUSDC" precision: int = 8 minimum_margin: float = None @@ -32336,11 +44995,20 @@ def __call__(self): return "ONTUSDC" -ONTUSDC = ONTUSDC() +ONTUSDT = ONTUSDT() @dataclass(slots=True, frozen=True) class ONTUSDT: + """ + name: ONTUSDT + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 900000.00000000 + margin: True + """ name: str = "ONTUSDT" precision: int = 8 minimum_margin: float = None @@ -32359,11 +45027,20 @@ def __call__(self): return "ONTUSDT" -ONTUSDT = ONTUSDT() +OOKIBNB = OOKIBNB() @dataclass(slots=True, frozen=True) class OOKIBNB: + """ + name: OOKIBNB + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 92141578.00000000 + margin: False + """ name: str = "OOKIBNB" precision: int = 8 minimum_margin: float = None @@ -32382,11 +45059,20 @@ def __call__(self): return "OOKIBNB" -OOKIBNB = OOKIBNB() +OOKIBUSD = OOKIBUSD() @dataclass(slots=True, frozen=True) class OOKIBUSD: + """ + name: OOKIBUSD + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 92141578.00000000 + margin: False + """ name: str = "OOKIBUSD" precision: int = 8 minimum_margin: float = None @@ -32405,11 +45091,20 @@ def __call__(self): return "OOKIBUSD" -OOKIBUSD = OOKIBUSD() +OOKIETH = OOKIETH() @dataclass(slots=True, frozen=True) class OOKIETH: + """ + name: OOKIETH + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 92141578.00000000 + margin: False + """ name: str = "OOKIETH" precision: int = 8 minimum_margin: float = None @@ -32428,11 +45123,20 @@ def __call__(self): return "OOKIETH" -OOKIETH = OOKIETH() +OOKIUSDT = OOKIUSDT() @dataclass(slots=True, frozen=True) class OOKIUSDT: + """ + name: OOKIUSDT + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 92141578.00000000 + margin: False + """ name: str = "OOKIUSDT" precision: int = 8 minimum_margin: float = None @@ -32451,11 +45155,20 @@ def __call__(self): return "OOKIUSDT" -OOKIUSDT = OOKIUSDT() +OPBNB = OPBNB() @dataclass(slots=True, frozen=True) class OPBNB: + """ + name: OPBNB + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 92141578.00000000 + margin: False + """ name: str = "OPBNB" precision: int = 8 minimum_margin: float = None @@ -32474,11 +45187,20 @@ def __call__(self): return "OPBNB" -OPBNB = OPBNB() +OPBTC = OPBTC() @dataclass(slots=True, frozen=True) class OPBTC: + """ + name: OPBTC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 92141578.00000000 + margin: False + """ name: str = "OPBTC" precision: int = 8 minimum_margin: float = None @@ -32497,11 +45219,20 @@ def __call__(self): return "OPBTC" -OPBTC = OPBTC() +OPBUSD = OPBUSD() @dataclass(slots=True, frozen=True) class OPBUSD: + """ + name: OPBUSD + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 92141578.00000000 + margin: True + """ name: str = "OPBUSD" precision: int = 8 minimum_margin: float = None @@ -32520,11 +45251,20 @@ def __call__(self): return "OPBUSD" -OPBUSD = OPBUSD() +OPETH = OPETH() @dataclass(slots=True, frozen=True) class OPETH: + """ + name: OPETH + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 913205152.00000000 + margin: False + """ name: str = "OPETH" precision: int = 8 minimum_margin: float = None @@ -32543,11 +45283,20 @@ def __call__(self): return "OPETH" -OPETH = OPETH() +OPEUR = OPEUR() @dataclass(slots=True, frozen=True) class OPEUR: + """ + name: OPEUR + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 92141578.00000000 + margin: False + """ name: str = "OPEUR" precision: int = 8 minimum_margin: float = None @@ -32566,11 +45315,20 @@ def __call__(self): return "OPEUR" -OPEUR = OPEUR() +OPUSDT = OPUSDT() @dataclass(slots=True, frozen=True) class OPUSDT: + """ + name: OPUSDT + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 92141578.00000000 + margin: True + """ name: str = "OPUSDT" precision: int = 8 minimum_margin: float = None @@ -32589,11 +45347,20 @@ def __call__(self): return "OPUSDT" -OPUSDT = OPUSDT() +ORNBTC = ORNBTC() @dataclass(slots=True, frozen=True) class ORNBTC: + """ + name: ORNBTC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 90000000.00000000 + margin: True + """ name: str = "ORNBTC" precision: int = 8 minimum_margin: float = None @@ -32612,11 +45379,20 @@ def __call__(self): return "ORNBTC" -ORNBTC = ORNBTC() +ORNBUSD = ORNBUSD() @dataclass(slots=True, frozen=True) class ORNBUSD: + """ + name: ORNBUSD + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 9222449.00000000 + margin: False + """ name: str = "ORNBUSD" precision: int = 8 minimum_margin: float = None @@ -32635,11 +45411,20 @@ def __call__(self): return "ORNBUSD" -ORNBUSD = ORNBUSD() +ORNUSDT = ORNUSDT() @dataclass(slots=True, frozen=True) class ORNUSDT: + """ + name: ORNUSDT + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 90000.00000000 + margin: True + """ name: str = "ORNUSDT" precision: int = 8 minimum_margin: float = None @@ -32658,11 +45443,20 @@ def __call__(self): return "ORNUSDT" -ORNUSDT = ORNUSDT() +OSMOBTC = OSMOBTC() @dataclass(slots=True, frozen=True) class OSMOBTC: + """ + name: OSMOBTC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 8384883677.00000000 + margin: False + """ name: str = "OSMOBTC" precision: int = 8 minimum_margin: float = None @@ -32681,11 +45475,20 @@ def __call__(self): return "OSMOBTC" -OSMOBTC = OSMOBTC() +OSMOBUSD = OSMOBUSD() @dataclass(slots=True, frozen=True) class OSMOBUSD: + """ + name: OSMOBUSD + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 92141578.00000000 + margin: True + """ name: str = "OSMOBUSD" precision: int = 8 minimum_margin: float = None @@ -32704,11 +45507,20 @@ def __call__(self): return "OSMOBUSD" -OSMOBUSD = OSMOBUSD() +OSMOUSDT = OSMOUSDT() @dataclass(slots=True, frozen=True) class OSMOUSDT: + """ + name: OSMOUSDT + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 92141578.00000000 + margin: True + """ name: str = "OSMOUSDT" precision: int = 8 minimum_margin: float = None @@ -32727,11 +45539,20 @@ def __call__(self): return "OSMOUSDT" -OSMOUSDT = OSMOUSDT() +OSTBNB = OSTBNB() @dataclass(slots=True, frozen=True) class OSTBNB: + """ + name: OSTBNB + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 9000000.00000000 + margin: False + """ name: str = "OSTBNB" precision: int = 8 minimum_margin: float = None @@ -32750,11 +45571,20 @@ def __call__(self): return "OSTBNB" -OSTBNB = OSTBNB() +OSTBTC = OSTBTC() @dataclass(slots=True, frozen=True) class OSTBTC: + """ + name: OSTBTC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 90000000.00000000 + margin: False + """ name: str = "OSTBTC" precision: int = 8 minimum_margin: float = None @@ -32773,11 +45603,20 @@ def __call__(self): return "OSTBTC" -OSTBTC = OSTBTC() +OSTETH = OSTETH() @dataclass(slots=True, frozen=True) class OSTETH: + """ + name: OSTETH + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 90000000.00000000 + margin: False + """ name: str = "OSTETH" precision: int = 8 minimum_margin: float = None @@ -32796,11 +45635,20 @@ def __call__(self): return "OSTETH" -OSTETH = OSTETH() +OXTBTC = OXTBTC() @dataclass(slots=True, frozen=True) class OXTBTC: + """ + name: OXTBTC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 90000000.00000000 + margin: True + """ name: str = "OXTBTC" precision: int = 8 minimum_margin: float = None @@ -32819,11 +45667,20 @@ def __call__(self): return "OXTBTC" -OXTBTC = OXTBTC() +OXTBUSD = OXTBUSD() @dataclass(slots=True, frozen=True) class OXTBUSD: + """ + name: OXTBUSD + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 922327.00000000 + margin: False + """ name: str = "OXTBUSD" precision: int = 8 minimum_margin: float = None @@ -32842,11 +45699,20 @@ def __call__(self): return "OXTBUSD" -OXTBUSD = OXTBUSD() +OXTUSDT = OXTUSDT() @dataclass(slots=True, frozen=True) class OXTUSDT: + """ + name: OXTUSDT + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 900000.00000000 + margin: True + """ name: str = "OXTUSDT" precision: int = 8 minimum_margin: float = None @@ -32865,11 +45731,20 @@ def __call__(self): return "OXTUSDT" -OXTUSDT = OXTUSDT() +PAXBNB = PAXBNB() @dataclass(slots=True, frozen=True) class PAXBNB: + """ + name: PAXBNB + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 9000000.00000000 + margin: False + """ name: str = "PAXBNB" precision: int = 8 minimum_margin: float = None @@ -32888,11 +45763,20 @@ def __call__(self): return "PAXBNB" -PAXBNB = PAXBNB() +PAXBTC = PAXBTC() @dataclass(slots=True, frozen=True) class PAXBTC: + """ + name: PAXBTC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 90000000.00000000 + margin: False + """ name: str = "PAXBTC" precision: int = 8 minimum_margin: float = None @@ -32911,11 +45795,20 @@ def __call__(self): return "PAXBTC" -PAXBTC = PAXBTC() +PAXBUSD = PAXBUSD() @dataclass(slots=True, frozen=True) class PAXBUSD: + """ + name: PAXBUSD + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 900000.00000000 + margin: False + """ name: str = "PAXBUSD" precision: int = 8 minimum_margin: float = None @@ -32934,11 +45827,20 @@ def __call__(self): return "PAXBUSD" -PAXBUSD = PAXBUSD() +PAXETH = PAXETH() @dataclass(slots=True, frozen=True) class PAXETH: + """ + name: PAXETH + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 90000000.00000000 + margin: False + """ name: str = "PAXETH" precision: int = 8 minimum_margin: float = None @@ -32957,11 +45859,20 @@ def __call__(self): return "PAXETH" -PAXETH = PAXETH() +PAXGBNB = PAXGBNB() @dataclass(slots=True, frozen=True) class PAXGBNB: + """ + name: PAXGBNB + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.00010000 + maximum_order_size: 900000.00000000 + margin: False + """ name: str = "PAXGBNB" precision: int = 8 minimum_margin: float = None @@ -32980,11 +45891,20 @@ def __call__(self): return "PAXGBNB" -PAXGBNB = PAXGBNB() +PAXGBTC = PAXGBTC() @dataclass(slots=True, frozen=True) class PAXGBTC: + """ + name: PAXGBTC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.00010000 + maximum_order_size: 9222449.00000000 + margin: False + """ name: str = "PAXGBTC" precision: int = 8 minimum_margin: float = None @@ -33003,11 +45923,20 @@ def __call__(self): return "PAXGBTC" -PAXGBTC = PAXGBTC() +PAXGBUSD = PAXGBUSD() @dataclass(slots=True, frozen=True) class PAXGBUSD: + """ + name: PAXGBUSD + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.00010000 + maximum_order_size: 9000.00000000 + margin: True + """ name: str = "PAXGBUSD" precision: int = 8 minimum_margin: float = None @@ -33026,11 +45955,20 @@ def __call__(self): return "PAXGBUSD" -PAXGBUSD = PAXGBUSD() +PAXGUSDT = PAXGUSDT() @dataclass(slots=True, frozen=True) class PAXGUSDT: + """ + name: PAXGUSDT + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.00010000 + maximum_order_size: 9000.00000000 + margin: True + """ name: str = "PAXGUSDT" precision: int = 8 minimum_margin: float = None @@ -33049,11 +45987,20 @@ def __call__(self): return "PAXGUSDT" -PAXGUSDT = PAXGUSDT() +PAXTUSD = PAXTUSD() @dataclass(slots=True, frozen=True) class PAXTUSD: + """ + name: PAXTUSD + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 900000.00000000 + margin: False + """ name: str = "PAXTUSD" precision: int = 8 minimum_margin: float = None @@ -33072,11 +46019,20 @@ def __call__(self): return "PAXTUSD" -PAXTUSD = PAXTUSD() +PAXUSDT = PAXUSDT() @dataclass(slots=True, frozen=True) class PAXUSDT: + """ + name: PAXUSDT + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 900000.00000000 + margin: False + """ name: str = "PAXUSDT" precision: int = 8 minimum_margin: float = None @@ -33095,11 +46051,20 @@ def __call__(self): return "PAXUSDT" -PAXUSDT = PAXUSDT() +PEOPLEBNB = PEOPLEBNB() @dataclass(slots=True, frozen=True) class PEOPLEBNB: + """ + name: PEOPLEBNB + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 92141578.00000000 + margin: False + """ name: str = "PEOPLEBNB" precision: int = 8 minimum_margin: float = None @@ -33118,11 +46083,20 @@ def __call__(self): return "PEOPLEBNB" -PEOPLEBNB = PEOPLEBNB() +PEOPLEBTC = PEOPLEBTC() @dataclass(slots=True, frozen=True) class PEOPLEBTC: + """ + name: PEOPLEBTC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 92141578.00000000 + margin: True + """ name: str = "PEOPLEBTC" precision: int = 8 minimum_margin: float = None @@ -33141,11 +46115,20 @@ def __call__(self): return "PEOPLEBTC" -PEOPLEBTC = PEOPLEBTC() +PEOPLEBUSD = PEOPLEBUSD() @dataclass(slots=True, frozen=True) class PEOPLEBUSD: + """ + name: PEOPLEBUSD + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 92141578.00000000 + margin: True + """ name: str = "PEOPLEBUSD" precision: int = 8 minimum_margin: float = None @@ -33164,11 +46147,20 @@ def __call__(self): return "PEOPLEBUSD" -PEOPLEBUSD = PEOPLEBUSD() +PEOPLEETH = PEOPLEETH() @dataclass(slots=True, frozen=True) class PEOPLEETH: + """ + name: PEOPLEETH + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 92141578.00000000 + margin: False + """ name: str = "PEOPLEETH" precision: int = 8 minimum_margin: float = None @@ -33187,11 +46179,20 @@ def __call__(self): return "PEOPLEETH" -PEOPLEETH = PEOPLEETH() +PEOPLEUSDT = PEOPLEUSDT() @dataclass(slots=True, frozen=True) class PEOPLEUSDT: + """ + name: PEOPLEUSDT + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 92141578.00000000 + margin: True + """ name: str = "PEOPLEUSDT" precision: int = 8 minimum_margin: float = None @@ -33210,11 +46211,20 @@ def __call__(self): return "PEOPLEUSDT" -PEOPLEUSDT = PEOPLEUSDT() +PERLBNB = PERLBNB() @dataclass(slots=True, frozen=True) class PERLBNB: + """ + name: PERLBNB + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 9000000.00000000 + margin: False + """ name: str = "PERLBNB" precision: int = 8 minimum_margin: float = None @@ -33233,11 +46243,20 @@ def __call__(self): return "PERLBNB" -PERLBNB = PERLBNB() +PERLBTC = PERLBTC() @dataclass(slots=True, frozen=True) class PERLBTC: + """ + name: PERLBTC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 90000000.00000000 + margin: False + """ name: str = "PERLBTC" precision: int = 8 minimum_margin: float = None @@ -33256,11 +46275,20 @@ def __call__(self): return "PERLBTC" -PERLBTC = PERLBTC() +PERLUSDC = PERLUSDC() @dataclass(slots=True, frozen=True) class PERLUSDC: + """ + name: PERLUSDC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 9000000.00000000 + margin: False + """ name: str = "PERLUSDC" precision: int = 8 minimum_margin: float = None @@ -33279,11 +46307,20 @@ def __call__(self): return "PERLUSDC" -PERLUSDC = PERLUSDC() +PERLUSDT = PERLUSDT() @dataclass(slots=True, frozen=True) class PERLUSDT: + """ + name: PERLUSDT + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 9000000.00000000 + margin: False + """ name: str = "PERLUSDT" precision: int = 8 minimum_margin: float = None @@ -33302,11 +46339,20 @@ def __call__(self): return "PERLUSDT" -PERLUSDT = PERLUSDT() +PERPBTC = PERPBTC() @dataclass(slots=True, frozen=True) class PERPBTC: + """ + name: PERPBTC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 90000000.00000000 + margin: False + """ name: str = "PERPBTC" precision: int = 8 minimum_margin: float = None @@ -33325,11 +46371,20 @@ def __call__(self): return "PERPBTC" -PERPBTC = PERPBTC() +PERPBUSD = PERPBUSD() @dataclass(slots=True, frozen=True) class PERPBUSD: + """ + name: PERPBUSD + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 90000.00000000 + margin: False + """ name: str = "PERPBUSD" precision: int = 8 minimum_margin: float = None @@ -33348,11 +46403,20 @@ def __call__(self): return "PERPBUSD" -PERPBUSD = PERPBUSD() +PERPUSDT = PERPUSDT() @dataclass(slots=True, frozen=True) class PERPUSDT: + """ + name: PERPUSDT + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 90000.00000000 + margin: False + """ name: str = "PERPUSDT" precision: int = 8 minimum_margin: float = None @@ -33371,11 +46435,20 @@ def __call__(self): return "PERPUSDT" -PERPUSDT = PERPUSDT() +PHABTC = PHABTC() @dataclass(slots=True, frozen=True) class PHABTC: + """ + name: PHABTC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 90000000.00000000 + margin: False + """ name: str = "PHABTC" precision: int = 8 minimum_margin: float = None @@ -33394,11 +46467,20 @@ def __call__(self): return "PHABTC" -PHABTC = PHABTC() +PHABUSD = PHABUSD() @dataclass(slots=True, frozen=True) class PHABUSD: + """ + name: PHABUSD + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 900000.00000000 + margin: True + """ name: str = "PHABUSD" precision: int = 8 minimum_margin: float = None @@ -33417,11 +46499,20 @@ def __call__(self): return "PHABUSD" -PHABUSD = PHABUSD() +PHAUSDT = PHAUSDT() @dataclass(slots=True, frozen=True) class PHAUSDT: + """ + name: PHAUSDT + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 92141578.00000000 + margin: True + """ name: str = "PHAUSDT" precision: int = 8 minimum_margin: float = None @@ -33440,11 +46531,20 @@ def __call__(self): return "PHAUSDT" -PHAUSDT = PHAUSDT() +PHBBNB = PHBBNB() @dataclass(slots=True, frozen=True) class PHBBNB: + """ + name: PHBBNB + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 9000000.00000000 + margin: False + """ name: str = "PHBBNB" precision: int = 8 minimum_margin: float = None @@ -33463,11 +46563,20 @@ def __call__(self): return "PHBBNB" -PHBBNB = PHBBNB() +PHBBTC = PHBBTC() @dataclass(slots=True, frozen=True) class PHBBTC: + """ + name: PHBBTC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 92141578.00000000 + margin: False + """ name: str = "PHBBTC" precision: int = 8 minimum_margin: float = None @@ -33486,11 +46595,20 @@ def __call__(self): return "PHBBTC" -PHBBTC = PHBBTC() +PHBBUSD = PHBBUSD() @dataclass(slots=True, frozen=True) class PHBBUSD: + """ + name: PHBBUSD + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 92141578.00000000 + margin: True + """ name: str = "PHBBUSD" precision: int = 8 minimum_margin: float = None @@ -33509,11 +46627,20 @@ def __call__(self): return "PHBBUSD" -PHBBUSD = PHBBUSD() +PHBPAX = PHBPAX() @dataclass(slots=True, frozen=True) class PHBPAX: + """ + name: PHBPAX + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 9000000.00000000 + margin: False + """ name: str = "PHBPAX" precision: int = 8 minimum_margin: float = None @@ -33532,11 +46659,20 @@ def __call__(self): return "PHBPAX" -PHBPAX = PHBPAX() +PHBTUSD = PHBTUSD() @dataclass(slots=True, frozen=True) class PHBTUSD: + """ + name: PHBTUSD + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 92141578.00000000 + margin: False + """ name: str = "PHBTUSD" precision: int = 8 minimum_margin: float = None @@ -33555,11 +46691,20 @@ def __call__(self): return "PHBTUSD" -PHBTUSD = PHBTUSD() +PHBUSDC = PHBUSDC() @dataclass(slots=True, frozen=True) class PHBUSDC: + """ + name: PHBUSDC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 9000000.00000000 + margin: False + """ name: str = "PHBUSDC" precision: int = 8 minimum_margin: float = None @@ -33578,11 +46723,20 @@ def __call__(self): return "PHBUSDC" -PHBUSDC = PHBUSDC() +PHBUSDT = PHBUSDT() @dataclass(slots=True, frozen=True) class PHBUSDT: + """ + name: PHBUSDT + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 92141578.00000000 + margin: False + """ name: str = "PHBUSDT" precision: int = 8 minimum_margin: float = None @@ -33601,11 +46755,20 @@ def __call__(self): return "PHBUSDT" -PHBUSDT = PHBUSDT() +PHXBNB = PHXBNB() @dataclass(slots=True, frozen=True) class PHXBNB: + """ + name: PHXBNB + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 9000000.00000000 + margin: False + """ name: str = "PHXBNB" precision: int = 8 minimum_margin: float = None @@ -33624,11 +46787,20 @@ def __call__(self): return "PHXBNB" -PHXBNB = PHXBNB() +PHXBTC = PHXBTC() @dataclass(slots=True, frozen=True) class PHXBTC: + """ + name: PHXBTC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 90000000.00000000 + margin: False + """ name: str = "PHXBTC" precision: int = 8 minimum_margin: float = None @@ -33647,11 +46819,20 @@ def __call__(self): return "PHXBTC" -PHXBTC = PHXBTC() +PHXETH = PHXETH() @dataclass(slots=True, frozen=True) class PHXETH: + """ + name: PHXETH + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 90000000.00000000 + margin: False + """ name: str = "PHXETH" precision: int = 8 minimum_margin: float = None @@ -33670,11 +46851,20 @@ def __call__(self): return "PHXETH" -PHXETH = PHXETH() +PIVXBNB = PIVXBNB() @dataclass(slots=True, frozen=True) class PIVXBNB: + """ + name: PIVXBNB + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 900000.00000000 + margin: False + """ name: str = "PIVXBNB" precision: int = 8 minimum_margin: float = None @@ -33693,11 +46883,20 @@ def __call__(self): return "PIVXBNB" -PIVXBNB = PIVXBNB() +PIVXBTC = PIVXBTC() @dataclass(slots=True, frozen=True) class PIVXBTC: + """ + name: PIVXBTC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 90000000.00000000 + margin: False + """ name: str = "PIVXBTC" precision: int = 8 minimum_margin: float = None @@ -33716,11 +46915,20 @@ def __call__(self): return "PIVXBTC" -PIVXBTC = PIVXBTC() +PLABNB = PLABNB() @dataclass(slots=True, frozen=True) class PLABNB: + """ + name: PLABNB + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 92141578.00000000 + margin: False + """ name: str = "PLABNB" precision: int = 8 minimum_margin: float = None @@ -33739,11 +46947,20 @@ def __call__(self): return "PLABNB" -PLABNB = PLABNB() +PLABTC = PLABTC() @dataclass(slots=True, frozen=True) class PLABTC: + """ + name: PLABTC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 92141578.00000000 + margin: False + """ name: str = "PLABTC" precision: int = 8 minimum_margin: float = None @@ -33762,11 +46979,20 @@ def __call__(self): return "PLABTC" -PLABTC = PLABTC() +PLABUSD = PLABUSD() @dataclass(slots=True, frozen=True) class PLABUSD: + """ + name: PLABUSD + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 92141578.00000000 + margin: False + """ name: str = "PLABUSD" precision: int = 8 minimum_margin: float = None @@ -33785,11 +47011,20 @@ def __call__(self): return "PLABUSD" -PLABUSD = PLABUSD() +PLAUSDT = PLAUSDT() @dataclass(slots=True, frozen=True) class PLAUSDT: + """ + name: PLAUSDT + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 92141578.00000000 + margin: False + """ name: str = "PLAUSDT" precision: int = 8 minimum_margin: float = None @@ -33808,11 +47043,20 @@ def __call__(self): return "PLAUSDT" -PLAUSDT = PLAUSDT() +PNTBTC = PNTBTC() @dataclass(slots=True, frozen=True) class PNTBTC: + """ + name: PNTBTC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 90000000.00000000 + margin: False + """ name: str = "PNTBTC" precision: int = 8 minimum_margin: float = None @@ -33831,11 +47075,20 @@ def __call__(self): return "PNTBTC" -PNTBTC = PNTBTC() +PNTUSDT = PNTUSDT() @dataclass(slots=True, frozen=True) class PNTUSDT: + """ + name: PNTUSDT + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 900000.00000000 + margin: False + """ name: str = "PNTUSDT" precision: int = 8 minimum_margin: float = None @@ -33854,11 +47107,20 @@ def __call__(self): return "PNTUSDT" -PNTUSDT = PNTUSDT() +POABNB = POABNB() @dataclass(slots=True, frozen=True) class POABNB: + """ + name: POABNB + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 9000000.00000000 + margin: False + """ name: str = "POABNB" precision: int = 8 minimum_margin: float = None @@ -33877,11 +47139,20 @@ def __call__(self): return "POABNB" -POABNB = POABNB() +POABTC = POABTC() @dataclass(slots=True, frozen=True) class POABTC: + """ + name: POABTC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 90000000.00000000 + margin: False + """ name: str = "POABTC" precision: int = 8 minimum_margin: float = None @@ -33900,11 +47171,20 @@ def __call__(self): return "POABTC" -POABTC = POABTC() +POAETH = POAETH() @dataclass(slots=True, frozen=True) class POAETH: + """ + name: POAETH + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 90000000.00000000 + margin: False + """ name: str = "POAETH" precision: int = 8 minimum_margin: float = None @@ -33923,11 +47203,20 @@ def __call__(self): return "POAETH" -POAETH = POAETH() +POEBTC = POEBTC() @dataclass(slots=True, frozen=True) class POEBTC: + """ + name: POEBTC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 92141578.00000000 + margin: False + """ name: str = "POEBTC" precision: int = 8 minimum_margin: float = None @@ -33946,11 +47235,20 @@ def __call__(self): return "POEBTC" -POEBTC = POEBTC() +POEETH = POEETH() @dataclass(slots=True, frozen=True) class POEETH: + """ + name: POEETH + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 90000000.00000000 + margin: False + """ name: str = "POEETH" precision: int = 8 minimum_margin: float = None @@ -33969,11 +47267,20 @@ def __call__(self): return "POEETH" -POEETH = POEETH() +POLSBNB = POLSBNB() @dataclass(slots=True, frozen=True) class POLSBNB: + """ + name: POLSBNB + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 92141578.00000000 + margin: False + """ name: str = "POLSBNB" precision: int = 8 minimum_margin: float = None @@ -33992,11 +47299,20 @@ def __call__(self): return "POLSBNB" -POLSBNB = POLSBNB() +POLSBTC = POLSBTC() @dataclass(slots=True, frozen=True) class POLSBTC: + """ + name: POLSBTC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 92141578.00000000 + margin: True + """ name: str = "POLSBTC" precision: int = 8 minimum_margin: float = None @@ -34015,11 +47331,20 @@ def __call__(self): return "POLSBTC" -POLSBTC = POLSBTC() +POLSBUSD = POLSBUSD() @dataclass(slots=True, frozen=True) class POLSBUSD: + """ + name: POLSBUSD + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 92141578.00000000 + margin: True + """ name: str = "POLSBUSD" precision: int = 8 minimum_margin: float = None @@ -34038,11 +47363,20 @@ def __call__(self): return "POLSBUSD" -POLSBUSD = POLSBUSD() +POLSUSDT = POLSUSDT() @dataclass(slots=True, frozen=True) class POLSUSDT: + """ + name: POLSUSDT + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 92141578.00000000 + margin: True + """ name: str = "POLSUSDT" precision: int = 8 minimum_margin: float = None @@ -34061,11 +47395,20 @@ def __call__(self): return "POLSUSDT" -POLSUSDT = POLSUSDT() +POLYBNB = POLYBNB() @dataclass(slots=True, frozen=True) class POLYBNB: + """ + name: POLYBNB + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 9000000.00000000 + margin: False + """ name: str = "POLYBNB" precision: int = 8 minimum_margin: float = None @@ -34084,11 +47427,20 @@ def __call__(self): return "POLYBNB" -POLYBNB = POLYBNB() +POLYBTC = POLYBTC() @dataclass(slots=True, frozen=True) class POLYBTC: + """ + name: POLYBTC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 90000000.00000000 + margin: False + """ name: str = "POLYBTC" precision: int = 8 minimum_margin: float = None @@ -34107,11 +47459,20 @@ def __call__(self): return "POLYBTC" -POLYBTC = POLYBTC() +POLYBUSD = POLYBUSD() @dataclass(slots=True, frozen=True) class POLYBUSD: + """ + name: POLYBUSD + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 92141578.00000000 + margin: False + """ name: str = "POLYBUSD" precision: int = 8 minimum_margin: float = None @@ -34130,11 +47491,20 @@ def __call__(self): return "POLYBUSD" -POLYBUSD = POLYBUSD() +POLYUSDT = POLYUSDT() @dataclass(slots=True, frozen=True) class POLYUSDT: + """ + name: POLYUSDT + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 913205152.00000000 + margin: False + """ name: str = "POLYUSDT" precision: int = 8 minimum_margin: float = None @@ -34153,11 +47523,20 @@ def __call__(self): return "POLYUSDT" -POLYUSDT = POLYUSDT() +POLYXBTC = POLYXBTC() @dataclass(slots=True, frozen=True) class POLYXBTC: + """ + name: POLYXBTC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 92141578.00000000 + margin: False + """ name: str = "POLYXBTC" precision: int = 8 minimum_margin: float = None @@ -34176,11 +47555,20 @@ def __call__(self): return "POLYXBTC" -POLYXBTC = POLYXBTC() +POLYXBUSD = POLYXBUSD() @dataclass(slots=True, frozen=True) class POLYXBUSD: + """ + name: POLYXBUSD + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 92141578.00000000 + margin: True + """ name: str = "POLYXBUSD" precision: int = 8 minimum_margin: float = None @@ -34199,11 +47587,20 @@ def __call__(self): return "POLYXBUSD" -POLYXBUSD = POLYXBUSD() +POLYXUSDT = POLYXUSDT() @dataclass(slots=True, frozen=True) class POLYXUSDT: + """ + name: POLYXUSDT + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 92141578.00000000 + margin: True + """ name: str = "POLYXUSDT" precision: int = 8 minimum_margin: float = None @@ -34222,11 +47619,20 @@ def __call__(self): return "POLYXUSDT" -POLYXUSDT = POLYXUSDT() +PONDBTC = PONDBTC() @dataclass(slots=True, frozen=True) class PONDBTC: + """ + name: PONDBTC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 90000000.00000000 + margin: True + """ name: str = "PONDBTC" precision: int = 8 minimum_margin: float = None @@ -34245,11 +47651,20 @@ def __call__(self): return "PONDBTC" -PONDBTC = PONDBTC() +PONDBUSD = PONDBUSD() @dataclass(slots=True, frozen=True) class PONDBUSD: + """ + name: PONDBUSD + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 9222449.00000000 + margin: True + """ name: str = "PONDBUSD" precision: int = 8 minimum_margin: float = None @@ -34268,11 +47683,20 @@ def __call__(self): return "PONDBUSD" -PONDBUSD = PONDBUSD() +PONDUSDT = PONDUSDT() @dataclass(slots=True, frozen=True) class PONDUSDT: + """ + name: PONDUSDT + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 9222449.00000000 + margin: True + """ name: str = "PONDUSDT" precision: int = 8 minimum_margin: float = None @@ -34291,11 +47715,20 @@ def __call__(self): return "PONDUSDT" -PONDUSDT = PONDUSDT() +PORTOBTC = PORTOBTC() @dataclass(slots=True, frozen=True) class PORTOBTC: + """ + name: PORTOBTC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 92141578.00000000 + margin: False + """ name: str = "PORTOBTC" precision: int = 8 minimum_margin: float = None @@ -34314,11 +47747,20 @@ def __call__(self): return "PORTOBTC" -PORTOBTC = PORTOBTC() +PORTOBUSD = PORTOBUSD() @dataclass(slots=True, frozen=True) class PORTOBUSD: + """ + name: PORTOBUSD + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 92141578.00000000 + margin: True + """ name: str = "PORTOBUSD" precision: int = 8 minimum_margin: float = None @@ -34337,11 +47779,20 @@ def __call__(self): return "PORTOBUSD" -PORTOBUSD = PORTOBUSD() +PORTOEUR = PORTOEUR() @dataclass(slots=True, frozen=True) class PORTOEUR: + """ + name: PORTOEUR + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 92141578.00000000 + margin: False + """ name: str = "PORTOEUR" precision: int = 8 minimum_margin: float = None @@ -34360,11 +47811,20 @@ def __call__(self): return "PORTOEUR" -PORTOEUR = PORTOEUR() +PORTOTRY = PORTOTRY() @dataclass(slots=True, frozen=True) class PORTOTRY: + """ + name: PORTOTRY + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 9222449.00000000 + margin: False + """ name: str = "PORTOTRY" precision: int = 8 minimum_margin: float = None @@ -34383,11 +47843,20 @@ def __call__(self): return "PORTOTRY" -PORTOTRY = PORTOTRY() +PORTOUSDT = PORTOUSDT() @dataclass(slots=True, frozen=True) class PORTOUSDT: + """ + name: PORTOUSDT + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 92141578.00000000 + margin: True + """ name: str = "PORTOUSDT" precision: int = 8 minimum_margin: float = None @@ -34406,11 +47875,20 @@ def __call__(self): return "PORTOUSDT" -PORTOUSDT = PORTOUSDT() +POWRBNB = POWRBNB() @dataclass(slots=True, frozen=True) class POWRBNB: + """ + name: POWRBNB + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 900000.00000000 + margin: False + """ name: str = "POWRBNB" precision: int = 8 minimum_margin: float = None @@ -34429,11 +47907,20 @@ def __call__(self): return "POWRBNB" -POWRBNB = POWRBNB() +POWRBTC = POWRBTC() @dataclass(slots=True, frozen=True) class POWRBTC: + """ + name: POWRBTC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 90000000.00000000 + margin: False + """ name: str = "POWRBTC" precision: int = 8 minimum_margin: float = None @@ -34452,11 +47939,20 @@ def __call__(self): return "POWRBTC" -POWRBTC = POWRBTC() +POWRBUSD = POWRBUSD() @dataclass(slots=True, frozen=True) class POWRBUSD: + """ + name: POWRBUSD + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 92141578.00000000 + margin: False + """ name: str = "POWRBUSD" precision: int = 8 minimum_margin: float = None @@ -34475,11 +47971,20 @@ def __call__(self): return "POWRBUSD" -POWRBUSD = POWRBUSD() +POWRETH = POWRETH() @dataclass(slots=True, frozen=True) class POWRETH: + """ + name: POWRETH + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 90000000.00000000 + margin: False + """ name: str = "POWRETH" precision: int = 8 minimum_margin: float = None @@ -34498,11 +48003,20 @@ def __call__(self): return "POWRETH" -POWRETH = POWRETH() +POWRUSDT = POWRUSDT() @dataclass(slots=True, frozen=True) class POWRUSDT: + """ + name: POWRUSDT + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 92141578.00000000 + margin: False + """ name: str = "POWRUSDT" precision: int = 8 minimum_margin: float = None @@ -34521,11 +48035,20 @@ def __call__(self): return "POWRUSDT" -POWRUSDT = POWRUSDT() +PPTBTC = PPTBTC() @dataclass(slots=True, frozen=True) class PPTBTC: + """ + name: PPTBTC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 90000000.00000000 + margin: False + """ name: str = "PPTBTC" precision: int = 8 minimum_margin: float = None @@ -34544,11 +48067,20 @@ def __call__(self): return "PPTBTC" -PPTBTC = PPTBTC() +PPTETH = PPTETH() @dataclass(slots=True, frozen=True) class PPTETH: + """ + name: PPTETH + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 90000000.00000000 + margin: False + """ name: str = "PPTETH" precision: int = 8 minimum_margin: float = None @@ -34567,11 +48099,20 @@ def __call__(self): return "PPTETH" -PPTETH = PPTETH() +PROMBNB = PROMBNB() @dataclass(slots=True, frozen=True) class PROMBNB: + """ + name: PROMBNB + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 9000000.00000000 + margin: False + """ name: str = "PROMBNB" precision: int = 8 minimum_margin: float = None @@ -34590,11 +48131,20 @@ def __call__(self): return "PROMBNB" -PROMBNB = PROMBNB() +PROMBTC = PROMBTC() @dataclass(slots=True, frozen=True) class PROMBTC: + """ + name: PROMBTC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 92141578.00000000 + margin: False + """ name: str = "PROMBTC" precision: int = 8 minimum_margin: float = None @@ -34613,11 +48163,20 @@ def __call__(self): return "PROMBTC" -PROMBTC = PROMBTC() +PROMBUSD = PROMBUSD() @dataclass(slots=True, frozen=True) class PROMBUSD: + """ + name: PROMBUSD + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 90000.00000000 + margin: False + """ name: str = "PROMBUSD" precision: int = 8 minimum_margin: float = None @@ -34636,11 +48195,20 @@ def __call__(self): return "PROMBUSD" -PROMBUSD = PROMBUSD() +PROSBUSD = PROSBUSD() @dataclass(slots=True, frozen=True) class PROSBUSD: + """ + name: PROSBUSD + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 92141578.00000000 + margin: False + """ name: str = "PROSBUSD" precision: int = 8 minimum_margin: float = None @@ -34659,11 +48227,20 @@ def __call__(self): return "PROSBUSD" -PROSBUSD = PROSBUSD() +PROSETH = PROSETH() @dataclass(slots=True, frozen=True) class PROSETH: + """ + name: PROSETH + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 90000000.00000000 + margin: False + """ name: str = "PROSETH" precision: int = 8 minimum_margin: float = None @@ -34682,11 +48259,20 @@ def __call__(self): return "PROSETH" -PROSETH = PROSETH() +PSGBTC = PSGBTC() @dataclass(slots=True, frozen=True) class PSGBTC: + """ + name: PSGBTC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 90000000.00000000 + margin: False + """ name: str = "PSGBTC" precision: int = 8 minimum_margin: float = None @@ -34705,11 +48291,20 @@ def __call__(self): return "PSGBTC" -PSGBTC = PSGBTC() +PSGBUSD = PSGBUSD() @dataclass(slots=True, frozen=True) class PSGBUSD: + """ + name: PSGBUSD + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 90000.00000000 + margin: False + """ name: str = "PSGBUSD" precision: int = 8 minimum_margin: float = None @@ -34728,11 +48323,20 @@ def __call__(self): return "PSGBUSD" -PSGBUSD = PSGBUSD() +PSGUSDT = PSGUSDT() @dataclass(slots=True, frozen=True) class PSGUSDT: + """ + name: PSGUSDT + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 90000.00000000 + margin: False + """ name: str = "PSGUSDT" precision: int = 8 minimum_margin: float = None @@ -34751,11 +48355,20 @@ def __call__(self): return "PSGUSDT" -PSGUSDT = PSGUSDT() +PUNDIXBUSD = PUNDIXBUSD() @dataclass(slots=True, frozen=True) class PUNDIXBUSD: + """ + name: PUNDIXBUSD + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 9222449.00000000 + margin: True + """ name: str = "PUNDIXBUSD" precision: int = 8 minimum_margin: float = None @@ -34774,11 +48387,20 @@ def __call__(self): return "PUNDIXBUSD" -PUNDIXBUSD = PUNDIXBUSD() +PUNDIXETH = PUNDIXETH() @dataclass(slots=True, frozen=True) class PUNDIXETH: + """ + name: PUNDIXETH + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 90000000.00000000 + margin: False + """ name: str = "PUNDIXETH" precision: int = 8 minimum_margin: float = None @@ -34797,11 +48419,20 @@ def __call__(self): return "PUNDIXETH" -PUNDIXETH = PUNDIXETH() +PUNDIXUSDT = PUNDIXUSDT() @dataclass(slots=True, frozen=True) class PUNDIXUSDT: + """ + name: PUNDIXUSDT + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 9222449.00000000 + margin: True + """ name: str = "PUNDIXUSDT" precision: int = 8 minimum_margin: float = None @@ -34820,11 +48451,20 @@ def __call__(self): return "PUNDIXUSDT" -PUNDIXUSDT = PUNDIXUSDT() +PYRBTC = PYRBTC() @dataclass(slots=True, frozen=True) class PYRBTC: + """ + name: PYRBTC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.00100000 + maximum_order_size: 92141578.00000000 + margin: True + """ name: str = "PYRBTC" precision: int = 8 minimum_margin: float = None @@ -34843,11 +48483,20 @@ def __call__(self): return "PYRBTC" -PYRBTC = PYRBTC() +PYRBUSD = PYRBUSD() @dataclass(slots=True, frozen=True) class PYRBUSD: + """ + name: PYRBUSD + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.00100000 + maximum_order_size: 9222449.00000000 + margin: True + """ name: str = "PYRBUSD" precision: int = 8 minimum_margin: float = None @@ -34866,11 +48515,20 @@ def __call__(self): return "PYRBUSD" -PYRBUSD = PYRBUSD() +PYRUSDT = PYRUSDT() @dataclass(slots=True, frozen=True) class PYRUSDT: + """ + name: PYRUSDT + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.00100000 + maximum_order_size: 9222449.00000000 + margin: True + """ name: str = "PYRUSDT" precision: int = 8 minimum_margin: float = None @@ -34889,11 +48547,20 @@ def __call__(self): return "PYRUSDT" -PYRUSDT = PYRUSDT() +QIBNB = QIBNB() @dataclass(slots=True, frozen=True) class QIBNB: + """ + name: QIBNB + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 92141578.00000000 + margin: False + """ name: str = "QIBNB" precision: int = 8 minimum_margin: float = None @@ -34912,11 +48579,20 @@ def __call__(self): return "QIBNB" -QIBNB = QIBNB() +QIBTC = QIBTC() @dataclass(slots=True, frozen=True) class QIBTC: + """ + name: QIBTC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 92141578.00000000 + margin: False + """ name: str = "QIBTC" precision: int = 8 minimum_margin: float = None @@ -34935,11 +48611,20 @@ def __call__(self): return "QIBTC" -QIBTC = QIBTC() +QIBUSD = QIBUSD() @dataclass(slots=True, frozen=True) class QIBUSD: + """ + name: QIBUSD + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 92141578.00000000 + margin: False + """ name: str = "QIBUSD" precision: int = 8 minimum_margin: float = None @@ -34958,11 +48643,20 @@ def __call__(self): return "QIBUSD" -QIBUSD = QIBUSD() +QIUSDT = QIUSDT() @dataclass(slots=True, frozen=True) class QIUSDT: + """ + name: QIUSDT + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 92141578.00000000 + margin: True + """ name: str = "QIUSDT" precision: int = 8 minimum_margin: float = None @@ -34981,11 +48675,20 @@ def __call__(self): return "QIUSDT" -QIUSDT = QIUSDT() +QKCBTC = QKCBTC() @dataclass(slots=True, frozen=True) class QKCBTC: + """ + name: QKCBTC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 90000000.00000000 + margin: False + """ name: str = "QKCBTC" precision: int = 8 minimum_margin: float = None @@ -35004,11 +48707,20 @@ def __call__(self): return "QKCBTC" -QKCBTC = QKCBTC() +QKCBUSD = QKCBUSD() @dataclass(slots=True, frozen=True) class QKCBUSD: + """ + name: QKCBUSD + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 913205152.00000000 + margin: False + """ name: str = "QKCBUSD" precision: int = 8 minimum_margin: float = None @@ -35027,11 +48739,20 @@ def __call__(self): return "QKCBUSD" -QKCBUSD = QKCBUSD() +QKCETH = QKCETH() @dataclass(slots=True, frozen=True) class QKCETH: + """ + name: QKCETH + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 90000000.00000000 + margin: False + """ name: str = "QKCETH" precision: int = 8 minimum_margin: float = None @@ -35050,11 +48771,20 @@ def __call__(self): return "QKCETH" -QKCETH = QKCETH() +QLCBNB = QLCBNB() @dataclass(slots=True, frozen=True) class QLCBNB: + """ + name: QLCBNB + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 9000000.00000000 + margin: False + """ name: str = "QLCBNB" precision: int = 8 minimum_margin: float = None @@ -35073,11 +48803,20 @@ def __call__(self): return "QLCBNB" -QLCBNB = QLCBNB() +QLCBTC = QLCBTC() @dataclass(slots=True, frozen=True) class QLCBTC: + """ + name: QLCBTC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 90000000.00000000 + margin: False + """ name: str = "QLCBTC" precision: int = 8 minimum_margin: float = None @@ -35096,11 +48835,20 @@ def __call__(self): return "QLCBTC" -QLCBTC = QLCBTC() +QLCETH = QLCETH() @dataclass(slots=True, frozen=True) class QLCETH: + """ + name: QLCETH + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 92141578.00000000 + margin: False + """ name: str = "QLCETH" precision: int = 8 minimum_margin: float = None @@ -35119,11 +48867,20 @@ def __call__(self): return "QLCETH" -QLCETH = QLCETH() +QNTBNB = QNTBNB() @dataclass(slots=True, frozen=True) class QNTBNB: + """ + name: QNTBNB + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.00100000 + maximum_order_size: 92141578.00000000 + margin: False + """ name: str = "QNTBNB" precision: int = 8 minimum_margin: float = None @@ -35142,11 +48899,20 @@ def __call__(self): return "QNTBNB" -QNTBNB = QNTBNB() +QNTBTC = QNTBTC() @dataclass(slots=True, frozen=True) class QNTBTC: + """ + name: QNTBTC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.00100000 + maximum_order_size: 92141578.00000000 + margin: True + """ name: str = "QNTBTC" precision: int = 8 minimum_margin: float = None @@ -35165,11 +48931,20 @@ def __call__(self): return "QNTBTC" -QNTBTC = QNTBTC() +QNTBUSD = QNTBUSD() @dataclass(slots=True, frozen=True) class QNTBUSD: + """ + name: QNTBUSD + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.00100000 + maximum_order_size: 922327.00000000 + margin: True + """ name: str = "QNTBUSD" precision: int = 8 minimum_margin: float = None @@ -35188,11 +48963,20 @@ def __call__(self): return "QNTBUSD" -QNTBUSD = QNTBUSD() +QNTUSDT = QNTUSDT() @dataclass(slots=True, frozen=True) class QNTUSDT: + """ + name: QNTUSDT + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.00100000 + maximum_order_size: 922327.00000000 + margin: True + """ name: str = "QNTUSDT" precision: int = 8 minimum_margin: float = None @@ -35211,11 +48995,20 @@ def __call__(self): return "QNTUSDT" -QNTUSDT = QNTUSDT() +QSPBNB = QSPBNB() @dataclass(slots=True, frozen=True) class QSPBNB: + """ + name: QSPBNB + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 9000000.00000000 + margin: False + """ name: str = "QSPBNB" precision: int = 8 minimum_margin: float = None @@ -35234,11 +49027,20 @@ def __call__(self): return "QSPBNB" -QSPBNB = QSPBNB() +QSPBTC = QSPBTC() @dataclass(slots=True, frozen=True) class QSPBTC: + """ + name: QSPBTC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 90000000.00000000 + margin: False + """ name: str = "QSPBTC" precision: int = 8 minimum_margin: float = None @@ -35257,11 +49059,20 @@ def __call__(self): return "QSPBTC" -QSPBTC = QSPBTC() +QSPETH = QSPETH() @dataclass(slots=True, frozen=True) class QSPETH: + """ + name: QSPETH + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 92141578.00000000 + margin: False + """ name: str = "QSPETH" precision: int = 8 minimum_margin: float = None @@ -35280,11 +49091,20 @@ def __call__(self): return "QSPETH" -QSPETH = QSPETH() +QTUMBNB = QTUMBNB() @dataclass(slots=True, frozen=True) class QTUMBNB: + """ + name: QTUMBNB + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 9000000.00000000 + margin: False + """ name: str = "QTUMBNB" precision: int = 8 minimum_margin: float = None @@ -35303,11 +49123,20 @@ def __call__(self): return "QTUMBNB" -QTUMBNB = QTUMBNB() +QTUMBTC = QTUMBTC() @dataclass(slots=True, frozen=True) class QTUMBTC: + """ + name: QTUMBTC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 90000000.00000000 + margin: True + """ name: str = "QTUMBTC" precision: int = 8 minimum_margin: float = None @@ -35326,11 +49155,20 @@ def __call__(self): return "QTUMBTC" -QTUMBTC = QTUMBTC() +QTUMBUSD = QTUMBUSD() @dataclass(slots=True, frozen=True) class QTUMBUSD: + """ + name: QTUMBUSD + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 90000.00000000 + margin: False + """ name: str = "QTUMBUSD" precision: int = 8 minimum_margin: float = None @@ -35349,11 +49187,20 @@ def __call__(self): return "QTUMBUSD" -QTUMBUSD = QTUMBUSD() +QTUMETH = QTUMETH() @dataclass(slots=True, frozen=True) class QTUMETH: + """ + name: QTUMETH + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 90000000.00000000 + margin: False + """ name: str = "QTUMETH" precision: int = 8 minimum_margin: float = None @@ -35372,11 +49219,20 @@ def __call__(self): return "QTUMETH" -QTUMETH = QTUMETH() +QTUMUSDT = QTUMUSDT() @dataclass(slots=True, frozen=True) class QTUMUSDT: + """ + name: QTUMUSDT + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 90000.00000000 + margin: True + """ name: str = "QTUMUSDT" precision: int = 8 minimum_margin: float = None @@ -35395,11 +49251,20 @@ def __call__(self): return "QTUMUSDT" -QTUMUSDT = QTUMUSDT() +QUICKBNB = QUICKBNB() @dataclass(slots=True, frozen=True) class QUICKBNB: + """ + name: QUICKBNB + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.00100000 + maximum_order_size: 92141578.00000000 + margin: False + """ name: str = "QUICKBNB" precision: int = 8 minimum_margin: float = None @@ -35418,11 +49283,20 @@ def __call__(self): return "QUICKBNB" -QUICKBNB = QUICKBNB() +QUICKBTC = QUICKBTC() @dataclass(slots=True, frozen=True) class QUICKBTC: + """ + name: QUICKBTC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.00100000 + maximum_order_size: 92141578.00000000 + margin: True + """ name: str = "QUICKBTC" precision: int = 8 minimum_margin: float = None @@ -35441,11 +49315,20 @@ def __call__(self): return "QUICKBTC" -QUICKBTC = QUICKBTC() +QUICKBUSD = QUICKBUSD() @dataclass(slots=True, frozen=True) class QUICKBUSD: + """ + name: QUICKBUSD + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.00100000 + maximum_order_size: 922327.00000000 + margin: True + """ name: str = "QUICKBUSD" precision: int = 8 minimum_margin: float = None @@ -35464,11 +49347,20 @@ def __call__(self): return "QUICKBUSD" -QUICKBUSD = QUICKBUSD() +QUICKUSDT = QUICKUSDT() @dataclass(slots=True, frozen=True) class QUICKUSDT: + """ + name: QUICKUSDT + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.00100000 + maximum_order_size: 922327.00000000 + margin: True + """ name: str = "QUICKUSDT" precision: int = 8 minimum_margin: float = None @@ -35487,11 +49379,20 @@ def __call__(self): return "QUICKUSDT" -QUICKUSDT = QUICKUSDT() +RADBNB = RADBNB() @dataclass(slots=True, frozen=True) class RADBNB: + """ + name: RADBNB + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 92141578.00000000 + margin: False + """ name: str = "RADBNB" precision: int = 8 minimum_margin: float = None @@ -35510,11 +49411,20 @@ def __call__(self): return "RADBNB" -RADBNB = RADBNB() +RADBTC = RADBTC() @dataclass(slots=True, frozen=True) class RADBTC: + """ + name: RADBTC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 92141578.00000000 + margin: False + """ name: str = "RADBTC" precision: int = 8 minimum_margin: float = None @@ -35533,11 +49443,20 @@ def __call__(self): return "RADBTC" -RADBTC = RADBTC() +RADBUSD = RADBUSD() @dataclass(slots=True, frozen=True) class RADBUSD: + """ + name: RADBUSD + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 92141578.00000000 + margin: True + """ name: str = "RADBUSD" precision: int = 8 minimum_margin: float = None @@ -35556,11 +49475,20 @@ def __call__(self): return "RADBUSD" -RADBUSD = RADBUSD() +RADUSDT = RADUSDT() @dataclass(slots=True, frozen=True) class RADUSDT: + """ + name: RADUSDT + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 92141578.00000000 + margin: True + """ name: str = "RADUSDT" precision: int = 8 minimum_margin: float = None @@ -35579,11 +49507,20 @@ def __call__(self): return "RADUSDT" -RADUSDT = RADUSDT() +RAMPBTC = RAMPBTC() @dataclass(slots=True, frozen=True) class RAMPBTC: + """ + name: RAMPBTC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 90000000.00000000 + margin: False + """ name: str = "RAMPBTC" precision: int = 8 minimum_margin: float = None @@ -35602,11 +49539,20 @@ def __call__(self): return "RAMPBTC" -RAMPBTC = RAMPBTC() +RAMPBUSD = RAMPBUSD() @dataclass(slots=True, frozen=True) class RAMPBUSD: + """ + name: RAMPBUSD + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 92141578.00000000 + margin: False + """ name: str = "RAMPBUSD" precision: int = 8 minimum_margin: float = None @@ -35625,11 +49571,20 @@ def __call__(self): return "RAMPBUSD" -RAMPBUSD = RAMPBUSD() +RAMPUSDT = RAMPUSDT() @dataclass(slots=True, frozen=True) class RAMPUSDT: + """ + name: RAMPUSDT + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 92141578.00000000 + margin: False + """ name: str = "RAMPUSDT" precision: int = 8 minimum_margin: float = None @@ -35648,11 +49603,20 @@ def __call__(self): return "RAMPUSDT" -RAMPUSDT = RAMPUSDT() +RAREBNB = RAREBNB() @dataclass(slots=True, frozen=True) class RAREBNB: + """ + name: RAREBNB + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 92141578.00000000 + margin: False + """ name: str = "RAREBNB" precision: int = 8 minimum_margin: float = None @@ -35671,11 +49635,20 @@ def __call__(self): return "RAREBNB" -RAREBNB = RAREBNB() +RAREBTC = RAREBTC() @dataclass(slots=True, frozen=True) class RAREBTC: + """ + name: RAREBTC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 92141578.00000000 + margin: False + """ name: str = "RAREBTC" precision: int = 8 minimum_margin: float = None @@ -35694,11 +49667,20 @@ def __call__(self): return "RAREBTC" -RAREBTC = RAREBTC() +RAREBUSD = RAREBUSD() @dataclass(slots=True, frozen=True) class RAREBUSD: + """ + name: RAREBUSD + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 92141578.00000000 + margin: False + """ name: str = "RAREBUSD" precision: int = 8 minimum_margin: float = None @@ -35717,11 +49699,20 @@ def __call__(self): return "RAREBUSD" -RAREBUSD = RAREBUSD() +RAREUSDT = RAREUSDT() @dataclass(slots=True, frozen=True) class RAREUSDT: + """ + name: RAREUSDT + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 92141578.00000000 + margin: False + """ name: str = "RAREUSDT" precision: int = 8 minimum_margin: float = None @@ -35740,11 +49731,20 @@ def __call__(self): return "RAREUSDT" -RAREUSDT = RAREUSDT() +RAYBNB = RAYBNB() @dataclass(slots=True, frozen=True) class RAYBNB: + """ + name: RAYBNB + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 92141578.00000000 + margin: False + """ name: str = "RAYBNB" precision: int = 8 minimum_margin: float = None @@ -35763,11 +49763,20 @@ def __call__(self): return "RAYBNB" -RAYBNB = RAYBNB() +RAYBUSD = RAYBUSD() @dataclass(slots=True, frozen=True) class RAYBUSD: + """ + name: RAYBUSD + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 9222449.00000000 + margin: False + """ name: str = "RAYBUSD" precision: int = 8 minimum_margin: float = None @@ -35786,11 +49795,20 @@ def __call__(self): return "RAYBUSD" -RAYBUSD = RAYBUSD() +RAYUSDT = RAYUSDT() @dataclass(slots=True, frozen=True) class RAYUSDT: + """ + name: RAYUSDT + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 9222449.00000000 + margin: False + """ name: str = "RAYUSDT" precision: int = 8 minimum_margin: float = None @@ -35809,11 +49827,20 @@ def __call__(self): return "RAYUSDT" -RAYUSDT = RAYUSDT() +RCNBNB = RCNBNB() @dataclass(slots=True, frozen=True) class RCNBNB: + """ + name: RCNBNB + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 9000000.00000000 + margin: False + """ name: str = "RCNBNB" precision: int = 8 minimum_margin: float = None @@ -35832,11 +49859,20 @@ def __call__(self): return "RCNBNB" -RCNBNB = RCNBNB() +RCNBTC = RCNBTC() @dataclass(slots=True, frozen=True) class RCNBTC: + """ + name: RCNBTC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 90000000.00000000 + margin: False + """ name: str = "RCNBTC" precision: int = 8 minimum_margin: float = None @@ -35855,11 +49891,20 @@ def __call__(self): return "RCNBTC" -RCNBTC = RCNBTC() +RCNETH = RCNETH() @dataclass(slots=True, frozen=True) class RCNETH: + """ + name: RCNETH + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 90000000.00000000 + margin: False + """ name: str = "RCNETH" precision: int = 8 minimum_margin: float = None @@ -35878,11 +49923,20 @@ def __call__(self): return "RCNETH" -RCNETH = RCNETH() +RDNBNB = RDNBNB() @dataclass(slots=True, frozen=True) class RDNBNB: + """ + name: RDNBNB + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 9000000.00000000 + margin: False + """ name: str = "RDNBNB" precision: int = 8 minimum_margin: float = None @@ -35901,11 +49955,20 @@ def __call__(self): return "RDNBNB" -RDNBNB = RDNBNB() +RDNBTC = RDNBTC() @dataclass(slots=True, frozen=True) class RDNBTC: + """ + name: RDNBTC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 90000000.00000000 + margin: False + """ name: str = "RDNBTC" precision: int = 8 minimum_margin: float = None @@ -35924,11 +49987,20 @@ def __call__(self): return "RDNBTC" -RDNBTC = RDNBTC() +RDNETH = RDNETH() @dataclass(slots=True, frozen=True) class RDNETH: + """ + name: RDNETH + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 90000000.00000000 + margin: False + """ name: str = "RDNETH" precision: int = 8 minimum_margin: float = None @@ -35947,11 +50019,20 @@ def __call__(self): return "RDNETH" -RDNETH = RDNETH() +REEFBIDR = REEFBIDR() @dataclass(slots=True, frozen=True) class REEFBIDR: + """ + name: REEFBIDR + precision: 2 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 922327.00000000 + margin: False + """ name: str = "REEFBIDR" precision: int = 2 minimum_margin: float = None @@ -35970,11 +50051,20 @@ def __call__(self): return "REEFBIDR" -REEFBIDR = REEFBIDR() +REEFBTC = REEFBTC() @dataclass(slots=True, frozen=True) class REEFBTC: + """ + name: REEFBTC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 92141578.00000000 + margin: False + """ name: str = "REEFBTC" precision: int = 8 minimum_margin: float = None @@ -35993,11 +50083,20 @@ def __call__(self): return "REEFBTC" -REEFBTC = REEFBTC() +REEFBUSD = REEFBUSD() @dataclass(slots=True, frozen=True) class REEFBUSD: + """ + name: REEFBUSD + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 92141578.00000000 + margin: True + """ name: str = "REEFBUSD" precision: int = 8 minimum_margin: float = None @@ -36016,11 +50115,20 @@ def __call__(self): return "REEFBUSD" -REEFBUSD = REEFBUSD() +REEFTRY = REEFTRY() @dataclass(slots=True, frozen=True) class REEFTRY: + """ + name: REEFTRY + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 92141578.00000000 + margin: False + """ name: str = "REEFTRY" precision: int = 8 minimum_margin: float = None @@ -36039,11 +50147,20 @@ def __call__(self): return "REEFTRY" -REEFTRY = REEFTRY() +REEFUSDT = REEFUSDT() @dataclass(slots=True, frozen=True) class REEFUSDT: + """ + name: REEFUSDT + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 92141578.00000000 + margin: True + """ name: str = "REEFUSDT" precision: int = 8 minimum_margin: float = None @@ -36062,11 +50179,20 @@ def __call__(self): return "REEFUSDT" -REEFUSDT = REEFUSDT() +REIBNB = REIBNB() @dataclass(slots=True, frozen=True) class REIBNB: + """ + name: REIBNB + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 92141578.00000000 + margin: False + """ name: str = "REIBNB" precision: int = 8 minimum_margin: float = None @@ -36085,11 +50211,20 @@ def __call__(self): return "REIBNB" -REIBNB = REIBNB() +REIBUSD = REIBUSD() @dataclass(slots=True, frozen=True) class REIBUSD: + """ + name: REIBUSD + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 92141578.00000000 + margin: True + """ name: str = "REIBUSD" precision: int = 8 minimum_margin: float = None @@ -36108,11 +50243,20 @@ def __call__(self): return "REIBUSD" -REIBUSD = REIBUSD() +REIETH = REIETH() @dataclass(slots=True, frozen=True) class REIETH: + """ + name: REIETH + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 92141578.00000000 + margin: False + """ name: str = "REIETH" precision: int = 8 minimum_margin: float = None @@ -36131,11 +50275,20 @@ def __call__(self): return "REIETH" -REIETH = REIETH() +REIUSDT = REIUSDT() @dataclass(slots=True, frozen=True) class REIUSDT: + """ + name: REIUSDT + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 92141578.00000000 + margin: True + """ name: str = "REIUSDT" precision: int = 8 minimum_margin: float = None @@ -36154,11 +50307,20 @@ def __call__(self): return "REIUSDT" -REIUSDT = REIUSDT() +RENBNB = RENBNB() @dataclass(slots=True, frozen=True) class RENBNB: + """ + name: RENBNB + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 9000000.00000000 + margin: False + """ name: str = "RENBNB" precision: int = 8 minimum_margin: float = None @@ -36177,11 +50339,20 @@ def __call__(self): return "RENBNB" -RENBNB = RENBNB() +RENBTC = RENBTC() @dataclass(slots=True, frozen=True) class RENBTC: + """ + name: RENBTC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 90000000.00000000 + margin: True + """ name: str = "RENBTC" precision: int = 8 minimum_margin: float = None @@ -36200,11 +50371,20 @@ def __call__(self): return "RENBTC" -RENBTC = RENBTC() +RENBTCBTC = RENBTCBTC() @dataclass(slots=True, frozen=True) class RENBTCBTC: + """ + name: RENBTCBTC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.00001000 + maximum_order_size: 92141578.00000000 + margin: False + """ name: str = "RENBTCBTC" precision: int = 8 minimum_margin: float = None @@ -36223,11 +50403,20 @@ def __call__(self): return "RENBTCBTC" -RENBTCBTC = RENBTCBTC() +RENBTCETH = RENBTCETH() @dataclass(slots=True, frozen=True) class RENBTCETH: + """ + name: RENBTCETH + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.00001000 + maximum_order_size: 100000.00000000 + margin: False + """ name: str = "RENBTCETH" precision: int = 8 minimum_margin: float = None @@ -36246,11 +50435,20 @@ def __call__(self): return "RENBTCETH" -RENBTCETH = RENBTCETH() +RENBUSD = RENBUSD() @dataclass(slots=True, frozen=True) class RENBUSD: + """ + name: RENBUSD + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 92141578.00000000 + margin: False + """ name: str = "RENBUSD" precision: int = 8 minimum_margin: float = None @@ -36269,11 +50467,20 @@ def __call__(self): return "RENBUSD" -RENBUSD = RENBUSD() +RENUSDT = RENUSDT() @dataclass(slots=True, frozen=True) class RENUSDT: + """ + name: RENUSDT + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 9000000.00000000 + margin: True + """ name: str = "RENUSDT" precision: int = 8 minimum_margin: float = None @@ -36292,11 +50499,20 @@ def __call__(self): return "RENUSDT" -RENUSDT = RENUSDT() +REPBNB = REPBNB() @dataclass(slots=True, frozen=True) class REPBNB: + """ + name: REPBNB + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 900000.00000000 + margin: False + """ name: str = "REPBNB" precision: int = 8 minimum_margin: float = None @@ -36315,11 +50531,20 @@ def __call__(self): return "REPBNB" -REPBNB = REPBNB() +REPBTC = REPBTC() @dataclass(slots=True, frozen=True) class REPBTC: + """ + name: REPBTC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 9000000.00000000 + margin: False + """ name: str = "REPBTC" precision: int = 8 minimum_margin: float = None @@ -36338,11 +50563,20 @@ def __call__(self): return "REPBTC" -REPBTC = REPBTC() +REPBUSD = REPBUSD() @dataclass(slots=True, frozen=True) class REPBUSD: + """ + name: REPBUSD + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.00100000 + maximum_order_size: 90000.00000000 + margin: False + """ name: str = "REPBUSD" precision: int = 8 minimum_margin: float = None @@ -36361,11 +50595,20 @@ def __call__(self): return "REPBUSD" -REPBUSD = REPBUSD() +REPUSDT = REPUSDT() @dataclass(slots=True, frozen=True) class REPUSDT: + """ + name: REPUSDT + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 90000.00000000 + margin: False + """ name: str = "REPUSDT" precision: int = 8 minimum_margin: float = None @@ -36384,11 +50627,20 @@ def __call__(self): return "REPUSDT" -REPUSDT = REPUSDT() +REQBTC = REQBTC() @dataclass(slots=True, frozen=True) class REQBTC: + """ + name: REQBTC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 90000000.00000000 + margin: False + """ name: str = "REQBTC" precision: int = 8 minimum_margin: float = None @@ -36407,11 +50659,20 @@ def __call__(self): return "REQBTC" -REQBTC = REQBTC() +REQBUSD = REQBUSD() @dataclass(slots=True, frozen=True) class REQBUSD: + """ + name: REQBUSD + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 92141578.00000000 + margin: True + """ name: str = "REQBUSD" precision: int = 8 minimum_margin: float = None @@ -36430,11 +50691,20 @@ def __call__(self): return "REQBUSD" -REQBUSD = REQBUSD() +REQETH = REQETH() @dataclass(slots=True, frozen=True) class REQETH: + """ + name: REQETH + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 90000000.00000000 + margin: False + """ name: str = "REQETH" precision: int = 8 minimum_margin: float = None @@ -36453,11 +50723,20 @@ def __call__(self): return "REQETH" -REQETH = REQETH() +REQUSDT = REQUSDT() @dataclass(slots=True, frozen=True) class REQUSDT: + """ + name: REQUSDT + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 92141578.00000000 + margin: True + """ name: str = "REQUSDT" precision: int = 8 minimum_margin: float = None @@ -36476,11 +50755,20 @@ def __call__(self): return "REQUSDT" -REQUSDT = REQUSDT() +RGTBNB = RGTBNB() @dataclass(slots=True, frozen=True) class RGTBNB: + """ + name: RGTBNB + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 92141578.00000000 + margin: False + """ name: str = "RGTBNB" precision: int = 8 minimum_margin: float = None @@ -36499,11 +50787,20 @@ def __call__(self): return "RGTBNB" -RGTBNB = RGTBNB() +RGTBTC = RGTBTC() @dataclass(slots=True, frozen=True) class RGTBTC: + """ + name: RGTBTC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 92141578.00000000 + margin: False + """ name: str = "RGTBTC" precision: int = 8 minimum_margin: float = None @@ -36522,11 +50819,20 @@ def __call__(self): return "RGTBTC" -RGTBTC = RGTBTC() +RGTBUSD = RGTBUSD() @dataclass(slots=True, frozen=True) class RGTBUSD: + """ + name: RGTBUSD + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 922327.00000000 + margin: False + """ name: str = "RGTBUSD" precision: int = 8 minimum_margin: float = None @@ -36545,11 +50851,20 @@ def __call__(self): return "RGTBUSD" -RGTBUSD = RGTBUSD() +RGTUSDT = RGTUSDT() @dataclass(slots=True, frozen=True) class RGTUSDT: + """ + name: RGTUSDT + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 922327.00000000 + margin: False + """ name: str = "RGTUSDT" precision: int = 8 minimum_margin: float = None @@ -36568,11 +50883,20 @@ def __call__(self): return "RGTUSDT" -RGTUSDT = RGTUSDT() +RIFBTC = RIFBTC() @dataclass(slots=True, frozen=True) class RIFBTC: + """ + name: RIFBTC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 90000000.00000000 + margin: False + """ name: str = "RIFBTC" precision: int = 8 minimum_margin: float = None @@ -36591,11 +50915,20 @@ def __call__(self): return "RIFBTC" -RIFBTC = RIFBTC() +RIFUSDT = RIFUSDT() @dataclass(slots=True, frozen=True) class RIFUSDT: + """ + name: RIFUSDT + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 9222449.00000000 + margin: False + """ name: str = "RIFUSDT" precision: int = 8 minimum_margin: float = None @@ -36614,11 +50947,20 @@ def __call__(self): return "RIFUSDT" -RIFUSDT = RIFUSDT() +RLCBNB = RLCBNB() @dataclass(slots=True, frozen=True) class RLCBNB: + """ + name: RLCBNB + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 9000000.00000000 + margin: False + """ name: str = "RLCBNB" precision: int = 8 minimum_margin: float = None @@ -36637,11 +50979,20 @@ def __call__(self): return "RLCBNB" -RLCBNB = RLCBNB() +RLCBTC = RLCBTC() @dataclass(slots=True, frozen=True) class RLCBTC: + """ + name: RLCBTC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 90000000.00000000 + margin: True + """ name: str = "RLCBTC" precision: int = 8 minimum_margin: float = None @@ -36660,11 +51011,20 @@ def __call__(self): return "RLCBTC" -RLCBTC = RLCBTC() +RLCBUSD = RLCBUSD() @dataclass(slots=True, frozen=True) class RLCBUSD: + """ + name: RLCBUSD + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 9222449.00000000 + margin: False + """ name: str = "RLCBUSD" precision: int = 8 minimum_margin: float = None @@ -36683,11 +51043,20 @@ def __call__(self): return "RLCBUSD" -RLCBUSD = RLCBUSD() +RLCETH = RLCETH() @dataclass(slots=True, frozen=True) class RLCETH: + """ + name: RLCETH + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 90000000.00000000 + margin: False + """ name: str = "RLCETH" precision: int = 8 minimum_margin: float = None @@ -36706,11 +51075,20 @@ def __call__(self): return "RLCETH" -RLCETH = RLCETH() +RLCUSDT = RLCUSDT() @dataclass(slots=True, frozen=True) class RLCUSDT: + """ + name: RLCUSDT + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 900000.00000000 + margin: True + """ name: str = "RLCUSDT" precision: int = 8 minimum_margin: float = None @@ -36729,11 +51107,20 @@ def __call__(self): return "RLCUSDT" -RLCUSDT = RLCUSDT() +RNDRBTC = RNDRBTC() @dataclass(slots=True, frozen=True) class RNDRBTC: + """ + name: RNDRBTC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 92141578.00000000 + margin: True + """ name: str = "RNDRBTC" precision: int = 8 minimum_margin: float = None @@ -36752,11 +51139,20 @@ def __call__(self): return "RNDRBTC" -RNDRBTC = RNDRBTC() +RNDRBUSD = RNDRBUSD() @dataclass(slots=True, frozen=True) class RNDRBUSD: + """ + name: RNDRBUSD + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 92141578.00000000 + margin: True + """ name: str = "RNDRBUSD" precision: int = 8 minimum_margin: float = None @@ -36775,11 +51171,20 @@ def __call__(self): return "RNDRBUSD" -RNDRBUSD = RNDRBUSD() +RNDRUSDT = RNDRUSDT() @dataclass(slots=True, frozen=True) class RNDRUSDT: + """ + name: RNDRUSDT + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 92141578.00000000 + margin: True + """ name: str = "RNDRUSDT" precision: int = 8 minimum_margin: float = None @@ -36798,11 +51203,20 @@ def __call__(self): return "RNDRUSDT" -RNDRUSDT = RNDRUSDT() +ROSEBNB = ROSEBNB() @dataclass(slots=True, frozen=True) class ROSEBNB: + """ + name: ROSEBNB + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 92141578.00000000 + margin: False + """ name: str = "ROSEBNB" precision: int = 8 minimum_margin: float = None @@ -36821,11 +51235,20 @@ def __call__(self): return "ROSEBNB" -ROSEBNB = ROSEBNB() +ROSEBTC = ROSEBTC() @dataclass(slots=True, frozen=True) class ROSEBTC: + """ + name: ROSEBTC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 90000000.00000000 + margin: True + """ name: str = "ROSEBTC" precision: int = 8 minimum_margin: float = None @@ -36844,11 +51267,20 @@ def __call__(self): return "ROSEBTC" -ROSEBTC = ROSEBTC() +ROSEBUSD = ROSEBUSD() @dataclass(slots=True, frozen=True) class ROSEBUSD: + """ + name: ROSEBUSD + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 9000000.00000000 + margin: True + """ name: str = "ROSEBUSD" precision: int = 8 minimum_margin: float = None @@ -36867,11 +51299,20 @@ def __call__(self): return "ROSEBUSD" -ROSEBUSD = ROSEBUSD() +ROSEETH = ROSEETH() @dataclass(slots=True, frozen=True) class ROSEETH: + """ + name: ROSEETH + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 92141578.00000000 + margin: False + """ name: str = "ROSEETH" precision: int = 8 minimum_margin: float = None @@ -36890,11 +51331,20 @@ def __call__(self): return "ROSEETH" -ROSEETH = ROSEETH() +ROSETRY = ROSETRY() @dataclass(slots=True, frozen=True) class ROSETRY: + """ + name: ROSETRY + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 92141578.00000000 + margin: False + """ name: str = "ROSETRY" precision: int = 8 minimum_margin: float = None @@ -36913,11 +51363,20 @@ def __call__(self): return "ROSETRY" -ROSETRY = ROSETRY() +ROSEUSDT = ROSEUSDT() @dataclass(slots=True, frozen=True) class ROSEUSDT: + """ + name: ROSEUSDT + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 9000000.00000000 + margin: True + """ name: str = "ROSEUSDT" precision: int = 8 minimum_margin: float = None @@ -36936,11 +51395,20 @@ def __call__(self): return "ROSEUSDT" -ROSEUSDT = ROSEUSDT() +RPXBNB = RPXBNB() @dataclass(slots=True, frozen=True) class RPXBNB: + """ + name: RPXBNB + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 9000000.00000000 + margin: False + """ name: str = "RPXBNB" precision: int = 8 minimum_margin: float = None @@ -36959,11 +51427,20 @@ def __call__(self): return "RPXBNB" -RPXBNB = RPXBNB() +RPXBTC = RPXBTC() @dataclass(slots=True, frozen=True) class RPXBTC: + """ + name: RPXBTC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 90000000.00000000 + margin: False + """ name: str = "RPXBTC" precision: int = 8 minimum_margin: float = None @@ -36982,11 +51459,20 @@ def __call__(self): return "RPXBTC" -RPXBTC = RPXBTC() +RPXETH = RPXETH() @dataclass(slots=True, frozen=True) class RPXETH: + """ + name: RPXETH + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 90000000.00000000 + margin: False + """ name: str = "RPXETH" precision: int = 8 minimum_margin: float = None @@ -37005,11 +51491,20 @@ def __call__(self): return "RPXETH" -RPXETH = RPXETH() +RSRBNB = RSRBNB() @dataclass(slots=True, frozen=True) class RSRBNB: + """ + name: RSRBNB + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 9000000.00000000 + margin: False + """ name: str = "RSRBNB" precision: int = 8 minimum_margin: float = None @@ -37028,11 +51523,20 @@ def __call__(self): return "RSRBNB" -RSRBNB = RSRBNB() +RSRBTC = RSRBTC() @dataclass(slots=True, frozen=True) class RSRBTC: + """ + name: RSRBTC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 90000000.00000000 + margin: False + """ name: str = "RSRBTC" precision: int = 8 minimum_margin: float = None @@ -37051,11 +51555,20 @@ def __call__(self): return "RSRBTC" -RSRBTC = RSRBTC() +RSRBUSD = RSRBUSD() @dataclass(slots=True, frozen=True) class RSRBUSD: + """ + name: RSRBUSD + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 9000000.00000000 + margin: True + """ name: str = "RSRBUSD" precision: int = 8 minimum_margin: float = None @@ -37074,11 +51587,20 @@ def __call__(self): return "RSRBUSD" -RSRBUSD = RSRBUSD() +RSRUSDT = RSRUSDT() @dataclass(slots=True, frozen=True) class RSRUSDT: + """ + name: RSRUSDT + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 9000000.00000000 + margin: True + """ name: str = "RSRUSDT" precision: int = 8 minimum_margin: float = None @@ -37097,11 +51619,20 @@ def __call__(self): return "RSRUSDT" -RSRUSDT = RSRUSDT() +RUNEAUD = RUNEAUD() @dataclass(slots=True, frozen=True) class RUNEAUD: + """ + name: RUNEAUD + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.00000100 + maximum_order_size: 9222449.00000000 + margin: False + """ name: str = "RUNEAUD" precision: int = 8 minimum_margin: float = None @@ -37120,11 +51651,20 @@ def __call__(self): return "RUNEAUD" -RUNEAUD = RUNEAUD() +RUNEBNB = RUNEBNB() @dataclass(slots=True, frozen=True) class RUNEBNB: + """ + name: RUNEBNB + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 9000000.00000000 + margin: False + """ name: str = "RUNEBNB" precision: int = 8 minimum_margin: float = None @@ -37143,11 +51683,20 @@ def __call__(self): return "RUNEBNB" -RUNEBNB = RUNEBNB() +RUNEBTC = RUNEBTC() @dataclass(slots=True, frozen=True) class RUNEBTC: + """ + name: RUNEBTC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 90000000.00000000 + margin: True + """ name: str = "RUNEBTC" precision: int = 8 minimum_margin: float = None @@ -37166,11 +51715,20 @@ def __call__(self): return "RUNEBTC" -RUNEBTC = RUNEBTC() +RUNEBUSD = RUNEBUSD() @dataclass(slots=True, frozen=True) class RUNEBUSD: + """ + name: RUNEBUSD + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 90000.00000000 + margin: True + """ name: str = "RUNEBUSD" precision: int = 8 minimum_margin: float = None @@ -37189,11 +51747,20 @@ def __call__(self): return "RUNEBUSD" -RUNEBUSD = RUNEBUSD() +RUNEETH = RUNEETH() @dataclass(slots=True, frozen=True) class RUNEETH: + """ + name: RUNEETH + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.00100000 + maximum_order_size: 92141578.00000000 + margin: False + """ name: str = "RUNEETH" precision: int = 8 minimum_margin: float = None @@ -37212,11 +51779,20 @@ def __call__(self): return "RUNEETH" -RUNEETH = RUNEETH() +RUNEEUR = RUNEEUR() @dataclass(slots=True, frozen=True) class RUNEEUR: + """ + name: RUNEEUR + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 9222449.00000000 + margin: False + """ name: str = "RUNEEUR" precision: int = 8 minimum_margin: float = None @@ -37235,11 +51811,20 @@ def __call__(self): return "RUNEEUR" -RUNEEUR = RUNEEUR() +RUNEGBP = RUNEGBP() @dataclass(slots=True, frozen=True) class RUNEGBP: + """ + name: RUNEGBP + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 9222449.00000000 + margin: False + """ name: str = "RUNEGBP" precision: int = 8 minimum_margin: float = None @@ -37258,11 +51843,20 @@ def __call__(self): return "RUNEGBP" -RUNEGBP = RUNEGBP() +RUNETRY = RUNETRY() @dataclass(slots=True, frozen=True) class RUNETRY: + """ + name: RUNETRY + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 9222449.00000000 + margin: False + """ name: str = "RUNETRY" precision: int = 8 minimum_margin: float = None @@ -37281,11 +51875,20 @@ def __call__(self): return "RUNETRY" -RUNETRY = RUNETRY() +RUNEUSDT = RUNEUSDT() @dataclass(slots=True, frozen=True) class RUNEUSDT: + """ + name: RUNEUSDT + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 90000.00000000 + margin: True + """ name: str = "RUNEUSDT" precision: int = 8 minimum_margin: float = None @@ -37304,11 +51907,20 @@ def __call__(self): return "RUNEUSDT" -RUNEUSDT = RUNEUSDT() +RVNBTC = RVNBTC() @dataclass(slots=True, frozen=True) class RVNBTC: + """ + name: RVNBTC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 90000000.00000000 + margin: True + """ name: str = "RVNBTC" precision: int = 8 minimum_margin: float = None @@ -37327,11 +51939,20 @@ def __call__(self): return "RVNBTC" -RVNBTC = RVNBTC() +RVNBUSD = RVNBUSD() @dataclass(slots=True, frozen=True) class RVNBUSD: + """ + name: RVNBUSD + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 9000000.00000000 + margin: False + """ name: str = "RVNBUSD" precision: int = 8 minimum_margin: float = None @@ -37350,11 +51971,20 @@ def __call__(self): return "RVNBUSD" -RVNBUSD = RVNBUSD() +RVNTRY = RVNTRY() @dataclass(slots=True, frozen=True) class RVNTRY: + """ + name: RVNTRY + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 92141578.00000000 + margin: False + """ name: str = "RVNTRY" precision: int = 8 minimum_margin: float = None @@ -37373,11 +52003,20 @@ def __call__(self): return "RVNTRY" -RVNTRY = RVNTRY() +RVNUSDT = RVNUSDT() @dataclass(slots=True, frozen=True) class RVNUSDT: + """ + name: RVNUSDT + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 9000000.00000000 + margin: True + """ name: str = "RVNUSDT" precision: int = 8 minimum_margin: float = None @@ -37396,11 +52035,20 @@ def __call__(self): return "RVNUSDT" -RVNUSDT = RVNUSDT() +SALTBTC = SALTBTC() @dataclass(slots=True, frozen=True) class SALTBTC: + """ + name: SALTBTC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 90000000.00000000 + margin: False + """ name: str = "SALTBTC" precision: int = 8 minimum_margin: float = None @@ -37419,11 +52067,20 @@ def __call__(self): return "SALTBTC" -SALTBTC = SALTBTC() +SALTETH = SALTETH() @dataclass(slots=True, frozen=True) class SALTETH: + """ + name: SALTETH + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 90000000.00000000 + margin: False + """ name: str = "SALTETH" precision: int = 8 minimum_margin: float = None @@ -37442,11 +52099,20 @@ def __call__(self): return "SALTETH" -SALTETH = SALTETH() +SANDAUD = SANDAUD() @dataclass(slots=True, frozen=True) class SANDAUD: + """ + name: SANDAUD + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 9222449.00000000 + margin: False + """ name: str = "SANDAUD" precision: int = 8 minimum_margin: float = None @@ -37465,11 +52131,20 @@ def __call__(self): return "SANDAUD" -SANDAUD = SANDAUD() +SANDBIDR = SANDBIDR() @dataclass(slots=True, frozen=True) class SANDBIDR: + """ + name: SANDBIDR + precision: 2 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 9223371110.00000000 + margin: False + """ name: str = "SANDBIDR" precision: int = 2 minimum_margin: float = None @@ -37488,11 +52163,20 @@ def __call__(self): return "SANDBIDR" -SANDBIDR = SANDBIDR() +SANDBNB = SANDBNB() @dataclass(slots=True, frozen=True) class SANDBNB: + """ + name: SANDBNB + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 9000000.00000000 + margin: False + """ name: str = "SANDBNB" precision: int = 8 minimum_margin: float = None @@ -37511,11 +52195,20 @@ def __call__(self): return "SANDBNB" -SANDBNB = SANDBNB() +SANDBRL = SANDBRL() @dataclass(slots=True, frozen=True) class SANDBRL: + """ + name: SANDBRL + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 9222449.00000000 + margin: False + """ name: str = "SANDBRL" precision: int = 8 minimum_margin: float = None @@ -37534,11 +52227,20 @@ def __call__(self): return "SANDBRL" -SANDBRL = SANDBRL() +SANDBTC = SANDBTC() @dataclass(slots=True, frozen=True) class SANDBTC: + """ + name: SANDBTC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 90000000.00000000 + margin: True + """ name: str = "SANDBTC" precision: int = 8 minimum_margin: float = None @@ -37557,11 +52259,20 @@ def __call__(self): return "SANDBTC" -SANDBTC = SANDBTC() +SANDBUSD = SANDBUSD() @dataclass(slots=True, frozen=True) class SANDBUSD: + """ + name: SANDBUSD + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 9000000.00000000 + margin: True + """ name: str = "SANDBUSD" precision: int = 8 minimum_margin: float = None @@ -37580,11 +52291,20 @@ def __call__(self): return "SANDBUSD" -SANDBUSD = SANDBUSD() +SANDETH = SANDETH() @dataclass(slots=True, frozen=True) class SANDETH: + """ + name: SANDETH + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 92141578.00000000 + margin: False + """ name: str = "SANDETH" precision: int = 8 minimum_margin: float = None @@ -37603,11 +52323,20 @@ def __call__(self): return "SANDETH" -SANDETH = SANDETH() +SANDTRY = SANDTRY() @dataclass(slots=True, frozen=True) class SANDTRY: + """ + name: SANDTRY + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 9222449.00000000 + margin: False + """ name: str = "SANDTRY" precision: int = 8 minimum_margin: float = None @@ -37626,11 +52355,20 @@ def __call__(self): return "SANDTRY" -SANDTRY = SANDTRY() +SANDUSDT = SANDUSDT() @dataclass(slots=True, frozen=True) class SANDUSDT: + """ + name: SANDUSDT + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 9000000.00000000 + margin: True + """ name: str = "SANDUSDT" precision: int = 8 minimum_margin: float = None @@ -37649,11 +52387,20 @@ def __call__(self): return "SANDUSDT" -SANDUSDT = SANDUSDT() +SANTOSBRL = SANTOSBRL() @dataclass(slots=True, frozen=True) class SANTOSBRL: + """ + name: SANTOSBRL + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 9222449.00000000 + margin: False + """ name: str = "SANTOSBRL" precision: int = 8 minimum_margin: float = None @@ -37672,11 +52419,20 @@ def __call__(self): return "SANTOSBRL" -SANTOSBRL = SANTOSBRL() +SANTOSBTC = SANTOSBTC() @dataclass(slots=True, frozen=True) class SANTOSBTC: + """ + name: SANTOSBTC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 92141578.00000000 + margin: False + """ name: str = "SANTOSBTC" precision: int = 8 minimum_margin: float = None @@ -37695,11 +52451,20 @@ def __call__(self): return "SANTOSBTC" -SANTOSBTC = SANTOSBTC() +SANTOSBUSD = SANTOSBUSD() @dataclass(slots=True, frozen=True) class SANTOSBUSD: + """ + name: SANTOSBUSD + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 92141578.00000000 + margin: True + """ name: str = "SANTOSBUSD" precision: int = 8 minimum_margin: float = None @@ -37718,11 +52483,20 @@ def __call__(self): return "SANTOSBUSD" -SANTOSBUSD = SANTOSBUSD() +SANTOSTRY = SANTOSTRY() @dataclass(slots=True, frozen=True) class SANTOSTRY: + """ + name: SANTOSTRY + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 9222449.00000000 + margin: False + """ name: str = "SANTOSTRY" precision: int = 8 minimum_margin: float = None @@ -37741,11 +52515,20 @@ def __call__(self): return "SANTOSTRY" -SANTOSTRY = SANTOSTRY() +SANTOSUSDT = SANTOSUSDT() @dataclass(slots=True, frozen=True) class SANTOSUSDT: + """ + name: SANTOSUSDT + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 92141578.00000000 + margin: True + """ name: str = "SANTOSUSDT" precision: int = 8 minimum_margin: float = None @@ -37764,11 +52547,20 @@ def __call__(self): return "SANTOSUSDT" -SANTOSUSDT = SANTOSUSDT() +SCBTC = SCBTC() @dataclass(slots=True, frozen=True) class SCBTC: + """ + name: SCBTC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 92141578.00000000 + margin: False + """ name: str = "SCBTC" precision: int = 8 minimum_margin: float = None @@ -37787,11 +52579,20 @@ def __call__(self): return "SCBTC" -SCBTC = SCBTC() +SCBUSD = SCBUSD() @dataclass(slots=True, frozen=True) class SCBUSD: + """ + name: SCBUSD + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 9222449.00000000 + margin: True + """ name: str = "SCBUSD" precision: int = 8 minimum_margin: float = None @@ -37810,11 +52611,20 @@ def __call__(self): return "SCBUSD" -SCBUSD = SCBUSD() +SCETH = SCETH() @dataclass(slots=True, frozen=True) class SCETH: + """ + name: SCETH + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 90000000.00000000 + margin: False + """ name: str = "SCETH" precision: int = 8 minimum_margin: float = None @@ -37833,11 +52643,20 @@ def __call__(self): return "SCETH" -SCETH = SCETH() +SCRTBTC = SCRTBTC() @dataclass(slots=True, frozen=True) class SCRTBTC: + """ + name: SCRTBTC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 90000000.00000000 + margin: False + """ name: str = "SCRTBTC" precision: int = 8 minimum_margin: float = None @@ -37856,11 +52675,20 @@ def __call__(self): return "SCRTBTC" -SCRTBTC = SCRTBTC() +SCRTBUSD = SCRTBUSD() @dataclass(slots=True, frozen=True) class SCRTBUSD: + """ + name: SCRTBUSD + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 92141578.00000000 + margin: False + """ name: str = "SCRTBUSD" precision: int = 8 minimum_margin: float = None @@ -37879,11 +52707,20 @@ def __call__(self): return "SCRTBUSD" -SCRTBUSD = SCRTBUSD() +SCRTETH = SCRTETH() @dataclass(slots=True, frozen=True) class SCRTETH: + """ + name: SCRTETH + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 90000000.00000000 + margin: False + """ name: str = "SCRTETH" precision: int = 8 minimum_margin: float = None @@ -37902,11 +52739,20 @@ def __call__(self): return "SCRTETH" -SCRTETH = SCRTETH() +SCRTUSDT = SCRTUSDT() @dataclass(slots=True, frozen=True) class SCRTUSDT: + """ + name: SCRTUSDT + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 92141578.00000000 + margin: False + """ name: str = "SCRTUSDT" precision: int = 8 minimum_margin: float = None @@ -37925,11 +52771,20 @@ def __call__(self): return "SCRTUSDT" -SCRTUSDT = SCRTUSDT() +SCUSDT = SCUSDT() @dataclass(slots=True, frozen=True) class SCUSDT: + """ + name: SCUSDT + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 92141578.00000000 + margin: True + """ name: str = "SCUSDT" precision: int = 8 minimum_margin: float = None @@ -37948,11 +52803,20 @@ def __call__(self): return "SCUSDT" -SCUSDT = SCUSDT() +SFPBTC = SFPBTC() @dataclass(slots=True, frozen=True) class SFPBTC: + """ + name: SFPBTC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 90000000.00000000 + margin: True + """ name: str = "SFPBTC" precision: int = 8 minimum_margin: float = None @@ -37971,11 +52835,20 @@ def __call__(self): return "SFPBTC" -SFPBTC = SFPBTC() +SFPBUSD = SFPBUSD() @dataclass(slots=True, frozen=True) class SFPBUSD: + """ + name: SFPBUSD + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 900000.00000000 + margin: True + """ name: str = "SFPBUSD" precision: int = 8 minimum_margin: float = None @@ -37994,11 +52867,20 @@ def __call__(self): return "SFPBUSD" -SFPBUSD = SFPBUSD() +SFPUSDT = SFPUSDT() @dataclass(slots=True, frozen=True) class SFPUSDT: + """ + name: SFPUSDT + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 900000.00000000 + margin: True + """ name: str = "SFPUSDT" precision: int = 8 minimum_margin: float = None @@ -38017,11 +52899,20 @@ def __call__(self): return "SFPUSDT" -SFPUSDT = SFPUSDT() +SHIBAUD = SHIBAUD() @dataclass(slots=True, frozen=True) class SHIBAUD: + """ + name: SHIBAUD + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00 + maximum_order_size: 46116860414.00 + margin: False + """ name: str = "SHIBAUD" precision: int = 8 minimum_margin: float = None @@ -38040,11 +52931,20 @@ def __call__(self): return "SHIBAUD" -SHIBAUD = SHIBAUD() +SHIBBRL = SHIBBRL() @dataclass(slots=True, frozen=True) class SHIBBRL: + """ + name: SHIBBRL + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00 + maximum_order_size: 46116860414.00 + margin: False + """ name: str = "SHIBBRL" precision: int = 8 minimum_margin: float = None @@ -38063,11 +52963,20 @@ def __call__(self): return "SHIBBRL" -SHIBBRL = SHIBBRL() +SHIBBUSD = SHIBBUSD() @dataclass(slots=True, frozen=True) class SHIBBUSD: + """ + name: SHIBBUSD + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00 + maximum_order_size: 46116860414.00 + margin: True + """ name: str = "SHIBBUSD" precision: int = 8 minimum_margin: float = None @@ -38086,11 +52995,20 @@ def __call__(self): return "SHIBBUSD" -SHIBBUSD = SHIBBUSD() +SHIBDOGE = SHIBDOGE() @dataclass(slots=True, frozen=True) class SHIBDOGE: + """ + name: SHIBDOGE + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00 + maximum_order_size: 46116860414.00 + margin: True + """ name: str = "SHIBDOGE" precision: int = 8 minimum_margin: float = None @@ -38109,11 +53027,20 @@ def __call__(self): return "SHIBDOGE" -SHIBDOGE = SHIBDOGE() +SHIBEUR = SHIBEUR() @dataclass(slots=True, frozen=True) class SHIBEUR: + """ + name: SHIBEUR + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00 + maximum_order_size: 46116860414.00 + margin: False + """ name: str = "SHIBEUR" precision: int = 8 minimum_margin: float = None @@ -38132,11 +53059,20 @@ def __call__(self): return "SHIBEUR" -SHIBEUR = SHIBEUR() +SHIBGBP = SHIBGBP() @dataclass(slots=True, frozen=True) class SHIBGBP: + """ + name: SHIBGBP + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00 + maximum_order_size: 46116860414.00 + margin: False + """ name: str = "SHIBGBP" precision: int = 8 minimum_margin: float = None @@ -38155,11 +53091,20 @@ def __call__(self): return "SHIBGBP" -SHIBGBP = SHIBGBP() +SHIBRUB = SHIBRUB() @dataclass(slots=True, frozen=True) class SHIBRUB: + """ + name: SHIBRUB + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00 + maximum_order_size: 46116860414.00 + margin: False + """ name: str = "SHIBRUB" precision: int = 8 minimum_margin: float = None @@ -38178,11 +53123,20 @@ def __call__(self): return "SHIBRUB" -SHIBRUB = SHIBRUB() +SHIBTRY = SHIBTRY() @dataclass(slots=True, frozen=True) class SHIBTRY: + """ + name: SHIBTRY + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00 + maximum_order_size: 46116860414.00 + margin: False + """ name: str = "SHIBTRY" precision: int = 8 minimum_margin: float = None @@ -38201,11 +53155,20 @@ def __call__(self): return "SHIBTRY" -SHIBTRY = SHIBTRY() +SHIBUAH = SHIBUAH() @dataclass(slots=True, frozen=True) class SHIBUAH: + """ + name: SHIBUAH + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00 + maximum_order_size: 92141578.00 + margin: False + """ name: str = "SHIBUAH" precision: int = 8 minimum_margin: float = None @@ -38224,11 +53187,20 @@ def __call__(self): return "SHIBUAH" -SHIBUAH = SHIBUAH() +SHIBUSDT = SHIBUSDT() @dataclass(slots=True, frozen=True) class SHIBUSDT: + """ + name: SHIBUSDT + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00 + maximum_order_size: 46116860414.00 + margin: True + """ name: str = "SHIBUSDT" precision: int = 8 minimum_margin: float = None @@ -38247,11 +53219,20 @@ def __call__(self): return "SHIBUSDT" -SHIBUSDT = SHIBUSDT() +SKLBTC = SKLBTC() @dataclass(slots=True, frozen=True) class SKLBTC: + """ + name: SKLBTC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 90000000.00000000 + margin: True + """ name: str = "SKLBTC" precision: int = 8 minimum_margin: float = None @@ -38270,11 +53251,20 @@ def __call__(self): return "SKLBTC" -SKLBTC = SKLBTC() +SKLBUSD = SKLBUSD() @dataclass(slots=True, frozen=True) class SKLBUSD: + """ + name: SKLBUSD + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 9000000.00000000 + margin: True + """ name: str = "SKLBUSD" precision: int = 8 minimum_margin: float = None @@ -38293,11 +53283,20 @@ def __call__(self): return "SKLBUSD" -SKLBUSD = SKLBUSD() +SKLUSDT = SKLUSDT() @dataclass(slots=True, frozen=True) class SKLUSDT: + """ + name: SKLUSDT + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 9000000.00000000 + margin: True + """ name: str = "SKLUSDT" precision: int = 8 minimum_margin: float = None @@ -38316,11 +53315,20 @@ def __call__(self): return "SKLUSDT" -SKLUSDT = SKLUSDT() +SKYBNB = SKYBNB() @dataclass(slots=True, frozen=True) class SKYBNB: + """ + name: SKYBNB + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 9000000.00000000 + margin: False + """ name: str = "SKYBNB" precision: int = 8 minimum_margin: float = None @@ -38339,11 +53347,20 @@ def __call__(self): return "SKYBNB" -SKYBNB = SKYBNB() +SKYBTC = SKYBTC() @dataclass(slots=True, frozen=True) class SKYBTC: + """ + name: SKYBTC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 90000000.00000000 + margin: False + """ name: str = "SKYBTC" precision: int = 8 minimum_margin: float = None @@ -38362,11 +53379,20 @@ def __call__(self): return "SKYBTC" -SKYBTC = SKYBTC() +SKYETH = SKYETH() @dataclass(slots=True, frozen=True) class SKYETH: + """ + name: SKYETH + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.00100000 + maximum_order_size: 9000000.00000000 + margin: False + """ name: str = "SKYETH" precision: int = 8 minimum_margin: float = None @@ -38385,11 +53411,20 @@ def __call__(self): return "SKYETH" -SKYETH = SKYETH() +SLPBIDR = SLPBIDR() @dataclass(slots=True, frozen=True) class SLPBIDR: + """ + name: SLPBIDR + precision: 2 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 9223362229.00000000 + margin: False + """ name: str = "SLPBIDR" precision: int = 2 minimum_margin: float = None @@ -38408,11 +53443,20 @@ def __call__(self): return "SLPBIDR" -SLPBIDR = SLPBIDR() +SLPBNB = SLPBNB() @dataclass(slots=True, frozen=True) class SLPBNB: + """ + name: SLPBNB + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 92141578.00000000 + margin: False + """ name: str = "SLPBNB" precision: int = 8 minimum_margin: float = None @@ -38431,11 +53475,20 @@ def __call__(self): return "SLPBNB" -SLPBNB = SLPBNB() +SLPBUSD = SLPBUSD() @dataclass(slots=True, frozen=True) class SLPBUSD: + """ + name: SLPBUSD + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 90000000.00000000 + margin: True + """ name: str = "SLPBUSD" precision: int = 8 minimum_margin: float = None @@ -38454,11 +53507,20 @@ def __call__(self): return "SLPBUSD" -SLPBUSD = SLPBUSD() +SLPETH = SLPETH() @dataclass(slots=True, frozen=True) class SLPETH: + """ + name: SLPETH + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 90000000.00000000 + margin: True + """ name: str = "SLPETH" precision: int = 8 minimum_margin: float = None @@ -38477,11 +53539,20 @@ def __call__(self): return "SLPETH" -SLPETH = SLPETH() +SLPTRY = SLPTRY() @dataclass(slots=True, frozen=True) class SLPTRY: + """ + name: SLPTRY + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 92141578.00000000 + margin: False + """ name: str = "SLPTRY" precision: int = 8 minimum_margin: float = None @@ -38500,11 +53571,20 @@ def __call__(self): return "SLPTRY" -SLPTRY = SLPTRY() +SLPUSDT = SLPUSDT() @dataclass(slots=True, frozen=True) class SLPUSDT: + """ + name: SLPUSDT + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 90000000.00000000 + margin: True + """ name: str = "SLPUSDT" precision: int = 8 minimum_margin: float = None @@ -38523,11 +53603,20 @@ def __call__(self): return "SLPUSDT" -SLPUSDT = SLPUSDT() +SNGLSBTC = SNGLSBTC() @dataclass(slots=True, frozen=True) class SNGLSBTC: + """ + name: SNGLSBTC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 90000000.00000000 + margin: False + """ name: str = "SNGLSBTC" precision: int = 8 minimum_margin: float = None @@ -38546,11 +53635,20 @@ def __call__(self): return "SNGLSBTC" -SNGLSBTC = SNGLSBTC() +SNGLSETH = SNGLSETH() @dataclass(slots=True, frozen=True) class SNGLSETH: + """ + name: SNGLSETH + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 90000000.00000000 + margin: False + """ name: str = "SNGLSETH" precision: int = 8 minimum_margin: float = None @@ -38569,11 +53667,20 @@ def __call__(self): return "SNGLSETH" -SNGLSETH = SNGLSETH() +SNMBTC = SNMBTC() @dataclass(slots=True, frozen=True) class SNMBTC: + """ + name: SNMBTC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 90000000.00000000 + margin: False + """ name: str = "SNMBTC" precision: int = 8 minimum_margin: float = None @@ -38592,11 +53699,20 @@ def __call__(self): return "SNMBTC" -SNMBTC = SNMBTC() +SNMBUSD = SNMBUSD() @dataclass(slots=True, frozen=True) class SNMBUSD: + """ + name: SNMBUSD + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 92141578.00000000 + margin: True + """ name: str = "SNMBUSD" precision: int = 8 minimum_margin: float = None @@ -38615,11 +53731,20 @@ def __call__(self): return "SNMBUSD" -SNMBUSD = SNMBUSD() +SNMETH = SNMETH() @dataclass(slots=True, frozen=True) class SNMETH: + """ + name: SNMETH + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 90000000.00000000 + margin: False + """ name: str = "SNMETH" precision: int = 8 minimum_margin: float = None @@ -38638,11 +53763,20 @@ def __call__(self): return "SNMETH" -SNMETH = SNMETH() +SNTBTC = SNTBTC() @dataclass(slots=True, frozen=True) class SNTBTC: + """ + name: SNTBTC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 90000000.00000000 + margin: False + """ name: str = "SNTBTC" precision: int = 8 minimum_margin: float = None @@ -38661,11 +53795,20 @@ def __call__(self): return "SNTBTC" -SNTBTC = SNTBTC() +SNTBUSD = SNTBUSD() @dataclass(slots=True, frozen=True) class SNTBUSD: + """ + name: SNTBUSD + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 92141578.00000000 + margin: False + """ name: str = "SNTBUSD" precision: int = 8 minimum_margin: float = None @@ -38684,11 +53827,20 @@ def __call__(self): return "SNTBUSD" -SNTBUSD = SNTBUSD() +SNTETH = SNTETH() @dataclass(slots=True, frozen=True) class SNTETH: + """ + name: SNTETH + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 90000000.00000000 + margin: False + """ name: str = "SNTETH" precision: int = 8 minimum_margin: float = None @@ -38707,11 +53859,20 @@ def __call__(self): return "SNTETH" -SNTETH = SNTETH() +SNXBNB = SNXBNB() @dataclass(slots=True, frozen=True) class SNXBNB: + """ + name: SNXBNB + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 9000000.00000000 + margin: False + """ name: str = "SNXBNB" precision: int = 8 minimum_margin: float = None @@ -38730,11 +53891,20 @@ def __call__(self): return "SNXBNB" -SNXBNB = SNXBNB() +SNXBTC = SNXBTC() @dataclass(slots=True, frozen=True) class SNXBTC: + """ + name: SNXBTC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 90000000.00000000 + margin: True + """ name: str = "SNXBTC" precision: int = 8 minimum_margin: float = None @@ -38753,11 +53923,20 @@ def __call__(self): return "SNXBTC" -SNXBTC = SNXBTC() +SNXBUSD = SNXBUSD() @dataclass(slots=True, frozen=True) class SNXBUSD: + """ + name: SNXBUSD + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 90000.00000000 + margin: True + """ name: str = "SNXBUSD" precision: int = 8 minimum_margin: float = None @@ -38776,11 +53955,20 @@ def __call__(self): return "SNXBUSD" -SNXBUSD = SNXBUSD() +SNXETH = SNXETH() @dataclass(slots=True, frozen=True) class SNXETH: + """ + name: SNXETH + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 92141578.00000000 + margin: False + """ name: str = "SNXETH" precision: int = 8 minimum_margin: float = None @@ -38799,11 +53987,20 @@ def __call__(self): return "SNXETH" -SNXETH = SNXETH() +SNXUSDT = SNXUSDT() @dataclass(slots=True, frozen=True) class SNXUSDT: + """ + name: SNXUSDT + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 90000.00000000 + margin: True + """ name: str = "SNXUSDT" precision: int = 8 minimum_margin: float = None @@ -38822,11 +54019,20 @@ def __call__(self): return "SNXUSDT" -SNXUSDT = SNXUSDT() +SOLAUD = SOLAUD() @dataclass(slots=True, frozen=True) class SOLAUD: + """ + name: SOLAUD + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.00100000 + maximum_order_size: 922327.00000000 + margin: False + """ name: str = "SOLAUD" precision: int = 8 minimum_margin: float = None @@ -38845,11 +54051,20 @@ def __call__(self): return "SOLAUD" -SOLAUD = SOLAUD() +SOLBIDR = SOLBIDR() @dataclass(slots=True, frozen=True) class SOLBIDR: + """ + name: SOLBIDR + precision: 2 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.00010000 + maximum_order_size: 9223372.00000000 + margin: False + """ name: str = "SOLBIDR" precision: int = 2 minimum_margin: float = None @@ -38868,11 +54083,20 @@ def __call__(self): return "SOLBIDR" -SOLBIDR = SOLBIDR() +SOLBNB = SOLBNB() @dataclass(slots=True, frozen=True) class SOLBNB: + """ + name: SOLBNB + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 9000000.00000000 + margin: False + """ name: str = "SOLBNB" precision: int = 8 minimum_margin: float = None @@ -38891,11 +54115,20 @@ def __call__(self): return "SOLBNB" -SOLBNB = SOLBNB() +SOLBRL = SOLBRL() @dataclass(slots=True, frozen=True) class SOLBRL: + """ + name: SOLBRL + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 9222449.00000000 + margin: False + """ name: str = "SOLBRL" precision: int = 8 minimum_margin: float = None @@ -38914,11 +54147,20 @@ def __call__(self): return "SOLBRL" -SOLBRL = SOLBRL() +SOLBTC = SOLBTC() @dataclass(slots=True, frozen=True) class SOLBTC: + """ + name: SOLBTC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 90000000.00000000 + margin: True + """ name: str = "SOLBTC" precision: int = 8 minimum_margin: float = None @@ -38937,11 +54179,20 @@ def __call__(self): return "SOLBTC" -SOLBTC = SOLBTC() +SOLBUSD = SOLBUSD() @dataclass(slots=True, frozen=True) class SOLBUSD: + """ + name: SOLBUSD + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 90000.00000000 + margin: True + """ name: str = "SOLBUSD" precision: int = 8 minimum_margin: float = None @@ -38960,11 +54211,20 @@ def __call__(self): return "SOLBUSD" -SOLBUSD = SOLBUSD() +SOLETH = SOLETH() @dataclass(slots=True, frozen=True) class SOLETH: + """ + name: SOLETH + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.00100000 + maximum_order_size: 92141578.00000000 + margin: False + """ name: str = "SOLETH" precision: int = 8 minimum_margin: float = None @@ -38983,11 +54243,20 @@ def __call__(self): return "SOLETH" -SOLETH = SOLETH() +SOLEUR = SOLEUR() @dataclass(slots=True, frozen=True) class SOLEUR: + """ + name: SOLEUR + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 9222440.00000000 + margin: False + """ name: str = "SOLEUR" precision: int = 8 minimum_margin: float = None @@ -39006,11 +54275,20 @@ def __call__(self): return "SOLEUR" -SOLEUR = SOLEUR() +SOLGBP = SOLGBP() @dataclass(slots=True, frozen=True) class SOLGBP: + """ + name: SOLGBP + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 9222449.00000000 + margin: False + """ name: str = "SOLGBP" precision: int = 8 minimum_margin: float = None @@ -39029,11 +54307,20 @@ def __call__(self): return "SOLGBP" -SOLGBP = SOLGBP() +SOLRUB = SOLRUB() @dataclass(slots=True, frozen=True) class SOLRUB: + """ + name: SOLRUB + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 92233.00000000 + margin: False + """ name: str = "SOLRUB" precision: int = 8 minimum_margin: float = None @@ -39052,11 +54339,20 @@ def __call__(self): return "SOLRUB" -SOLRUB = SOLRUB() +SOLTRY = SOLTRY() @dataclass(slots=True, frozen=True) class SOLTRY: + """ + name: SOLTRY + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 3074353.00000000 + margin: False + """ name: str = "SOLTRY" precision: int = 8 minimum_margin: float = None @@ -39075,11 +54371,20 @@ def __call__(self): return "SOLTRY" -SOLTRY = SOLTRY() +SOLUSDC = SOLUSDC() @dataclass(slots=True, frozen=True) class SOLUSDC: + """ + name: SOLUSDC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 922327.00000000 + margin: False + """ name: str = "SOLUSDC" precision: int = 8 minimum_margin: float = None @@ -39098,11 +54403,20 @@ def __call__(self): return "SOLUSDC" -SOLUSDC = SOLUSDC() +SOLUSDT = SOLUSDT() @dataclass(slots=True, frozen=True) class SOLUSDT: + """ + name: SOLUSDT + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 90000.00000000 + margin: True + """ name: str = "SOLUSDT" precision: int = 8 minimum_margin: float = None @@ -39121,11 +54435,20 @@ def __call__(self): return "SOLUSDT" -SOLUSDT = SOLUSDT() +SPARTABNB = SPARTABNB() @dataclass(slots=True, frozen=True) class SPARTABNB: + """ + name: SPARTABNB + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 9000000.00000000 + margin: False + """ name: str = "SPARTABNB" precision: int = 8 minimum_margin: float = None @@ -39144,11 +54467,20 @@ def __call__(self): return "SPARTABNB" -SPARTABNB = SPARTABNB() +SPELLBNB = SPELLBNB() @dataclass(slots=True, frozen=True) class SPELLBNB: + """ + name: SPELLBNB + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 92141578.00000000 + margin: False + """ name: str = "SPELLBNB" precision: int = 8 minimum_margin: float = None @@ -39167,11 +54499,20 @@ def __call__(self): return "SPELLBNB" -SPELLBNB = SPELLBNB() +SPELLBTC = SPELLBTC() @dataclass(slots=True, frozen=True) class SPELLBTC: + """ + name: SPELLBTC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 92141578.00000000 + margin: False + """ name: str = "SPELLBTC" precision: int = 8 minimum_margin: float = None @@ -39190,11 +54531,20 @@ def __call__(self): return "SPELLBTC" -SPELLBTC = SPELLBTC() +SPELLBUSD = SPELLBUSD() @dataclass(slots=True, frozen=True) class SPELLBUSD: + """ + name: SPELLBUSD + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 92141578.00000000 + margin: True + """ name: str = "SPELLBUSD" precision: int = 8 minimum_margin: float = None @@ -39213,11 +54563,20 @@ def __call__(self): return "SPELLBUSD" -SPELLBUSD = SPELLBUSD() +SPELLTRY = SPELLTRY() @dataclass(slots=True, frozen=True) class SPELLTRY: + """ + name: SPELLTRY + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 92141578.00000000 + margin: False + """ name: str = "SPELLTRY" precision: int = 8 minimum_margin: float = None @@ -39236,11 +54595,20 @@ def __call__(self): return "SPELLTRY" -SPELLTRY = SPELLTRY() +SPELLUSDT = SPELLUSDT() @dataclass(slots=True, frozen=True) class SPELLUSDT: + """ + name: SPELLUSDT + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 92141578.00000000 + margin: True + """ name: str = "SPELLUSDT" precision: int = 8 minimum_margin: float = None @@ -39259,11 +54627,20 @@ def __call__(self): return "SPELLUSDT" -SPELLUSDT = SPELLUSDT() +SRMBIDR = SRMBIDR() @dataclass(slots=True, frozen=True) class SRMBIDR: + """ + name: SRMBIDR + precision: 2 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.00100000 + maximum_order_size: 100000.00000000 + margin: False + """ name: str = "SRMBIDR" precision: int = 2 minimum_margin: float = None @@ -39282,11 +54659,20 @@ def __call__(self): return "SRMBIDR" -SRMBIDR = SRMBIDR() +SRMBNB = SRMBNB() @dataclass(slots=True, frozen=True) class SRMBNB: + """ + name: SRMBNB + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 9000000.00000000 + margin: False + """ name: str = "SRMBNB" precision: int = 8 minimum_margin: float = None @@ -39305,11 +54691,20 @@ def __call__(self): return "SRMBNB" -SRMBNB = SRMBNB() +SRMBTC = SRMBTC() @dataclass(slots=True, frozen=True) class SRMBTC: + """ + name: SRMBTC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 90000000.00000000 + margin: False + """ name: str = "SRMBTC" precision: int = 8 minimum_margin: float = None @@ -39328,11 +54723,20 @@ def __call__(self): return "SRMBTC" -SRMBTC = SRMBTC() +SRMBUSD = SRMBUSD() @dataclass(slots=True, frozen=True) class SRMBUSD: + """ + name: SRMBUSD + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 900000.00000000 + margin: False + """ name: str = "SRMBUSD" precision: int = 8 minimum_margin: float = None @@ -39351,11 +54755,20 @@ def __call__(self): return "SRMBUSD" -SRMBUSD = SRMBUSD() +SRMUSDT = SRMUSDT() @dataclass(slots=True, frozen=True) class SRMUSDT: + """ + name: SRMUSDT + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 900000.00000000 + margin: False + """ name: str = "SRMUSDT" precision: int = 8 minimum_margin: float = None @@ -39374,11 +54787,20 @@ def __call__(self): return "SRMUSDT" -SRMUSDT = SRMUSDT() +SSVBTC = SSVBTC() @dataclass(slots=True, frozen=True) class SSVBTC: + """ + name: SSVBTC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 92141578.00000000 + margin: False + """ name: str = "SSVBTC" precision: int = 8 minimum_margin: float = None @@ -39397,11 +54819,20 @@ def __call__(self): return "SSVBTC" -SSVBTC = SSVBTC() +SSVBUSD = SSVBUSD() @dataclass(slots=True, frozen=True) class SSVBUSD: + """ + name: SSVBUSD + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.00100000 + maximum_order_size: 9222449.00000000 + margin: False + """ name: str = "SSVBUSD" precision: int = 8 minimum_margin: float = None @@ -39420,11 +54851,20 @@ def __call__(self): return "SSVBUSD" -SSVBUSD = SSVBUSD() +SSVETH = SSVETH() @dataclass(slots=True, frozen=True) class SSVETH: + """ + name: SSVETH + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 92141578.00000000 + margin: False + """ name: str = "SSVETH" precision: int = 8 minimum_margin: float = None @@ -39443,11 +54883,20 @@ def __call__(self): return "SSVETH" -SSVETH = SSVETH() +STEEMBNB = STEEMBNB() @dataclass(slots=True, frozen=True) class STEEMBNB: + """ + name: STEEMBNB + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 9000000.00000000 + margin: False + """ name: str = "STEEMBNB" precision: int = 8 minimum_margin: float = None @@ -39466,11 +54915,20 @@ def __call__(self): return "STEEMBNB" -STEEMBNB = STEEMBNB() +STEEMBTC = STEEMBTC() @dataclass(slots=True, frozen=True) class STEEMBTC: + """ + name: STEEMBTC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 90000000.00000000 + margin: False + """ name: str = "STEEMBTC" precision: int = 8 minimum_margin: float = None @@ -39489,11 +54947,20 @@ def __call__(self): return "STEEMBTC" -STEEMBTC = STEEMBTC() +STEEMBUSD = STEEMBUSD() @dataclass(slots=True, frozen=True) class STEEMBUSD: + """ + name: STEEMBUSD + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 92141578.00000000 + margin: False + """ name: str = "STEEMBUSD" precision: int = 8 minimum_margin: float = None @@ -39512,11 +54979,20 @@ def __call__(self): return "STEEMBUSD" -STEEMBUSD = STEEMBUSD() +STEEMETH = STEEMETH() @dataclass(slots=True, frozen=True) class STEEMETH: + """ + name: STEEMETH + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 9000000.00000000 + margin: False + """ name: str = "STEEMETH" precision: int = 8 minimum_margin: float = None @@ -39535,11 +55011,20 @@ def __call__(self): return "STEEMETH" -STEEMETH = STEEMETH() +STEEMUSDT = STEEMUSDT() @dataclass(slots=True, frozen=True) class STEEMUSDT: + """ + name: STEEMUSDT + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 92141578.00000000 + margin: False + """ name: str = "STEEMUSDT" precision: int = 8 minimum_margin: float = None @@ -39558,11 +55043,20 @@ def __call__(self): return "STEEMUSDT" -STEEMUSDT = STEEMUSDT() +STGBTC = STGBTC() @dataclass(slots=True, frozen=True) class STGBTC: + """ + name: STGBTC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 913205152.00000000 + margin: False + """ name: str = "STGBTC" precision: int = 8 minimum_margin: float = None @@ -39581,11 +55075,20 @@ def __call__(self): return "STGBTC" -STGBTC = STGBTC() +STGBUSD = STGBUSD() @dataclass(slots=True, frozen=True) class STGBUSD: + """ + name: STGBUSD + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 913205152.00000000 + margin: True + """ name: str = "STGBUSD" precision: int = 8 minimum_margin: float = None @@ -39604,11 +55107,20 @@ def __call__(self): return "STGBUSD" -STGBUSD = STGBUSD() +STGUSDT = STGUSDT() @dataclass(slots=True, frozen=True) class STGUSDT: + """ + name: STGUSDT + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 913205152.00000000 + margin: True + """ name: str = "STGUSDT" precision: int = 8 minimum_margin: float = None @@ -39627,11 +55139,20 @@ def __call__(self): return "STGUSDT" -STGUSDT = STGUSDT() +STMXBTC = STMXBTC() @dataclass(slots=True, frozen=True) class STMXBTC: + """ + name: STMXBTC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 90000000.00000000 + margin: True + """ name: str = "STMXBTC" precision: int = 8 minimum_margin: float = None @@ -39650,11 +55171,20 @@ def __call__(self): return "STMXBTC" -STMXBTC = STMXBTC() +STMXBUSD = STMXBUSD() @dataclass(slots=True, frozen=True) class STMXBUSD: + """ + name: STMXBUSD + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 9222449.00000000 + margin: False + """ name: str = "STMXBUSD" precision: int = 8 minimum_margin: float = None @@ -39673,11 +55203,20 @@ def __call__(self): return "STMXBUSD" -STMXBUSD = STMXBUSD() +STMXETH = STMXETH() @dataclass(slots=True, frozen=True) class STMXETH: + """ + name: STMXETH + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 90000000.00000000 + margin: False + """ name: str = "STMXETH" precision: int = 8 minimum_margin: float = None @@ -39696,11 +55235,20 @@ def __call__(self): return "STMXETH" -STMXETH = STMXETH() +STMXUSDT = STMXUSDT() @dataclass(slots=True, frozen=True) class STMXUSDT: + """ + name: STMXUSDT + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 92141578.00000000 + margin: True + """ name: str = "STMXUSDT" precision: int = 8 minimum_margin: float = None @@ -39719,11 +55267,20 @@ def __call__(self): return "STMXUSDT" -STMXUSDT = STMXUSDT() +STORJBTC = STORJBTC() @dataclass(slots=True, frozen=True) class STORJBTC: + """ + name: STORJBTC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 90000000.00000000 + margin: True + """ name: str = "STORJBTC" precision: int = 8 minimum_margin: float = None @@ -39742,11 +55299,20 @@ def __call__(self): return "STORJBTC" -STORJBTC = STORJBTC() +STORJBUSD = STORJBUSD() @dataclass(slots=True, frozen=True) class STORJBUSD: + """ + name: STORJBUSD + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 9222448.00000000 + margin: False + """ name: str = "STORJBUSD" precision: int = 8 minimum_margin: float = None @@ -39765,11 +55331,20 @@ def __call__(self): return "STORJBUSD" -STORJBUSD = STORJBUSD() +STORJETH = STORJETH() @dataclass(slots=True, frozen=True) class STORJETH: + """ + name: STORJETH + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 90000000.00000000 + margin: False + """ name: str = "STORJETH" precision: int = 8 minimum_margin: float = None @@ -39788,11 +55363,20 @@ def __call__(self): return "STORJETH" -STORJETH = STORJETH() +STORJTRY = STORJTRY() @dataclass(slots=True, frozen=True) class STORJTRY: + """ + name: STORJTRY + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 9222449.00000000 + margin: False + """ name: str = "STORJTRY" precision: int = 8 minimum_margin: float = None @@ -39811,11 +55395,20 @@ def __call__(self): return "STORJTRY" -STORJTRY = STORJTRY() +STORJUSDT = STORJUSDT() @dataclass(slots=True, frozen=True) class STORJUSDT: + """ + name: STORJUSDT + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 900000.00000000 + margin: True + """ name: str = "STORJUSDT" precision: int = 8 minimum_margin: float = None @@ -39834,11 +55427,20 @@ def __call__(self): return "STORJUSDT" -STORJUSDT = STORJUSDT() +STORMBNB = STORMBNB() @dataclass(slots=True, frozen=True) class STORMBNB: + """ + name: STORMBNB + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 9222449.00000000 + margin: False + """ name: str = "STORMBNB" precision: int = 8 minimum_margin: float = None @@ -39857,11 +55459,20 @@ def __call__(self): return "STORMBNB" -STORMBNB = STORMBNB() +STORMBTC = STORMBTC() @dataclass(slots=True, frozen=True) class STORMBTC: + """ + name: STORMBTC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 92141578.00000000 + margin: False + """ name: str = "STORMBTC" precision: int = 8 minimum_margin: float = None @@ -39880,11 +55491,20 @@ def __call__(self): return "STORMBTC" -STORMBTC = STORMBTC() +STORMETH = STORMETH() @dataclass(slots=True, frozen=True) class STORMETH: + """ + name: STORMETH + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 90000000.00000000 + margin: False + """ name: str = "STORMETH" precision: int = 8 minimum_margin: float = None @@ -39903,11 +55523,20 @@ def __call__(self): return "STORMETH" -STORMETH = STORMETH() +STORMUSDT = STORMUSDT() @dataclass(slots=True, frozen=True) class STORMUSDT: + """ + name: STORMUSDT + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 92141578.00000000 + margin: False + """ name: str = "STORMUSDT" precision: int = 8 minimum_margin: float = None @@ -39926,11 +55555,20 @@ def __call__(self): return "STORMUSDT" -STORMUSDT = STORMUSDT() +STPTBNB = STPTBNB() @dataclass(slots=True, frozen=True) class STPTBNB: + """ + name: STPTBNB + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 9000000.00000000 + margin: False + """ name: str = "STPTBNB" precision: int = 8 minimum_margin: float = None @@ -39949,11 +55587,20 @@ def __call__(self): return "STPTBNB" -STPTBNB = STPTBNB() +STPTBTC = STPTBTC() @dataclass(slots=True, frozen=True) class STPTBTC: + """ + name: STPTBTC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 90000000.00000000 + margin: False + """ name: str = "STPTBTC" precision: int = 8 minimum_margin: float = None @@ -39972,11 +55619,20 @@ def __call__(self): return "STPTBTC" -STPTBTC = STPTBTC() +STPTBUSD = STPTBUSD() @dataclass(slots=True, frozen=True) class STPTBUSD: + """ + name: STPTBUSD + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 92141578.00000000 + margin: False + """ name: str = "STPTBUSD" precision: int = 8 minimum_margin: float = None @@ -39995,11 +55651,20 @@ def __call__(self): return "STPTBUSD" -STPTBUSD = STPTBUSD() +STPTUSDT = STPTUSDT() @dataclass(slots=True, frozen=True) class STPTUSDT: + """ + name: STPTUSDT + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 9000000.00000000 + margin: False + """ name: str = "STPTUSDT" precision: int = 8 minimum_margin: float = None @@ -40018,11 +55683,20 @@ def __call__(self): return "STPTUSDT" -STPTUSDT = STPTUSDT() +STRATBNB = STRATBNB() @dataclass(slots=True, frozen=True) class STRATBNB: + """ + name: STRATBNB + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 9000000.00000000 + margin: False + """ name: str = "STRATBNB" precision: int = 8 minimum_margin: float = None @@ -40041,11 +55715,20 @@ def __call__(self): return "STRATBNB" -STRATBNB = STRATBNB() +STRATBTC = STRATBTC() @dataclass(slots=True, frozen=True) class STRATBTC: + """ + name: STRATBTC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 90000000.00000000 + margin: False + """ name: str = "STRATBTC" precision: int = 8 minimum_margin: float = None @@ -40064,11 +55747,20 @@ def __call__(self): return "STRATBTC" -STRATBTC = STRATBTC() +STRATBUSD = STRATBUSD() @dataclass(slots=True, frozen=True) class STRATBUSD: + """ + name: STRATBUSD + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 900000.00000000 + margin: False + """ name: str = "STRATBUSD" precision: int = 8 minimum_margin: float = None @@ -40087,11 +55779,20 @@ def __call__(self): return "STRATBUSD" -STRATBUSD = STRATBUSD() +STRATETH = STRATETH() @dataclass(slots=True, frozen=True) class STRATETH: + """ + name: STRATETH + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 90000000.00000000 + margin: False + """ name: str = "STRATETH" precision: int = 8 minimum_margin: float = None @@ -40110,11 +55811,20 @@ def __call__(self): return "STRATETH" -STRATETH = STRATETH() +STRATUSDT = STRATUSDT() @dataclass(slots=True, frozen=True) class STRATUSDT: + """ + name: STRATUSDT + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 900000.00000000 + margin: False + """ name: str = "STRATUSDT" precision: int = 8 minimum_margin: float = None @@ -40133,11 +55843,20 @@ def __call__(self): return "STRATUSDT" -STRATUSDT = STRATUSDT() +STRAXBTC = STRAXBTC() @dataclass(slots=True, frozen=True) class STRAXBTC: + """ + name: STRAXBTC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 90000000.00000000 + margin: False + """ name: str = "STRAXBTC" precision: int = 8 minimum_margin: float = None @@ -40156,11 +55875,20 @@ def __call__(self): return "STRAXBTC" -STRAXBTC = STRAXBTC() +STRAXBUSD = STRAXBUSD() @dataclass(slots=True, frozen=True) class STRAXBUSD: + """ + name: STRAXBUSD + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 900000.00000000 + margin: True + """ name: str = "STRAXBUSD" precision: int = 8 minimum_margin: float = None @@ -40179,11 +55907,20 @@ def __call__(self): return "STRAXBUSD" -STRAXBUSD = STRAXBUSD() +STRAXETH = STRAXETH() @dataclass(slots=True, frozen=True) class STRAXETH: + """ + name: STRAXETH + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 90000000.00000000 + margin: False + """ name: str = "STRAXETH" precision: int = 8 minimum_margin: float = None @@ -40202,11 +55939,20 @@ def __call__(self): return "STRAXETH" -STRAXETH = STRAXETH() +STRAXUSDT = STRAXUSDT() @dataclass(slots=True, frozen=True) class STRAXUSDT: + """ + name: STRAXUSDT + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 900000.00000000 + margin: True + """ name: str = "STRAXUSDT" precision: int = 8 minimum_margin: float = None @@ -40225,11 +55971,20 @@ def __call__(self): return "STRAXUSDT" -STRAXUSDT = STRAXUSDT() +STXBNB = STXBNB() @dataclass(slots=True, frozen=True) class STXBNB: + """ + name: STXBNB + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 9000000.00000000 + margin: False + """ name: str = "STXBNB" precision: int = 8 minimum_margin: float = None @@ -40248,11 +56003,20 @@ def __call__(self): return "STXBNB" -STXBNB = STXBNB() +STXBTC = STXBTC() @dataclass(slots=True, frozen=True) class STXBTC: + """ + name: STXBTC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 90000000.00000000 + margin: True + """ name: str = "STXBTC" precision: int = 8 minimum_margin: float = None @@ -40271,11 +56035,20 @@ def __call__(self): return "STXBTC" -STXBTC = STXBTC() +STXBUSD = STXBUSD() @dataclass(slots=True, frozen=True) class STXBUSD: + """ + name: STXBUSD + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 92141578.00000000 + margin: True + """ name: str = "STXBUSD" precision: int = 8 minimum_margin: float = None @@ -40294,11 +56067,20 @@ def __call__(self): return "STXBUSD" -STXBUSD = STXBUSD() +STXUSDT = STXUSDT() @dataclass(slots=True, frozen=True) class STXUSDT: + """ + name: STXUSDT + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 900000.00000000 + margin: True + """ name: str = "STXUSDT" precision: int = 8 minimum_margin: float = None @@ -40317,11 +56099,20 @@ def __call__(self): return "STXUSDT" -STXUSDT = STXUSDT() +SUBBTC = SUBBTC() @dataclass(slots=True, frozen=True) class SUBBTC: + """ + name: SUBBTC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 90000000.00000000 + margin: False + """ name: str = "SUBBTC" precision: int = 8 minimum_margin: float = None @@ -40340,11 +56131,20 @@ def __call__(self): return "SUBBTC" -SUBBTC = SUBBTC() +SUBETH = SUBETH() @dataclass(slots=True, frozen=True) class SUBETH: + """ + name: SUBETH + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 90000000.00000000 + margin: False + """ name: str = "SUBETH" precision: int = 8 minimum_margin: float = None @@ -40363,11 +56163,20 @@ def __call__(self): return "SUBETH" -SUBETH = SUBETH() +SUNBTC = SUNBTC() @dataclass(slots=True, frozen=True) class SUNBTC: + """ + name: SUNBTC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.00100000 + maximum_order_size: 10000000.00000000 + margin: False + """ name: str = "SUNBTC" precision: int = 8 minimum_margin: float = None @@ -40386,11 +56195,20 @@ def __call__(self): return "SUNBTC" -SUNBTC = SUNBTC() +SUNBUSD = SUNBUSD() @dataclass(slots=True, frozen=True) class SUNBUSD: + """ + name: SUNBUSD + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 92141578.00000000 + margin: True + """ name: str = "SUNBUSD" precision: int = 8 minimum_margin: float = None @@ -40409,11 +56227,20 @@ def __call__(self): return "SUNBUSD" -SUNBUSD = SUNBUSD() +SUNUSDT = SUNUSDT() @dataclass(slots=True, frozen=True) class SUNUSDT: + """ + name: SUNUSDT + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 92141578.00000000 + margin: True + """ name: str = "SUNUSDT" precision: int = 8 minimum_margin: float = None @@ -40432,11 +56259,20 @@ def __call__(self): return "SUNUSDT" -SUNUSDT = SUNUSDT() +SUPERBTC = SUPERBTC() @dataclass(slots=True, frozen=True) class SUPERBTC: + """ + name: SUPERBTC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 90000000.00000000 + margin: True + """ name: str = "SUPERBTC" precision: int = 8 minimum_margin: float = None @@ -40455,11 +56291,20 @@ def __call__(self): return "SUPERBTC" -SUPERBTC = SUPERBTC() +SUPERBUSD = SUPERBUSD() @dataclass(slots=True, frozen=True) class SUPERBUSD: + """ + name: SUPERBUSD + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 9222449.00000000 + margin: True + """ name: str = "SUPERBUSD" precision: int = 8 minimum_margin: float = None @@ -40478,11 +56323,20 @@ def __call__(self): return "SUPERBUSD" -SUPERBUSD = SUPERBUSD() +SUPERUSDT = SUPERUSDT() @dataclass(slots=True, frozen=True) class SUPERUSDT: + """ + name: SUPERUSDT + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 9222449.00000000 + margin: True + """ name: str = "SUPERUSDT" precision: int = 8 minimum_margin: float = None @@ -40501,11 +56355,20 @@ def __call__(self): return "SUPERUSDT" -SUPERUSDT = SUPERUSDT() +SUSDBTC = SUSDBTC() @dataclass(slots=True, frozen=True) class SUSDBTC: + """ + name: SUSDBTC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 90000000.00000000 + margin: False + """ name: str = "SUSDBTC" precision: int = 8 minimum_margin: float = None @@ -40524,11 +56387,20 @@ def __call__(self): return "SUSDBTC" -SUSDBTC = SUSDBTC() +SUSDETH = SUSDETH() @dataclass(slots=True, frozen=True) class SUSDETH: + """ + name: SUSDETH + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 90000000.00000000 + margin: False + """ name: str = "SUSDETH" precision: int = 8 minimum_margin: float = None @@ -40547,11 +56419,20 @@ def __call__(self): return "SUSDETH" -SUSDETH = SUSDETH() +SUSDUSDT = SUSDUSDT() @dataclass(slots=True, frozen=True) class SUSDUSDT: + """ + name: SUSDUSDT + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 900000.00000000 + margin: False + """ name: str = "SUSDUSDT" precision: int = 8 minimum_margin: float = None @@ -40570,11 +56451,20 @@ def __call__(self): return "SUSDUSDT" -SUSDUSDT = SUSDUSDT() +SUSHIBNB = SUSHIBNB() @dataclass(slots=True, frozen=True) class SUSHIBNB: + """ + name: SUSHIBNB + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 9000000.00000000 + margin: False + """ name: str = "SUSHIBNB" precision: int = 8 minimum_margin: float = None @@ -40593,11 +56483,20 @@ def __call__(self): return "SUSHIBNB" -SUSHIBNB = SUSHIBNB() +SUSHIBTC = SUSHIBTC() @dataclass(slots=True, frozen=True) class SUSHIBTC: + """ + name: SUSHIBTC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 90000000.00000000 + margin: True + """ name: str = "SUSHIBTC" precision: int = 8 minimum_margin: float = None @@ -40616,11 +56515,20 @@ def __call__(self): return "SUSHIBTC" -SUSHIBTC = SUSHIBTC() +SUSHIBUSD = SUSHIBUSD() @dataclass(slots=True, frozen=True) class SUSHIBUSD: + """ + name: SUSHIBUSD + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 90000.00000000 + margin: False + """ name: str = "SUSHIBUSD" precision: int = 8 minimum_margin: float = None @@ -40639,11 +56547,20 @@ def __call__(self): return "SUSHIBUSD" -SUSHIBUSD = SUSHIBUSD() +SUSHIDOWNUSDT = SUSHIDOWNUSDT() @dataclass(slots=True, frozen=True) class SUSHIDOWNUSDT: + """ + name: SUSHIDOWNUSDT + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 19998638.00000000 + margin: False + """ name: str = "SUSHIDOWNUSDT" precision: int = 8 minimum_margin: float = None @@ -40662,11 +56579,20 @@ def __call__(self): return "SUSHIDOWNUSDT" -SUSHIDOWNUSDT = SUSHIDOWNUSDT() +SUSHIUPUSDT = SUSHIUPUSDT() @dataclass(slots=True, frozen=True) class SUSHIUPUSDT: + """ + name: SUSHIUPUSDT + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 150000.00000000 + margin: False + """ name: str = "SUSHIUPUSDT" precision: int = 8 minimum_margin: float = None @@ -40685,11 +56611,20 @@ def __call__(self): return "SUSHIUPUSDT" -SUSHIUPUSDT = SUSHIUPUSDT() +SUSHIUSDT = SUSHIUSDT() @dataclass(slots=True, frozen=True) class SUSHIUSDT: + """ + name: SUSHIUSDT + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 90000.00000000 + margin: True + """ name: str = "SUSHIUSDT" precision: int = 8 minimum_margin: float = None @@ -40708,11 +56643,20 @@ def __call__(self): return "SUSHIUSDT" -SUSHIUSDT = SUSHIUSDT() +SWRVBNB = SWRVBNB() @dataclass(slots=True, frozen=True) class SWRVBNB: + """ + name: SWRVBNB + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 9000000.00000000 + margin: False + """ name: str = "SWRVBNB" precision: int = 8 minimum_margin: float = None @@ -40731,11 +56675,20 @@ def __call__(self): return "SWRVBNB" -SWRVBNB = SWRVBNB() +SWRVBUSD = SWRVBUSD() @dataclass(slots=True, frozen=True) class SWRVBUSD: + """ + name: SWRVBUSD + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 922327.00000000 + margin: False + """ name: str = "SWRVBUSD" precision: int = 8 minimum_margin: float = None @@ -40754,11 +56707,20 @@ def __call__(self): return "SWRVBUSD" -SWRVBUSD = SWRVBUSD() +SXPAUD = SXPAUD() @dataclass(slots=True, frozen=True) class SXPAUD: + """ + name: SXPAUD + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 922327.00000000 + margin: False + """ name: str = "SXPAUD" precision: int = 8 minimum_margin: float = None @@ -40777,11 +56739,20 @@ def __call__(self): return "SXPAUD" -SXPAUD = SXPAUD() +SXPBIDR = SXPBIDR() @dataclass(slots=True, frozen=True) class SXPBIDR: + """ + name: SXPBIDR + precision: 2 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 1000000.00000000 + margin: False + """ name: str = "SXPBIDR" precision: int = 2 minimum_margin: float = None @@ -40800,11 +56771,20 @@ def __call__(self): return "SXPBIDR" -SXPBIDR = SXPBIDR() +SXPBNB = SXPBNB() @dataclass(slots=True, frozen=True) class SXPBNB: + """ + name: SXPBNB + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 9000000.00000000 + margin: False + """ name: str = "SXPBNB" precision: int = 8 minimum_margin: float = None @@ -40823,11 +56803,20 @@ def __call__(self): return "SXPBNB" -SXPBNB = SXPBNB() +SXPBTC = SXPBTC() @dataclass(slots=True, frozen=True) class SXPBTC: + """ + name: SXPBTC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 90000000.00000000 + margin: True + """ name: str = "SXPBTC" precision: int = 8 minimum_margin: float = None @@ -40846,11 +56835,20 @@ def __call__(self): return "SXPBTC" -SXPBTC = SXPBTC() +SXPBUSD = SXPBUSD() @dataclass(slots=True, frozen=True) class SXPBUSD: + """ + name: SXPBUSD + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 900000.00000000 + margin: True + """ name: str = "SXPBUSD" precision: int = 8 minimum_margin: float = None @@ -40869,11 +56867,20 @@ def __call__(self): return "SXPBUSD" -SXPBUSD = SXPBUSD() +SXPDOWNUSDT = SXPDOWNUSDT() @dataclass(slots=True, frozen=True) class SXPDOWNUSDT: + """ + name: SXPDOWNUSDT + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 100000000.00000000 + margin: False + """ name: str = "SXPDOWNUSDT" precision: int = 8 minimum_margin: float = None @@ -40892,11 +56899,20 @@ def __call__(self): return "SXPDOWNUSDT" -SXPDOWNUSDT = SXPDOWNUSDT() +SXPEUR = SXPEUR() @dataclass(slots=True, frozen=True) class SXPEUR: + """ + name: SXPEUR + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 922327.00000000 + margin: False + """ name: str = "SXPEUR" precision: int = 8 minimum_margin: float = None @@ -40915,11 +56931,20 @@ def __call__(self): return "SXPEUR" -SXPEUR = SXPEUR() +SXPGBP = SXPGBP() @dataclass(slots=True, frozen=True) class SXPGBP: + """ + name: SXPGBP + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 900000.00000000 + margin: False + """ name: str = "SXPGBP" precision: int = 8 minimum_margin: float = None @@ -40938,11 +56963,20 @@ def __call__(self): return "SXPGBP" -SXPGBP = SXPGBP() +SXPTRY = SXPTRY() @dataclass(slots=True, frozen=True) class SXPTRY: + """ + name: SXPTRY + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 922327.00000000 + margin: False + """ name: str = "SXPTRY" precision: int = 8 minimum_margin: float = None @@ -40961,11 +56995,20 @@ def __call__(self): return "SXPTRY" -SXPTRY = SXPTRY() +SXPUPUSDT = SXPUPUSDT() @dataclass(slots=True, frozen=True) class SXPUPUSDT: + """ + name: SXPUPUSDT + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 920000.00000000 + margin: False + """ name: str = "SXPUPUSDT" precision: int = 8 minimum_margin: float = None @@ -40984,11 +57027,20 @@ def __call__(self): return "SXPUPUSDT" -SXPUPUSDT = SXPUPUSDT() +SXPUSDT = SXPUSDT() @dataclass(slots=True, frozen=True) class SXPUSDT: + """ + name: SXPUSDT + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 922327.00000000 + margin: True + """ name: str = "SXPUSDT" precision: int = 8 minimum_margin: float = None @@ -41007,11 +57059,20 @@ def __call__(self): return "SXPUSDT" -SXPUSDT = SXPUSDT() +SYSBNB = SYSBNB() @dataclass(slots=True, frozen=True) class SYSBNB: + """ + name: SYSBNB + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 9000000.00000000 + margin: False + """ name: str = "SYSBNB" precision: int = 8 minimum_margin: float = None @@ -41030,11 +57091,20 @@ def __call__(self): return "SYSBNB" -SYSBNB = SYSBNB() +SYSBTC = SYSBTC() @dataclass(slots=True, frozen=True) class SYSBTC: + """ + name: SYSBTC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 90000000.00000000 + margin: False + """ name: str = "SYSBTC" precision: int = 8 minimum_margin: float = None @@ -41053,11 +57123,20 @@ def __call__(self): return "SYSBTC" -SYSBTC = SYSBTC() +SYSBUSD = SYSBUSD() @dataclass(slots=True, frozen=True) class SYSBUSD: + """ + name: SYSBUSD + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 9000000.00000000 + margin: False + """ name: str = "SYSBUSD" precision: int = 8 minimum_margin: float = None @@ -41076,11 +57155,20 @@ def __call__(self): return "SYSBUSD" -SYSBUSD = SYSBUSD() +SYSETH = SYSETH() @dataclass(slots=True, frozen=True) class SYSETH: + """ + name: SYSETH + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 90000000.00000000 + margin: False + """ name: str = "SYSETH" precision: int = 8 minimum_margin: float = None @@ -41099,11 +57187,20 @@ def __call__(self): return "SYSETH" -SYSETH = SYSETH() +SYSUSDT = SYSUSDT() @dataclass(slots=True, frozen=True) class SYSUSDT: + """ + name: SYSUSDT + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 92141578.00000000 + margin: False + """ name: str = "SYSUSDT" precision: int = 8 minimum_margin: float = None @@ -41122,11 +57219,20 @@ def __call__(self): return "SYSUSDT" -SYSUSDT = SYSUSDT() +TBUSD = TBUSD() @dataclass(slots=True, frozen=True) class TBUSD: + """ + name: TBUSD + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 92141578.00000000 + margin: False + """ name: str = "TBUSD" precision: int = 8 minimum_margin: float = None @@ -41145,11 +57251,20 @@ def __call__(self): return "TBUSD" -TBUSD = TBUSD() +TCTBNB = TCTBNB() @dataclass(slots=True, frozen=True) class TCTBNB: + """ + name: TCTBNB + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 9000000.00000000 + margin: False + """ name: str = "TCTBNB" precision: int = 8 minimum_margin: float = None @@ -41168,11 +57283,20 @@ def __call__(self): return "TCTBNB" -TCTBNB = TCTBNB() +TCTBTC = TCTBTC() @dataclass(slots=True, frozen=True) class TCTBTC: + """ + name: TCTBTC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 90000000.00000000 + margin: False + """ name: str = "TCTBTC" precision: int = 8 minimum_margin: float = None @@ -41191,11 +57315,20 @@ def __call__(self): return "TCTBTC" -TCTBTC = TCTBTC() +TCTUSDT = TCTUSDT() @dataclass(slots=True, frozen=True) class TCTUSDT: + """ + name: TCTUSDT + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 9000000.00000000 + margin: False + """ name: str = "TCTUSDT" precision: int = 8 minimum_margin: float = None @@ -41214,11 +57347,20 @@ def __call__(self): return "TCTUSDT" -TCTUSDT = TCTUSDT() +TFUELBNB = TFUELBNB() @dataclass(slots=True, frozen=True) class TFUELBNB: + """ + name: TFUELBNB + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 9000000.00000000 + margin: False + """ name: str = "TFUELBNB" precision: int = 8 minimum_margin: float = None @@ -41237,11 +57379,20 @@ def __call__(self): return "TFUELBNB" -TFUELBNB = TFUELBNB() +TFUELBTC = TFUELBTC() @dataclass(slots=True, frozen=True) class TFUELBTC: + """ + name: TFUELBTC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 90000000.00000000 + margin: True + """ name: str = "TFUELBTC" precision: int = 8 minimum_margin: float = None @@ -41260,11 +57411,20 @@ def __call__(self): return "TFUELBTC" -TFUELBTC = TFUELBTC() +TFUELBUSD = TFUELBUSD() @dataclass(slots=True, frozen=True) class TFUELBUSD: + """ + name: TFUELBUSD + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 92141578.00000000 + margin: False + """ name: str = "TFUELBUSD" precision: int = 8 minimum_margin: float = None @@ -41283,11 +57443,20 @@ def __call__(self): return "TFUELBUSD" -TFUELBUSD = TFUELBUSD() +TFUELPAX = TFUELPAX() @dataclass(slots=True, frozen=True) class TFUELPAX: + """ + name: TFUELPAX + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 9000000.00000000 + margin: False + """ name: str = "TFUELPAX" precision: int = 8 minimum_margin: float = None @@ -41306,11 +57475,20 @@ def __call__(self): return "TFUELPAX" -TFUELPAX = TFUELPAX() +TFUELTUSD = TFUELTUSD() @dataclass(slots=True, frozen=True) class TFUELTUSD: + """ + name: TFUELTUSD + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 9000000.00000000 + margin: False + """ name: str = "TFUELTUSD" precision: int = 8 minimum_margin: float = None @@ -41329,11 +57507,20 @@ def __call__(self): return "TFUELTUSD" -TFUELTUSD = TFUELTUSD() +TFUELUSDC = TFUELUSDC() @dataclass(slots=True, frozen=True) class TFUELUSDC: + """ + name: TFUELUSDC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 9000000.00000000 + margin: False + """ name: str = "TFUELUSDC" precision: int = 8 minimum_margin: float = None @@ -41352,11 +57539,20 @@ def __call__(self): return "TFUELUSDC" -TFUELUSDC = TFUELUSDC() +TFUELUSDT = TFUELUSDT() @dataclass(slots=True, frozen=True) class TFUELUSDT: + """ + name: TFUELUSDT + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 9000000.00000000 + margin: True + """ name: str = "TFUELUSDT" precision: int = 8 minimum_margin: float = None @@ -41375,11 +57571,20 @@ def __call__(self): return "TFUELUSDT" -TFUELUSDT = TFUELUSDT() +THETABNB = THETABNB() @dataclass(slots=True, frozen=True) class THETABNB: + """ + name: THETABNB + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 9000000.00000000 + margin: False + """ name: str = "THETABNB" precision: int = 8 minimum_margin: float = None @@ -41398,11 +57603,20 @@ def __call__(self): return "THETABNB" -THETABNB = THETABNB() +THETABTC = THETABTC() @dataclass(slots=True, frozen=True) class THETABTC: + """ + name: THETABTC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 90000000.00000000 + margin: True + """ name: str = "THETABTC" precision: int = 8 minimum_margin: float = None @@ -41421,11 +57635,20 @@ def __call__(self): return "THETABTC" -THETABTC = THETABTC() +THETABUSD = THETABUSD() @dataclass(slots=True, frozen=True) class THETABUSD: + """ + name: THETABUSD + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 9222449.00000000 + margin: False + """ name: str = "THETABUSD" precision: int = 8 minimum_margin: float = None @@ -41444,11 +57667,20 @@ def __call__(self): return "THETABUSD" -THETABUSD = THETABUSD() +THETAETH = THETAETH() @dataclass(slots=True, frozen=True) class THETAETH: + """ + name: THETAETH + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 90000000.00000000 + margin: False + """ name: str = "THETAETH" precision: int = 8 minimum_margin: float = None @@ -41467,11 +57699,20 @@ def __call__(self): return "THETAETH" -THETAETH = THETAETH() +THETAEUR = THETAEUR() @dataclass(slots=True, frozen=True) class THETAEUR: + """ + name: THETAEUR + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 90000.00000000 + margin: False + """ name: str = "THETAEUR" precision: int = 8 minimum_margin: float = None @@ -41490,11 +57731,20 @@ def __call__(self): return "THETAEUR" -THETAEUR = THETAEUR() +THETAUSDT = THETAUSDT() @dataclass(slots=True, frozen=True) class THETAUSDT: + """ + name: THETAUSDT + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 90000.00000000 + margin: True + """ name: str = "THETAUSDT" precision: int = 8 minimum_margin: float = None @@ -41513,11 +57763,20 @@ def __call__(self): return "THETAUSDT" -THETAUSDT = THETAUSDT() +TKOBIDR = TKOBIDR() @dataclass(slots=True, frozen=True) class TKOBIDR: + """ + name: TKOBIDR + precision: 2 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 90000000.00000000 + margin: False + """ name: str = "TKOBIDR" precision: int = 2 minimum_margin: float = None @@ -41536,11 +57795,20 @@ def __call__(self): return "TKOBIDR" -TKOBIDR = TKOBIDR() +TKOBTC = TKOBTC() @dataclass(slots=True, frozen=True) class TKOBTC: + """ + name: TKOBTC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 90000000.00000000 + margin: False + """ name: str = "TKOBTC" precision: int = 8 minimum_margin: float = None @@ -41559,11 +57827,20 @@ def __call__(self): return "TKOBTC" -TKOBTC = TKOBTC() +TKOBUSD = TKOBUSD() @dataclass(slots=True, frozen=True) class TKOBUSD: + """ + name: TKOBUSD + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 900000.00000000 + margin: False + """ name: str = "TKOBUSD" precision: int = 8 minimum_margin: float = None @@ -41582,11 +57859,20 @@ def __call__(self): return "TKOBUSD" -TKOBUSD = TKOBUSD() +TKOUSDT = TKOUSDT() @dataclass(slots=True, frozen=True) class TKOUSDT: + """ + name: TKOUSDT + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 900000.00000000 + margin: False + """ name: str = "TKOUSDT" precision: int = 8 minimum_margin: float = None @@ -41605,11 +57891,20 @@ def __call__(self): return "TKOUSDT" -TKOUSDT = TKOUSDT() +TLMBNB = TLMBNB() @dataclass(slots=True, frozen=True) class TLMBNB: + """ + name: TLMBNB + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 92141578.00000000 + margin: False + """ name: str = "TLMBNB" precision: int = 8 minimum_margin: float = None @@ -41628,11 +57923,20 @@ def __call__(self): return "TLMBNB" -TLMBNB = TLMBNB() +TLMBTC = TLMBTC() @dataclass(slots=True, frozen=True) class TLMBTC: + """ + name: TLMBTC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 90000000.00000000 + margin: True + """ name: str = "TLMBTC" precision: int = 8 minimum_margin: float = None @@ -41651,11 +57955,20 @@ def __call__(self): return "TLMBTC" -TLMBTC = TLMBTC() +TLMBUSD = TLMBUSD() @dataclass(slots=True, frozen=True) class TLMBUSD: + """ + name: TLMBUSD + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 900000.00000000 + margin: True + """ name: str = "TLMBUSD" precision: int = 8 minimum_margin: float = None @@ -41674,11 +57987,20 @@ def __call__(self): return "TLMBUSD" -TLMBUSD = TLMBUSD() +TLMTRY = TLMTRY() @dataclass(slots=True, frozen=True) class TLMTRY: + """ + name: TLMTRY + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 92141578.00000000 + margin: False + """ name: str = "TLMTRY" precision: int = 8 minimum_margin: float = None @@ -41697,11 +58019,20 @@ def __call__(self): return "TLMTRY" -TLMTRY = TLMTRY() +TLMUSDT = TLMUSDT() @dataclass(slots=True, frozen=True) class TLMUSDT: + """ + name: TLMUSDT + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 900000.00000000 + margin: True + """ name: str = "TLMUSDT" precision: int = 8 minimum_margin: float = None @@ -41720,11 +58051,20 @@ def __call__(self): return "TLMUSDT" -TLMUSDT = TLMUSDT() +TNBBTC = TNBBTC() @dataclass(slots=True, frozen=True) class TNBBTC: + """ + name: TNBBTC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 92141578.00000000 + margin: False + """ name: str = "TNBBTC" precision: int = 8 minimum_margin: float = None @@ -41743,11 +58083,20 @@ def __call__(self): return "TNBBTC" -TNBBTC = TNBBTC() +TNBETH = TNBETH() @dataclass(slots=True, frozen=True) class TNBETH: + """ + name: TNBETH + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 90000000.00000000 + margin: False + """ name: str = "TNBETH" precision: int = 8 minimum_margin: float = None @@ -41766,11 +58115,20 @@ def __call__(self): return "TNBETH" -TNBETH = TNBETH() +TNTBTC = TNTBTC() @dataclass(slots=True, frozen=True) class TNTBTC: + """ + name: TNTBTC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 90000000.00000000 + margin: False + """ name: str = "TNTBTC" precision: int = 8 minimum_margin: float = None @@ -41789,11 +58147,20 @@ def __call__(self): return "TNTBTC" -TNTBTC = TNTBTC() +TNTETH = TNTETH() @dataclass(slots=True, frozen=True) class TNTETH: + """ + name: TNTETH + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 90000000.00000000 + margin: False + """ name: str = "TNTETH" precision: int = 8 minimum_margin: float = None @@ -41812,11 +58179,20 @@ def __call__(self): return "TNTETH" -TNTETH = TNTETH() +TOMOBNB = TOMOBNB() @dataclass(slots=True, frozen=True) class TOMOBNB: + """ + name: TOMOBNB + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 9000000.00000000 + margin: False + """ name: str = "TOMOBNB" precision: int = 8 minimum_margin: float = None @@ -41835,11 +58211,20 @@ def __call__(self): return "TOMOBNB" -TOMOBNB = TOMOBNB() +TOMOBTC = TOMOBTC() @dataclass(slots=True, frozen=True) class TOMOBTC: + """ + name: TOMOBTC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 90000000.00000000 + margin: True + """ name: str = "TOMOBTC" precision: int = 8 minimum_margin: float = None @@ -41858,11 +58243,20 @@ def __call__(self): return "TOMOBTC" -TOMOBTC = TOMOBTC() +TOMOBUSD = TOMOBUSD() @dataclass(slots=True, frozen=True) class TOMOBUSD: + """ + name: TOMOBUSD + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 900000.00000000 + margin: False + """ name: str = "TOMOBUSD" precision: int = 8 minimum_margin: float = None @@ -41881,11 +58275,20 @@ def __call__(self): return "TOMOBUSD" -TOMOBUSD = TOMOBUSD() +TOMOUSDC = TOMOUSDC() @dataclass(slots=True, frozen=True) class TOMOUSDC: + """ + name: TOMOUSDC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 900000.00000000 + margin: False + """ name: str = "TOMOUSDC" precision: int = 8 minimum_margin: float = None @@ -41904,11 +58307,20 @@ def __call__(self): return "TOMOUSDC" -TOMOUSDC = TOMOUSDC() +TOMOUSDT = TOMOUSDT() @dataclass(slots=True, frozen=True) class TOMOUSDT: + """ + name: TOMOUSDT + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 900000.00000000 + margin: True + """ name: str = "TOMOUSDT" precision: int = 8 minimum_margin: float = None @@ -41927,11 +58339,20 @@ def __call__(self): return "TOMOUSDT" -TOMOUSDT = TOMOUSDT() +TORNBNB = TORNBNB() @dataclass(slots=True, frozen=True) class TORNBNB: + """ + name: TORNBNB + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 9222449.00000000 + margin: False + """ name: str = "TORNBNB" precision: int = 8 minimum_margin: float = None @@ -41950,11 +58371,20 @@ def __call__(self): return "TORNBNB" -TORNBNB = TORNBNB() +TORNBTC = TORNBTC() @dataclass(slots=True, frozen=True) class TORNBTC: + """ + name: TORNBTC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 92141578.00000000 + margin: False + """ name: str = "TORNBTC" precision: int = 8 minimum_margin: float = None @@ -41973,11 +58403,20 @@ def __call__(self): return "TORNBTC" -TORNBTC = TORNBTC() +TORNBUSD = TORNBUSD() @dataclass(slots=True, frozen=True) class TORNBUSD: + """ + name: TORNBUSD + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 922327.00000000 + margin: False + """ name: str = "TORNBUSD" precision: int = 8 minimum_margin: float = None @@ -41996,11 +58435,20 @@ def __call__(self): return "TORNBUSD" -TORNBUSD = TORNBUSD() +TORNUSDT = TORNUSDT() @dataclass(slots=True, frozen=True) class TORNUSDT: + """ + name: TORNUSDT + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 922327.00000000 + margin: False + """ name: str = "TORNUSDT" precision: int = 8 minimum_margin: float = None @@ -42019,11 +58467,20 @@ def __call__(self): return "TORNUSDT" -TORNUSDT = TORNUSDT() +TRBBNB = TRBBNB() @dataclass(slots=True, frozen=True) class TRBBNB: + """ + name: TRBBNB + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.00100000 + maximum_order_size: 900000.00000000 + margin: False + """ name: str = "TRBBNB" precision: int = 8 minimum_margin: float = None @@ -42042,11 +58499,20 @@ def __call__(self): return "TRBBNB" -TRBBNB = TRBBNB() +TRBBTC = TRBBTC() @dataclass(slots=True, frozen=True) class TRBBTC: + """ + name: TRBBTC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 10000000.00000000 + margin: True + """ name: str = "TRBBTC" precision: int = 8 minimum_margin: float = None @@ -42065,11 +58531,20 @@ def __call__(self): return "TRBBTC" -TRBBTC = TRBBTC() +TRBBUSD = TRBBUSD() @dataclass(slots=True, frozen=True) class TRBBUSD: + """ + name: TRBBUSD + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 90000.00000000 + margin: True + """ name: str = "TRBBUSD" precision: int = 8 minimum_margin: float = None @@ -42088,11 +58563,20 @@ def __call__(self): return "TRBBUSD" -TRBBUSD = TRBBUSD() +TRBUSDT = TRBUSDT() @dataclass(slots=True, frozen=True) class TRBUSDT: + """ + name: TRBUSDT + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 90000.00000000 + margin: True + """ name: str = "TRBUSDT" precision: int = 8 minimum_margin: float = None @@ -42111,11 +58595,20 @@ def __call__(self): return "TRBUSDT" -TRBUSDT = TRBUSDT() +TRIBEBNB = TRIBEBNB() @dataclass(slots=True, frozen=True) class TRIBEBNB: + """ + name: TRIBEBNB + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 92141578.00000000 + margin: False + """ name: str = "TRIBEBNB" precision: int = 8 minimum_margin: float = None @@ -42134,11 +58627,20 @@ def __call__(self): return "TRIBEBNB" -TRIBEBNB = TRIBEBNB() +TRIBEBTC = TRIBEBTC() @dataclass(slots=True, frozen=True) class TRIBEBTC: + """ + name: TRIBEBTC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 92141578.00000000 + margin: False + """ name: str = "TRIBEBTC" precision: int = 8 minimum_margin: float = None @@ -42157,11 +58659,20 @@ def __call__(self): return "TRIBEBTC" -TRIBEBTC = TRIBEBTC() +TRIBEBUSD = TRIBEBUSD() @dataclass(slots=True, frozen=True) class TRIBEBUSD: + """ + name: TRIBEBUSD + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 92141578.00000000 + margin: False + """ name: str = "TRIBEBUSD" precision: int = 8 minimum_margin: float = None @@ -42180,11 +58691,20 @@ def __call__(self): return "TRIBEBUSD" -TRIBEBUSD = TRIBEBUSD() +TRIBEUSDT = TRIBEUSDT() @dataclass(slots=True, frozen=True) class TRIBEUSDT: + """ + name: TRIBEUSDT + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 92141578.00000000 + margin: False + """ name: str = "TRIBEUSDT" precision: int = 8 minimum_margin: float = None @@ -42203,11 +58723,20 @@ def __call__(self): return "TRIBEUSDT" -TRIBEUSDT = TRIBEUSDT() +TRIGBNB = TRIGBNB() @dataclass(slots=True, frozen=True) class TRIGBNB: + """ + name: TRIGBNB + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 9000000.00000000 + margin: False + """ name: str = "TRIGBNB" precision: int = 8 minimum_margin: float = None @@ -42226,11 +58755,20 @@ def __call__(self): return "TRIGBNB" -TRIGBNB = TRIGBNB() +TRIGBTC = TRIGBTC() @dataclass(slots=True, frozen=True) class TRIGBTC: + """ + name: TRIGBTC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 90000000.00000000 + margin: False + """ name: str = "TRIGBTC" precision: int = 8 minimum_margin: float = None @@ -42249,11 +58787,20 @@ def __call__(self): return "TRIGBTC" -TRIGBTC = TRIGBTC() +TRIGETH = TRIGETH() @dataclass(slots=True, frozen=True) class TRIGETH: + """ + name: TRIGETH + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 90000000.00000000 + margin: False + """ name: str = "TRIGETH" precision: int = 8 minimum_margin: float = None @@ -42272,11 +58819,20 @@ def __call__(self): return "TRIGETH" -TRIGETH = TRIGETH() +TROYBNB = TROYBNB() @dataclass(slots=True, frozen=True) class TROYBNB: + """ + name: TROYBNB + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 90000000.00000000 + margin: False + """ name: str = "TROYBNB" precision: int = 8 minimum_margin: float = None @@ -42295,11 +58851,20 @@ def __call__(self): return "TROYBNB" -TROYBNB = TROYBNB() +TROYBTC = TROYBTC() @dataclass(slots=True, frozen=True) class TROYBTC: + """ + name: TROYBTC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 92141578.00000000 + margin: True + """ name: str = "TROYBTC" precision: int = 8 minimum_margin: float = None @@ -42318,11 +58883,20 @@ def __call__(self): return "TROYBTC" -TROYBTC = TROYBTC() +TROYBUSD = TROYBUSD() @dataclass(slots=True, frozen=True) class TROYBUSD: + """ + name: TROYBUSD + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 92141578.00000000 + margin: True + """ name: str = "TROYBUSD" precision: int = 8 minimum_margin: float = None @@ -42341,11 +58915,20 @@ def __call__(self): return "TROYBUSD" -TROYBUSD = TROYBUSD() +TROYUSDT = TROYUSDT() @dataclass(slots=True, frozen=True) class TROYUSDT: + """ + name: TROYUSDT + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 92141578.00000000 + margin: True + """ name: str = "TROYUSDT" precision: int = 8 minimum_margin: float = None @@ -42364,11 +58947,20 @@ def __call__(self): return "TROYUSDT" -TROYUSDT = TROYUSDT() +TRUBTC = TRUBTC() @dataclass(slots=True, frozen=True) class TRUBTC: + """ + name: TRUBTC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 90000000.00000000 + margin: True + """ name: str = "TRUBTC" precision: int = 8 minimum_margin: float = None @@ -42387,11 +58979,20 @@ def __call__(self): return "TRUBTC" -TRUBTC = TRUBTC() +TRUBUSD = TRUBUSD() @dataclass(slots=True, frozen=True) class TRUBUSD: + """ + name: TRUBUSD + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 9222449.00000000 + margin: False + """ name: str = "TRUBUSD" precision: int = 8 minimum_margin: float = None @@ -42410,11 +59011,20 @@ def __call__(self): return "TRUBUSD" -TRUBUSD = TRUBUSD() +TRURUB = TRURUB() @dataclass(slots=True, frozen=True) class TRURUB: + """ + name: TRURUB + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 9222449.00000000 + margin: False + """ name: str = "TRURUB" precision: int = 8 minimum_margin: float = None @@ -42433,11 +59043,20 @@ def __call__(self): return "TRURUB" -TRURUB = TRURUB() +TRUUSDT = TRUUSDT() @dataclass(slots=True, frozen=True) class TRUUSDT: + """ + name: TRUUSDT + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 9222449.00000000 + margin: True + """ name: str = "TRUUSDT" precision: int = 8 minimum_margin: float = None @@ -42456,11 +59075,20 @@ def __call__(self): return "TRUUSDT" -TRUUSDT = TRUUSDT() +TRXAUD = TRXAUD() @dataclass(slots=True, frozen=True) class TRXAUD: + """ + name: TRXAUD + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 90000000.00000000 + margin: False + """ name: str = "TRXAUD" precision: int = 8 minimum_margin: float = None @@ -42479,11 +59107,20 @@ def __call__(self): return "TRXAUD" -TRXAUD = TRXAUD() +TRXBNB = TRXBNB() @dataclass(slots=True, frozen=True) class TRXBNB: + """ + name: TRXBNB + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 9000000.00000000 + margin: False + """ name: str = "TRXBNB" precision: int = 8 minimum_margin: float = None @@ -42502,11 +59139,20 @@ def __call__(self): return "TRXBNB" -TRXBNB = TRXBNB() +TRXBTC = TRXBTC() @dataclass(slots=True, frozen=True) class TRXBTC: + """ + name: TRXBTC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 90000000.00000000 + margin: True + """ name: str = "TRXBTC" precision: int = 8 minimum_margin: float = None @@ -42525,11 +59171,20 @@ def __call__(self): return "TRXBTC" -TRXBTC = TRXBTC() +TRXBUSD = TRXBUSD() @dataclass(slots=True, frozen=True) class TRXBUSD: + """ + name: TRXBUSD + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 9000000.00000000 + margin: True + """ name: str = "TRXBUSD" precision: int = 8 minimum_margin: float = None @@ -42548,11 +59203,20 @@ def __call__(self): return "TRXBUSD" -TRXBUSD = TRXBUSD() +TRXDOWNUSDT = TRXDOWNUSDT() @dataclass(slots=True, frozen=True) class TRXDOWNUSDT: + """ + name: TRXDOWNUSDT + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 89984117.00000000 + margin: False + """ name: str = "TRXDOWNUSDT" precision: int = 8 minimum_margin: float = None @@ -42571,11 +59235,20 @@ def __call__(self): return "TRXDOWNUSDT" -TRXDOWNUSDT = TRXDOWNUSDT() +TRXETH = TRXETH() @dataclass(slots=True, frozen=True) class TRXETH: + """ + name: TRXETH + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 90000000.00000000 + margin: True + """ name: str = "TRXETH" precision: int = 8 minimum_margin: float = None @@ -42594,11 +59267,20 @@ def __call__(self): return "TRXETH" -TRXETH = TRXETH() +TRXEUR = TRXEUR() @dataclass(slots=True, frozen=True) class TRXEUR: + """ + name: TRXEUR + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 90000000.00000000 + margin: False + """ name: str = "TRXEUR" precision: int = 8 minimum_margin: float = None @@ -42617,11 +59299,20 @@ def __call__(self): return "TRXEUR" -TRXEUR = TRXEUR() +TRXNGN = TRXNGN() @dataclass(slots=True, frozen=True) class TRXNGN: + """ + name: TRXNGN + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 922320.00000000 + margin: False + """ name: str = "TRXNGN" precision: int = 8 minimum_margin: float = None @@ -42640,11 +59331,20 @@ def __call__(self): return "TRXNGN" -TRXNGN = TRXNGN() +TRXPAX = TRXPAX() @dataclass(slots=True, frozen=True) class TRXPAX: + """ + name: TRXPAX + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 9000000.00000000 + margin: False + """ name: str = "TRXPAX" precision: int = 8 minimum_margin: float = None @@ -42663,11 +59363,20 @@ def __call__(self): return "TRXPAX" -TRXPAX = TRXPAX() +TRXTRY = TRXTRY() @dataclass(slots=True, frozen=True) class TRXTRY: + """ + name: TRXTRY + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 92141578.00000000 + margin: False + """ name: str = "TRXTRY" precision: int = 8 minimum_margin: float = None @@ -42686,11 +59395,20 @@ def __call__(self): return "TRXTRY" -TRXTRY = TRXTRY() +TRXTUSD = TRXTUSD() @dataclass(slots=True, frozen=True) class TRXTUSD: + """ + name: TRXTUSD + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 9000000.00000000 + margin: False + """ name: str = "TRXTUSD" precision: int = 8 minimum_margin: float = None @@ -42709,11 +59427,20 @@ def __call__(self): return "TRXTUSD" -TRXTUSD = TRXTUSD() +TRXUPUSDT = TRXUPUSDT() @dataclass(slots=True, frozen=True) class TRXUPUSDT: + """ + name: TRXUPUSDT + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 920000.00000000 + margin: False + """ name: str = "TRXUPUSDT" precision: int = 8 minimum_margin: float = None @@ -42732,11 +59459,20 @@ def __call__(self): return "TRXUPUSDT" -TRXUPUSDT = TRXUPUSDT() +TRXUSDC = TRXUSDC() @dataclass(slots=True, frozen=True) class TRXUSDC: + """ + name: TRXUSDC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 9000000.00000000 + margin: False + """ name: str = "TRXUSDC" precision: int = 8 minimum_margin: float = None @@ -42755,11 +59491,20 @@ def __call__(self): return "TRXUSDC" -TRXUSDC = TRXUSDC() +TRXUSDT = TRXUSDT() @dataclass(slots=True, frozen=True) class TRXUSDT: + """ + name: TRXUSDT + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 9000000.00000000 + margin: True + """ name: str = "TRXUSDT" precision: int = 8 minimum_margin: float = None @@ -42778,11 +59523,20 @@ def __call__(self): return "TRXUSDT" -TRXUSDT = TRXUSDT() +TRXXRP = TRXXRP() @dataclass(slots=True, frozen=True) class TRXXRP: + """ + name: TRXXRP + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 9000000.00000000 + margin: False + """ name: str = "TRXXRP" precision: int = 8 minimum_margin: float = None @@ -42801,11 +59555,20 @@ def __call__(self): return "TRXXRP" -TRXXRP = TRXXRP() +TUSDBNB = TUSDBNB() @dataclass(slots=True, frozen=True) class TUSDBNB: + """ + name: TUSDBNB + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 9000000.00000000 + margin: False + """ name: str = "TUSDBNB" precision: int = 8 minimum_margin: float = None @@ -42824,11 +59587,20 @@ def __call__(self): return "TUSDBNB" -TUSDBNB = TUSDBNB() +TUSDBTC = TUSDBTC() @dataclass(slots=True, frozen=True) class TUSDBTC: + """ + name: TUSDBTC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 90000000.00000000 + margin: False + """ name: str = "TUSDBTC" precision: int = 8 minimum_margin: float = None @@ -42847,11 +59619,20 @@ def __call__(self): return "TUSDBTC" -TUSDBTC = TUSDBTC() +TUSDBTUSD = TUSDBTUSD() @dataclass(slots=True, frozen=True) class TUSDBTUSD: + """ + name: TUSDBTUSD + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 900000.00000000 + margin: False + """ name: str = "TUSDBTUSD" precision: int = 8 minimum_margin: float = None @@ -42870,11 +59651,20 @@ def __call__(self): return "TUSDBTUSD" -TUSDBTUSD = TUSDBTUSD() +TUSDBUSD = TUSDBUSD() @dataclass(slots=True, frozen=True) class TUSDBUSD: + """ + name: TUSDBUSD + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 900000.00000000 + margin: False + """ name: str = "TUSDBUSD" precision: int = 8 minimum_margin: float = None @@ -42893,11 +59683,20 @@ def __call__(self): return "TUSDBUSD" -TUSDBUSD = TUSDBUSD() +TUSDETH = TUSDETH() @dataclass(slots=True, frozen=True) class TUSDETH: + """ + name: TUSDETH + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 90000000.00000000 + margin: False + """ name: str = "TUSDETH" precision: int = 8 minimum_margin: float = None @@ -42916,11 +59715,20 @@ def __call__(self): return "TUSDETH" -TUSDETH = TUSDETH() +TUSDT = TUSDT() @dataclass(slots=True, frozen=True) class TUSDT: + """ + name: TUSDT + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 92141578.00000000 + margin: False + """ name: str = "TUSDT" precision: int = 8 minimum_margin: float = None @@ -42939,11 +59747,20 @@ def __call__(self): return "TUSDT" -TUSDT = TUSDT() +TUSDUSDT = TUSDUSDT() @dataclass(slots=True, frozen=True) class TUSDUSDT: + """ + name: TUSDUSDT + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 900000.00000000 + margin: False + """ name: str = "TUSDUSDT" precision: int = 8 minimum_margin: float = None @@ -42962,11 +59779,20 @@ def __call__(self): return "TUSDUSDT" -TUSDUSDT = TUSDUSDT() +TVKBTC = TVKBTC() @dataclass(slots=True, frozen=True) class TVKBTC: + """ + name: TVKBTC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 90000000.00000000 + margin: True + """ name: str = "TVKBTC" precision: int = 8 minimum_margin: float = None @@ -42985,11 +59811,20 @@ def __call__(self): return "TVKBTC" -TVKBTC = TVKBTC() +TVKBUSD = TVKBUSD() @dataclass(slots=True, frozen=True) class TVKBUSD: + """ + name: TVKBUSD + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 9222449.00000000 + margin: True + """ name: str = "TVKBUSD" precision: int = 8 minimum_margin: float = None @@ -43008,11 +59843,20 @@ def __call__(self): return "TVKBUSD" -TVKBUSD = TVKBUSD() +TVKUSDT = TVKUSDT() @dataclass(slots=True, frozen=True) class TVKUSDT: + """ + name: TVKUSDT + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 92141578.00000000 + margin: True + """ name: str = "TVKUSDT" precision: int = 8 minimum_margin: float = None @@ -43031,11 +59875,20 @@ def __call__(self): return "TVKUSDT" -TVKUSDT = TVKUSDT() +TWTBTC = TWTBTC() @dataclass(slots=True, frozen=True) class TWTBTC: + """ + name: TWTBTC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 90000000.00000000 + margin: False + """ name: str = "TWTBTC" precision: int = 8 minimum_margin: float = None @@ -43054,11 +59907,20 @@ def __call__(self): return "TWTBTC" -TWTBTC = TWTBTC() +TWTBUSD = TWTBUSD() @dataclass(slots=True, frozen=True) class TWTBUSD: + """ + name: TWTBUSD + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 900000.00000000 + margin: False + """ name: str = "TWTBUSD" precision: int = 8 minimum_margin: float = None @@ -43077,11 +59939,20 @@ def __call__(self): return "TWTBUSD" -TWTBUSD = TWTBUSD() +TWTTRY = TWTTRY() @dataclass(slots=True, frozen=True) class TWTTRY: + """ + name: TWTTRY + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 9222449.00000000 + margin: False + """ name: str = "TWTTRY" precision: int = 8 minimum_margin: float = None @@ -43100,11 +59971,20 @@ def __call__(self): return "TWTTRY" -TWTTRY = TWTTRY() +TWTUSDT = TWTUSDT() @dataclass(slots=True, frozen=True) class TWTUSDT: + """ + name: TWTUSDT + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 900000.00000000 + margin: True + """ name: str = "TWTUSDT" precision: int = 8 minimum_margin: float = None @@ -43123,11 +60003,20 @@ def __call__(self): return "TWTUSDT" -TWTUSDT = TWTUSDT() +UFTBUSD = UFTBUSD() @dataclass(slots=True, frozen=True) class UFTBUSD: + """ + name: UFTBUSD + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 900000.00000000 + margin: False + """ name: str = "UFTBUSD" precision: int = 8 minimum_margin: float = None @@ -43146,11 +60035,20 @@ def __call__(self): return "UFTBUSD" -UFTBUSD = UFTBUSD() +UFTETH = UFTETH() @dataclass(slots=True, frozen=True) class UFTETH: + """ + name: UFTETH + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 9000000.00000000 + margin: False + """ name: str = "UFTETH" precision: int = 8 minimum_margin: float = None @@ -43169,11 +60067,20 @@ def __call__(self): return "UFTETH" -UFTETH = UFTETH() +UMABTC = UMABTC() @dataclass(slots=True, frozen=True) class UMABTC: + """ + name: UMABTC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 9000000.00000000 + margin: True + """ name: str = "UMABTC" precision: int = 8 minimum_margin: float = None @@ -43192,11 +60099,20 @@ def __call__(self): return "UMABTC" -UMABTC = UMABTC() +UMABUSD = UMABUSD() @dataclass(slots=True, frozen=True) class UMABUSD: + """ + name: UMABUSD + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 92141578.00000000 + margin: False + """ name: str = "UMABUSD" precision: int = 8 minimum_margin: float = None @@ -43215,11 +60131,20 @@ def __call__(self): return "UMABUSD" -UMABUSD = UMABUSD() +UMATRY = UMATRY() @dataclass(slots=True, frozen=True) class UMATRY: + """ + name: UMATRY + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 922327.00000000 + margin: False + """ name: str = "UMATRY" precision: int = 8 minimum_margin: float = None @@ -43238,11 +60163,20 @@ def __call__(self): return "UMATRY" -UMATRY = UMATRY() +UMAUSDT = UMAUSDT() @dataclass(slots=True, frozen=True) class UMAUSDT: + """ + name: UMAUSDT + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 90000.00000000 + margin: True + """ name: str = "UMAUSDT" precision: int = 8 minimum_margin: float = None @@ -43261,11 +60195,20 @@ def __call__(self): return "UMAUSDT" -UMAUSDT = UMAUSDT() +UNFIBNB = UNFIBNB() @dataclass(slots=True, frozen=True) class UNFIBNB: + """ + name: UNFIBNB + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 9000000.00000000 + margin: False + """ name: str = "UNFIBNB" precision: int = 8 minimum_margin: float = None @@ -43284,11 +60227,20 @@ def __call__(self): return "UNFIBNB" -UNFIBNB = UNFIBNB() +UNFIBTC = UNFIBTC() @dataclass(slots=True, frozen=True) class UNFIBTC: + """ + name: UNFIBTC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 90000000.00000000 + margin: False + """ name: str = "UNFIBTC" precision: int = 8 minimum_margin: float = None @@ -43307,11 +60259,20 @@ def __call__(self): return "UNFIBTC" -UNFIBTC = UNFIBTC() +UNFIBUSD = UNFIBUSD() @dataclass(slots=True, frozen=True) class UNFIBUSD: + """ + name: UNFIBUSD + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 90000.00000000 + margin: False + """ name: str = "UNFIBUSD" precision: int = 8 minimum_margin: float = None @@ -43330,11 +60291,20 @@ def __call__(self): return "UNFIBUSD" -UNFIBUSD = UNFIBUSD() +UNFIETH = UNFIETH() @dataclass(slots=True, frozen=True) class UNFIETH: + """ + name: UNFIETH + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 92141578.00000000 + margin: False + """ name: str = "UNFIETH" precision: int = 8 minimum_margin: float = None @@ -43353,11 +60323,20 @@ def __call__(self): return "UNFIETH" -UNFIETH = UNFIETH() +UNFIUSDT = UNFIUSDT() @dataclass(slots=True, frozen=True) class UNFIUSDT: + """ + name: UNFIUSDT + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 90000.00000000 + margin: True + """ name: str = "UNFIUSDT" precision: int = 8 minimum_margin: float = None @@ -43376,11 +60355,20 @@ def __call__(self): return "UNFIUSDT" -UNFIUSDT = UNFIUSDT() +UNIAUD = UNIAUD() @dataclass(slots=True, frozen=True) class UNIAUD: + """ + name: UNIAUD + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 9222449.00000000 + margin: False + """ name: str = "UNIAUD" precision: int = 8 minimum_margin: float = None @@ -43399,11 +60387,20 @@ def __call__(self): return "UNIAUD" -UNIAUD = UNIAUD() +UNIBNB = UNIBNB() @dataclass(slots=True, frozen=True) class UNIBNB: + """ + name: UNIBNB + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 9000000.00000000 + margin: False + """ name: str = "UNIBNB" precision: int = 8 minimum_margin: float = None @@ -43422,11 +60419,20 @@ def __call__(self): return "UNIBNB" -UNIBNB = UNIBNB() +UNIBTC = UNIBTC() @dataclass(slots=True, frozen=True) class UNIBTC: + """ + name: UNIBTC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 90000000.00000000 + margin: True + """ name: str = "UNIBTC" precision: int = 8 minimum_margin: float = None @@ -43445,11 +60451,20 @@ def __call__(self): return "UNIBTC" -UNIBTC = UNIBTC() +UNIBUSD = UNIBUSD() @dataclass(slots=True, frozen=True) class UNIBUSD: + """ + name: UNIBUSD + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 90000.00000000 + margin: True + """ name: str = "UNIBUSD" precision: int = 8 minimum_margin: float = None @@ -43468,11 +60483,20 @@ def __call__(self): return "UNIBUSD" -UNIBUSD = UNIBUSD() +UNIDOWNUSDT = UNIDOWNUSDT() @dataclass(slots=True, frozen=True) class UNIDOWNUSDT: + """ + name: UNIDOWNUSDT + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 99999999.00000000 + margin: False + """ name: str = "UNIDOWNUSDT" precision: int = 8 minimum_margin: float = None @@ -43491,11 +60515,20 @@ def __call__(self): return "UNIDOWNUSDT" -UNIDOWNUSDT = UNIDOWNUSDT() +UNIETH = UNIETH() @dataclass(slots=True, frozen=True) class UNIETH: + """ + name: UNIETH + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.00100000 + maximum_order_size: 92141578.00000000 + margin: False + """ name: str = "UNIETH" precision: int = 8 minimum_margin: float = None @@ -43514,11 +60547,20 @@ def __call__(self): return "UNIETH" -UNIETH = UNIETH() +UNIEUR = UNIEUR() @dataclass(slots=True, frozen=True) class UNIEUR: + """ + name: UNIEUR + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 90000.00000000 + margin: False + """ name: str = "UNIEUR" precision: int = 8 minimum_margin: float = None @@ -43537,11 +60579,20 @@ def __call__(self): return "UNIEUR" -UNIEUR = UNIEUR() +UNIUPUSDT = UNIUPUSDT() @dataclass(slots=True, frozen=True) class UNIUPUSDT: + """ + name: UNIUPUSDT + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 920000.00000000 + margin: False + """ name: str = "UNIUPUSDT" precision: int = 8 minimum_margin: float = None @@ -43560,11 +60611,20 @@ def __call__(self): return "UNIUPUSDT" -UNIUPUSDT = UNIUPUSDT() +UNIUSDT = UNIUSDT() @dataclass(slots=True, frozen=True) class UNIUSDT: + """ + name: UNIUSDT + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 90000.00000000 + margin: True + """ name: str = "UNIUSDT" precision: int = 8 minimum_margin: float = None @@ -43583,11 +60643,20 @@ def __call__(self): return "UNIUSDT" -UNIUSDT = UNIUSDT() +USDCBNB = USDCBNB() @dataclass(slots=True, frozen=True) class USDCBNB: + """ + name: USDCBNB + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 9000000.00000000 + margin: False + """ name: str = "USDCBNB" precision: int = 8 minimum_margin: float = None @@ -43606,11 +60675,20 @@ def __call__(self): return "USDCBNB" -USDCBNB = USDCBNB() +USDCBUSD = USDCBUSD() @dataclass(slots=True, frozen=True) class USDCBUSD: + """ + name: USDCBUSD + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 9000000.00000000 + margin: False + """ name: str = "USDCBUSD" precision: int = 8 minimum_margin: float = None @@ -43629,11 +60707,20 @@ def __call__(self): return "USDCBUSD" -USDCBUSD = USDCBUSD() +USDCPAX = USDCPAX() @dataclass(slots=True, frozen=True) class USDCPAX: + """ + name: USDCPAX + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 900000.00000000 + margin: False + """ name: str = "USDCPAX" precision: int = 8 minimum_margin: float = None @@ -43652,11 +60739,20 @@ def __call__(self): return "USDCPAX" -USDCPAX = USDCPAX() +USDCTUSD = USDCTUSD() @dataclass(slots=True, frozen=True) class USDCTUSD: + """ + name: USDCTUSD + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 900000.00000000 + margin: False + """ name: str = "USDCTUSD" precision: int = 8 minimum_margin: float = None @@ -43675,11 +60771,20 @@ def __call__(self): return "USDCTUSD" -USDCTUSD = USDCTUSD() +USDCUSDT = USDCUSDT() @dataclass(slots=True, frozen=True) class USDCUSDT: + """ + name: USDCUSDT + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 9000000.00000000 + margin: False + """ name: str = "USDCUSDT" precision: int = 8 minimum_margin: float = None @@ -43698,11 +60803,20 @@ def __call__(self): return "USDCUSDT" -USDCUSDT = USDCUSDT() +USDPBUSD = USDPBUSD() @dataclass(slots=True, frozen=True) class USDPBUSD: + """ + name: USDPBUSD + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 92141578.00000000 + margin: False + """ name: str = "USDPBUSD" precision: int = 8 minimum_margin: float = None @@ -43721,11 +60835,20 @@ def __call__(self): return "USDPBUSD" -USDPBUSD = USDPBUSD() +USDPUSDT = USDPUSDT() @dataclass(slots=True, frozen=True) class USDPUSDT: + """ + name: USDPUSDT + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 92141578.00000000 + margin: False + """ name: str = "USDPUSDT" precision: int = 8 minimum_margin: float = None @@ -43744,11 +60867,20 @@ def __call__(self): return "USDPUSDT" -USDPUSDT = USDPUSDT() +USDSBUSDS = USDSBUSDS() @dataclass(slots=True, frozen=True) class USDSBUSDS: + """ + name: USDSBUSDS + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 900000.00000000 + margin: False + """ name: str = "USDSBUSDS" precision: int = 8 minimum_margin: float = None @@ -43767,11 +60899,20 @@ def __call__(self): return "USDSBUSDS" -USDSBUSDS = USDSBUSDS() +USDSBUSDT = USDSBUSDT() @dataclass(slots=True, frozen=True) class USDSBUSDT: + """ + name: USDSBUSDT + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 900000.00000000 + margin: False + """ name: str = "USDSBUSDT" precision: int = 8 minimum_margin: float = None @@ -43790,11 +60931,20 @@ def __call__(self): return "USDSBUSDT" -USDSBUSDT = USDSBUSDT() +USDSPAX = USDSPAX() @dataclass(slots=True, frozen=True) class USDSPAX: + """ + name: USDSPAX + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 900000.00000000 + margin: False + """ name: str = "USDSPAX" precision: int = 8 minimum_margin: float = None @@ -43813,11 +60963,20 @@ def __call__(self): return "USDSPAX" -USDSPAX = USDSPAX() +USDSTUSD = USDSTUSD() @dataclass(slots=True, frozen=True) class USDSTUSD: + """ + name: USDSTUSD + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 900000.00000000 + margin: False + """ name: str = "USDSTUSD" precision: int = 8 minimum_margin: float = None @@ -43836,11 +60995,20 @@ def __call__(self): return "USDSTUSD" -USDSTUSD = USDSTUSD() +USDSUSDC = USDSUSDC() @dataclass(slots=True, frozen=True) class USDSUSDC: + """ + name: USDSUSDC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 900000.00000000 + margin: False + """ name: str = "USDSUSDC" precision: int = 8 minimum_margin: float = None @@ -43859,11 +61027,20 @@ def __call__(self): return "USDSUSDC" -USDSUSDC = USDSUSDC() +USDSUSDT = USDSUSDT() @dataclass(slots=True, frozen=True) class USDSUSDT: + """ + name: USDSUSDT + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 900000.00000000 + margin: False + """ name: str = "USDSUSDT" precision: int = 8 minimum_margin: float = None @@ -43882,11 +61059,20 @@ def __call__(self): return "USDSUSDT" -USDSUSDT = USDSUSDT() +USDTBIDR = USDTBIDR() @dataclass(slots=True, frozen=True) class USDTBIDR: + """ + name: USDTBIDR + precision: 2 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 1000000.00000000 + margin: False + """ name: str = "USDTBIDR" precision: int = 2 minimum_margin: float = None @@ -43905,11 +61091,20 @@ def __call__(self): return "USDTBIDR" -USDTBIDR = USDTBIDR() +USDTBKRW = USDTBKRW() @dataclass(slots=True, frozen=True) class USDTBKRW: + """ + name: USDTBKRW + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 922327.00000000 + margin: False + """ name: str = "USDTBKRW" precision: int = 8 minimum_margin: float = None @@ -43928,11 +61123,20 @@ def __call__(self): return "USDTBKRW" -USDTBKRW = USDTBKRW() +USDTBRL = USDTBRL() @dataclass(slots=True, frozen=True) class USDTBRL: + """ + name: USDTBRL + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 9222449.00000000 + margin: False + """ name: str = "USDTBRL" precision: int = 8 minimum_margin: float = None @@ -43951,11 +61155,20 @@ def __call__(self): return "USDTBRL" -USDTBRL = USDTBRL() +USDTBVND = USDTBVND() @dataclass(slots=True, frozen=True) class USDTBVND: + """ + name: USDTBVND + precision: 2 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 1000000.00000000 + margin: False + """ name: str = "USDTBVND" precision: int = 2 minimum_margin: float = None @@ -43974,11 +61187,20 @@ def __call__(self): return "USDTBVND" -USDTBVND = USDTBVND() +USDTDAI = USDTDAI() @dataclass(slots=True, frozen=True) class USDTDAI: + """ + name: USDTDAI + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 900000.00000000 + margin: False + """ name: str = "USDTDAI" precision: int = 8 minimum_margin: float = None @@ -43997,11 +61219,20 @@ def __call__(self): return "USDTDAI" -USDTDAI = USDTDAI() +USDTIDRT = USDTIDRT() @dataclass(slots=True, frozen=True) class USDTIDRT: + """ + name: USDTIDRT + precision: 2 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 1000000.00000000 + margin: False + """ name: str = "USDTIDRT" precision: int = 2 minimum_margin: float = None @@ -44020,11 +61251,20 @@ def __call__(self): return "USDTIDRT" -USDTIDRT = USDTIDRT() +USDTNGN = USDTNGN() @dataclass(slots=True, frozen=True) class USDTNGN: + """ + name: USDTNGN + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 922320.00000000 + margin: False + """ name: str = "USDTNGN" precision: int = 8 minimum_margin: float = None @@ -44043,11 +61283,20 @@ def __call__(self): return "USDTNGN" -USDTNGN = USDTNGN() +USDTRUB = USDTRUB() @dataclass(slots=True, frozen=True) class USDTRUB: + """ + name: USDTRUB + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 9222449.00000000 + margin: False + """ name: str = "USDTRUB" precision: int = 8 minimum_margin: float = None @@ -44066,11 +61315,20 @@ def __call__(self): return "USDTRUB" -USDTRUB = USDTRUB() +USDTTRY = USDTTRY() @dataclass(slots=True, frozen=True) class USDTTRY: + """ + name: USDTTRY + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 92141578.00000000 + margin: False + """ name: str = "USDTTRY" precision: int = 8 minimum_margin: float = None @@ -44089,11 +61347,20 @@ def __call__(self): return "USDTTRY" -USDTTRY = USDTTRY() +USDTUAH = USDTUAH() @dataclass(slots=True, frozen=True) class USDTUAH: + """ + name: USDTUAH + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 922327.00000000 + margin: False + """ name: str = "USDTUAH" precision: int = 8 minimum_margin: float = None @@ -44112,11 +61379,20 @@ def __call__(self): return "USDTUAH" -USDTUAH = USDTUAH() +USDTZAR = USDTZAR() @dataclass(slots=True, frozen=True) class USDTZAR: + """ + name: USDTZAR + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 100000.00000000 + margin: False + """ name: str = "USDTZAR" precision: int = 8 minimum_margin: float = None @@ -44135,11 +61411,20 @@ def __call__(self): return "USDTZAR" -USDTZAR = USDTZAR() +USTBTC = USTBTC() @dataclass(slots=True, frozen=True) class USTBTC: + """ + name: USTBTC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 92141578.00000000 + margin: False + """ name: str = "USTBTC" precision: int = 8 minimum_margin: float = None @@ -44158,11 +61443,20 @@ def __call__(self): return "USTBTC" -USTBTC = USTBTC() +USTBUSD = USTBUSD() @dataclass(slots=True, frozen=True) class USTBUSD: + """ + name: USTBUSD + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 92141578.00000000 + margin: False + """ name: str = "USTBUSD" precision: int = 8 minimum_margin: float = None @@ -44181,11 +61475,20 @@ def __call__(self): return "USTBUSD" -USTBUSD = USTBUSD() +USTCBUSD = USTCBUSD() @dataclass(slots=True, frozen=True) class USTCBUSD: + """ + name: USTCBUSD + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 92141578.00000000 + margin: True + """ name: str = "USTCBUSD" precision: int = 8 minimum_margin: float = None @@ -44204,11 +61507,20 @@ def __call__(self): return "USTCBUSD" -USTCBUSD = USTCBUSD() +USTUSDT = USTUSDT() @dataclass(slots=True, frozen=True) class USTUSDT: + """ + name: USTUSDT + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 92141578.00000000 + margin: False + """ name: str = "USTUSDT" precision: int = 8 minimum_margin: float = None @@ -44227,11 +61539,20 @@ def __call__(self): return "USTUSDT" -USTUSDT = USTUSDT() +UTKBTC = UTKBTC() @dataclass(slots=True, frozen=True) class UTKBTC: + """ + name: UTKBTC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 90000000.00000000 + margin: True + """ name: str = "UTKBTC" precision: int = 8 minimum_margin: float = None @@ -44250,11 +61571,20 @@ def __call__(self): return "UTKBTC" -UTKBTC = UTKBTC() +UTKBUSD = UTKBUSD() @dataclass(slots=True, frozen=True) class UTKBUSD: + """ + name: UTKBUSD + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 92141578.00000000 + margin: False + """ name: str = "UTKBUSD" precision: int = 8 minimum_margin: float = None @@ -44273,11 +61603,20 @@ def __call__(self): return "UTKBUSD" -UTKBUSD = UTKBUSD() +UTKUSDT = UTKUSDT() @dataclass(slots=True, frozen=True) class UTKUSDT: + """ + name: UTKUSDT + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 900000.00000000 + margin: True + """ name: str = "UTKUSDT" precision: int = 8 minimum_margin: float = None @@ -44296,11 +61635,20 @@ def __call__(self): return "UTKUSDT" -UTKUSDT = UTKUSDT() +VENBNB = VENBNB() @dataclass(slots=True, frozen=True) class VENBNB: + """ + name: VENBNB + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 900000.00000000 + margin: False + """ name: str = "VENBNB" precision: int = 8 minimum_margin: float = None @@ -44319,11 +61667,20 @@ def __call__(self): return "VENBNB" -VENBNB = VENBNB() +VENBTC = VENBTC() @dataclass(slots=True, frozen=True) class VENBTC: + """ + name: VENBTC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 90000000.00000000 + margin: False + """ name: str = "VENBTC" precision: int = 8 minimum_margin: float = None @@ -44342,11 +61699,20 @@ def __call__(self): return "VENBTC" -VENBTC = VENBTC() +VENETH = VENETH() @dataclass(slots=True, frozen=True) class VENETH: + """ + name: VENETH + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 90000000.00000000 + margin: False + """ name: str = "VENETH" precision: int = 8 minimum_margin: float = None @@ -44365,11 +61731,20 @@ def __call__(self): return "VENETH" -VENETH = VENETH() +VENUSDT = VENUSDT() @dataclass(slots=True, frozen=True) class VENUSDT: + """ + name: VENUSDT + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 900000.00000000 + margin: False + """ name: str = "VENUSDT" precision: int = 8 minimum_margin: float = None @@ -44388,11 +61763,20 @@ def __call__(self): return "VENUSDT" -VENUSDT = VENUSDT() +VETBNB = VETBNB() @dataclass(slots=True, frozen=True) class VETBNB: + """ + name: VETBNB + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 9000000.00000000 + margin: False + """ name: str = "VETBNB" precision: int = 8 minimum_margin: float = None @@ -44411,11 +61795,20 @@ def __call__(self): return "VETBNB" -VETBNB = VETBNB() +VETBTC = VETBTC() @dataclass(slots=True, frozen=True) class VETBTC: + """ + name: VETBTC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 90000000.00000000 + margin: True + """ name: str = "VETBTC" precision: int = 8 minimum_margin: float = None @@ -44434,11 +61827,20 @@ def __call__(self): return "VETBTC" -VETBTC = VETBTC() +VETBUSD = VETBUSD() @dataclass(slots=True, frozen=True) class VETBUSD: + """ + name: VETBUSD + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 9000000.00000000 + margin: True + """ name: str = "VETBUSD" precision: int = 8 minimum_margin: float = None @@ -44457,11 +61859,20 @@ def __call__(self): return "VETBUSD" -VETBUSD = VETBUSD() +VETETH = VETETH() @dataclass(slots=True, frozen=True) class VETETH: + """ + name: VETETH + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 90000000.00000000 + margin: False + """ name: str = "VETETH" precision: int = 8 minimum_margin: float = None @@ -44480,11 +61891,20 @@ def __call__(self): return "VETETH" -VETETH = VETETH() +VETEUR = VETEUR() @dataclass(slots=True, frozen=True) class VETEUR: + """ + name: VETEUR + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 92141578.00000000 + margin: False + """ name: str = "VETEUR" precision: int = 8 minimum_margin: float = None @@ -44503,11 +61923,20 @@ def __call__(self): return "VETEUR" -VETEUR = VETEUR() +VETGBP = VETGBP() @dataclass(slots=True, frozen=True) class VETGBP: + """ + name: VETGBP + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 92141578.00000000 + margin: False + """ name: str = "VETGBP" precision: int = 8 minimum_margin: float = None @@ -44526,11 +61955,20 @@ def __call__(self): return "VETGBP" -VETGBP = VETGBP() +VETTRY = VETTRY() @dataclass(slots=True, frozen=True) class VETTRY: + """ + name: VETTRY + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 9222449.00000000 + margin: False + """ name: str = "VETTRY" precision: int = 8 minimum_margin: float = None @@ -44549,11 +61987,20 @@ def __call__(self): return "VETTRY" -VETTRY = VETTRY() +VETUSDT = VETUSDT() @dataclass(slots=True, frozen=True) class VETUSDT: + """ + name: VETUSDT + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 9000000.00000000 + margin: True + """ name: str = "VETUSDT" precision: int = 8 minimum_margin: float = None @@ -44572,11 +62019,20 @@ def __call__(self): return "VETUSDT" -VETUSDT = VETUSDT() +VGXBTC = VGXBTC() @dataclass(slots=True, frozen=True) class VGXBTC: + """ + name: VGXBTC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 92141578.00000000 + margin: False + """ name: str = "VGXBTC" precision: int = 8 minimum_margin: float = None @@ -44595,11 +62051,20 @@ def __call__(self): return "VGXBTC" -VGXBTC = VGXBTC() +VGXETH = VGXETH() @dataclass(slots=True, frozen=True) class VGXETH: + """ + name: VGXETH + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 92141578.00000000 + margin: False + """ name: str = "VGXETH" precision: int = 8 minimum_margin: float = None @@ -44618,11 +62083,20 @@ def __call__(self): return "VGXETH" -VGXETH = VGXETH() +VGXUSDT = VGXUSDT() @dataclass(slots=True, frozen=True) class VGXUSDT: + """ + name: VGXUSDT + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 92141578.00000000 + margin: False + """ name: str = "VGXUSDT" precision: int = 8 minimum_margin: float = None @@ -44641,11 +62115,20 @@ def __call__(self): return "VGXUSDT" -VGXUSDT = VGXUSDT() +VIABNB = VIABNB() @dataclass(slots=True, frozen=True) class VIABNB: + """ + name: VIABNB + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 9000000.00000000 + margin: False + """ name: str = "VIABNB" precision: int = 8 minimum_margin: float = None @@ -44664,11 +62147,20 @@ def __call__(self): return "VIABNB" -VIABNB = VIABNB() +VIABTC = VIABTC() @dataclass(slots=True, frozen=True) class VIABTC: + """ + name: VIABTC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 90000000.00000000 + margin: False + """ name: str = "VIABTC" precision: int = 8 minimum_margin: float = None @@ -44687,11 +62179,20 @@ def __call__(self): return "VIABTC" -VIABTC = VIABTC() +VIAETH = VIAETH() @dataclass(slots=True, frozen=True) class VIAETH: + """ + name: VIAETH + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 90000000.00000000 + margin: False + """ name: str = "VIAETH" precision: int = 8 minimum_margin: float = None @@ -44710,11 +62211,20 @@ def __call__(self): return "VIAETH" -VIAETH = VIAETH() +VIBBTC = VIBBTC() @dataclass(slots=True, frozen=True) class VIBBTC: + """ + name: VIBBTC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 90000000.00000000 + margin: False + """ name: str = "VIBBTC" precision: int = 8 minimum_margin: float = None @@ -44733,11 +62243,20 @@ def __call__(self): return "VIBBTC" -VIBBTC = VIBBTC() +VIBBUSD = VIBBUSD() @dataclass(slots=True, frozen=True) class VIBBUSD: + """ + name: VIBBUSD + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 92141578.00000000 + margin: True + """ name: str = "VIBBUSD" precision: int = 8 minimum_margin: float = None @@ -44756,11 +62275,20 @@ def __call__(self): return "VIBBUSD" -VIBBUSD = VIBBUSD() +VIBEBTC = VIBEBTC() @dataclass(slots=True, frozen=True) class VIBEBTC: + """ + name: VIBEBTC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 90000000.00000000 + margin: False + """ name: str = "VIBEBTC" precision: int = 8 minimum_margin: float = None @@ -44779,11 +62307,20 @@ def __call__(self): return "VIBEBTC" -VIBEBTC = VIBEBTC() +VIBEETH = VIBEETH() @dataclass(slots=True, frozen=True) class VIBEETH: + """ + name: VIBEETH + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 90000000.00000000 + margin: False + """ name: str = "VIBEETH" precision: int = 8 minimum_margin: float = None @@ -44802,11 +62339,20 @@ def __call__(self): return "VIBEETH" -VIBEETH = VIBEETH() +VIBETH = VIBETH() @dataclass(slots=True, frozen=True) class VIBETH: + """ + name: VIBETH + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 90000000.00000000 + margin: False + """ name: str = "VIBETH" precision: int = 8 minimum_margin: float = None @@ -44825,11 +62371,20 @@ def __call__(self): return "VIBETH" -VIBETH = VIBETH() +VIDTBTC = VIDTBTC() @dataclass(slots=True, frozen=True) class VIDTBTC: + """ + name: VIDTBTC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 46116860414.00000000 + margin: False + """ name: str = "VIDTBTC" precision: int = 8 minimum_margin: float = None @@ -44848,11 +62403,20 @@ def __call__(self): return "VIDTBTC" -VIDTBTC = VIDTBTC() +VIDTBUSD = VIDTBUSD() @dataclass(slots=True, frozen=True) class VIDTBUSD: + """ + name: VIDTBUSD + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 913205152.00000000 + margin: False + """ name: str = "VIDTBUSD" precision: int = 8 minimum_margin: float = None @@ -44871,11 +62435,20 @@ def __call__(self): return "VIDTBUSD" -VIDTBUSD = VIDTBUSD() +VIDTUSDT = VIDTUSDT() @dataclass(slots=True, frozen=True) class VIDTUSDT: + """ + name: VIDTUSDT + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 913205152.00000000 + margin: False + """ name: str = "VIDTUSDT" precision: int = 8 minimum_margin: float = None @@ -44894,11 +62467,20 @@ def __call__(self): return "VIDTUSDT" -VIDTUSDT = VIDTUSDT() +VITEBNB = VITEBNB() @dataclass(slots=True, frozen=True) class VITEBNB: + """ + name: VITEBNB + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 9000000.00000000 + margin: False + """ name: str = "VITEBNB" precision: int = 8 minimum_margin: float = None @@ -44917,11 +62499,20 @@ def __call__(self): return "VITEBNB" -VITEBNB = VITEBNB() +VITEBTC = VITEBTC() @dataclass(slots=True, frozen=True) class VITEBTC: + """ + name: VITEBTC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 90000000.00000000 + margin: False + """ name: str = "VITEBTC" precision: int = 8 minimum_margin: float = None @@ -44940,11 +62531,20 @@ def __call__(self): return "VITEBTC" -VITEBTC = VITEBTC() +VITEBUSD = VITEBUSD() @dataclass(slots=True, frozen=True) class VITEBUSD: + """ + name: VITEBUSD + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 9000000.00000000 + margin: False + """ name: str = "VITEBUSD" precision: int = 8 minimum_margin: float = None @@ -44963,11 +62563,20 @@ def __call__(self): return "VITEBUSD" -VITEBUSD = VITEBUSD() +VITEUSDT = VITEUSDT() @dataclass(slots=True, frozen=True) class VITEUSDT: + """ + name: VITEUSDT + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 9000000.00000000 + margin: False + """ name: str = "VITEUSDT" precision: int = 8 minimum_margin: float = None @@ -44986,11 +62595,20 @@ def __call__(self): return "VITEUSDT" -VITEUSDT = VITEUSDT() +VOXELBNB = VOXELBNB() @dataclass(slots=True, frozen=True) class VOXELBNB: + """ + name: VOXELBNB + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 92141578.00000000 + margin: False + """ name: str = "VOXELBNB" precision: int = 8 minimum_margin: float = None @@ -45009,11 +62627,20 @@ def __call__(self): return "VOXELBNB" -VOXELBNB = VOXELBNB() +VOXELBTC = VOXELBTC() @dataclass(slots=True, frozen=True) class VOXELBTC: + """ + name: VOXELBTC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 92141578.00000000 + margin: False + """ name: str = "VOXELBTC" precision: int = 8 minimum_margin: float = None @@ -45032,11 +62659,20 @@ def __call__(self): return "VOXELBTC" -VOXELBTC = VOXELBTC() +VOXELBUSD = VOXELBUSD() @dataclass(slots=True, frozen=True) class VOXELBUSD: + """ + name: VOXELBUSD + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 92141578.00000000 + margin: False + """ name: str = "VOXELBUSD" precision: int = 8 minimum_margin: float = None @@ -45055,11 +62691,20 @@ def __call__(self): return "VOXELBUSD" -VOXELBUSD = VOXELBUSD() +VOXELETH = VOXELETH() @dataclass(slots=True, frozen=True) class VOXELETH: + """ + name: VOXELETH + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 92141578.00000000 + margin: False + """ name: str = "VOXELETH" precision: int = 8 minimum_margin: float = None @@ -45078,11 +62723,20 @@ def __call__(self): return "VOXELETH" -VOXELETH = VOXELETH() +VOXELUSDT = VOXELUSDT() @dataclass(slots=True, frozen=True) class VOXELUSDT: + """ + name: VOXELUSDT + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 92141578.00000000 + margin: False + """ name: str = "VOXELUSDT" precision: int = 8 minimum_margin: float = None @@ -45101,11 +62755,20 @@ def __call__(self): return "VOXELUSDT" -VOXELUSDT = VOXELUSDT() +VTHOBNB = VTHOBNB() @dataclass(slots=True, frozen=True) class VTHOBNB: + """ + name: VTHOBNB + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 90000000.00000000 + margin: False + """ name: str = "VTHOBNB" precision: int = 8 minimum_margin: float = None @@ -45124,11 +62787,20 @@ def __call__(self): return "VTHOBNB" -VTHOBNB = VTHOBNB() +VTHOBUSD = VTHOBUSD() @dataclass(slots=True, frozen=True) class VTHOBUSD: + """ + name: VTHOBUSD + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 9000000.00000000 + margin: False + """ name: str = "VTHOBUSD" precision: int = 8 minimum_margin: float = None @@ -45147,11 +62819,20 @@ def __call__(self): return "VTHOBUSD" -VTHOBUSD = VTHOBUSD() +VTHOUSDT = VTHOUSDT() @dataclass(slots=True, frozen=True) class VTHOUSDT: + """ + name: VTHOUSDT + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 92141578.00000000 + margin: False + """ name: str = "VTHOUSDT" precision: int = 8 minimum_margin: float = None @@ -45170,11 +62851,20 @@ def __call__(self): return "VTHOUSDT" -VTHOUSDT = VTHOUSDT() +WABIBNB = WABIBNB() @dataclass(slots=True, frozen=True) class WABIBNB: + """ + name: WABIBNB + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 9000000.00000000 + margin: False + """ name: str = "WABIBNB" precision: int = 8 minimum_margin: float = None @@ -45193,11 +62883,20 @@ def __call__(self): return "WABIBNB" -WABIBNB = WABIBNB() +WABIBTC = WABIBTC() @dataclass(slots=True, frozen=True) class WABIBTC: + """ + name: WABIBTC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 90000000.00000000 + margin: False + """ name: str = "WABIBTC" precision: int = 8 minimum_margin: float = None @@ -45216,11 +62915,20 @@ def __call__(self): return "WABIBTC" -WABIBTC = WABIBTC() +WABIETH = WABIETH() @dataclass(slots=True, frozen=True) class WABIETH: + """ + name: WABIETH + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 90000000.00000000 + margin: False + """ name: str = "WABIETH" precision: int = 8 minimum_margin: float = None @@ -45239,11 +62947,20 @@ def __call__(self): return "WABIETH" -WABIETH = WABIETH() +WANBNB = WANBNB() @dataclass(slots=True, frozen=True) class WANBNB: + """ + name: WANBNB + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 9000000.00000000 + margin: False + """ name: str = "WANBNB" precision: int = 8 minimum_margin: float = None @@ -45262,11 +62979,20 @@ def __call__(self): return "WANBNB" -WANBNB = WANBNB() +WANBTC = WANBTC() @dataclass(slots=True, frozen=True) class WANBTC: + """ + name: WANBTC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 90000000.00000000 + margin: False + """ name: str = "WANBTC" precision: int = 8 minimum_margin: float = None @@ -45285,11 +63011,20 @@ def __call__(self): return "WANBTC" -WANBTC = WANBTC() +WANETH = WANETH() @dataclass(slots=True, frozen=True) class WANETH: + """ + name: WANETH + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 9000000.00000000 + margin: False + """ name: str = "WANETH" precision: int = 8 minimum_margin: float = None @@ -45308,11 +63043,20 @@ def __call__(self): return "WANETH" -WANETH = WANETH() +WANUSDT = WANUSDT() @dataclass(slots=True, frozen=True) class WANUSDT: + """ + name: WANUSDT + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 900000.00000000 + margin: False + """ name: str = "WANUSDT" precision: int = 8 minimum_margin: float = None @@ -45331,11 +63075,20 @@ def __call__(self): return "WANUSDT" -WANUSDT = WANUSDT() +WAVESBNB = WAVESBNB() @dataclass(slots=True, frozen=True) class WAVESBNB: + """ + name: WAVESBNB + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 9000000.00000000 + margin: False + """ name: str = "WAVESBNB" precision: int = 8 minimum_margin: float = None @@ -45354,11 +63107,20 @@ def __call__(self): return "WAVESBNB" -WAVESBNB = WAVESBNB() +WAVESBTC = WAVESBTC() @dataclass(slots=True, frozen=True) class WAVESBTC: + """ + name: WAVESBTC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 90000000.00000000 + margin: True + """ name: str = "WAVESBTC" precision: int = 8 minimum_margin: float = None @@ -45377,11 +63139,20 @@ def __call__(self): return "WAVESBTC" -WAVESBTC = WAVESBTC() +WAVESBUSD = WAVESBUSD() @dataclass(slots=True, frozen=True) class WAVESBUSD: + """ + name: WAVESBUSD + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 90000.00000000 + margin: True + """ name: str = "WAVESBUSD" precision: int = 8 minimum_margin: float = None @@ -45400,11 +63171,20 @@ def __call__(self): return "WAVESBUSD" -WAVESBUSD = WAVESBUSD() +WAVESETH = WAVESETH() @dataclass(slots=True, frozen=True) class WAVESETH: + """ + name: WAVESETH + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 90000000.00000000 + margin: False + """ name: str = "WAVESETH" precision: int = 8 minimum_margin: float = None @@ -45423,11 +63203,20 @@ def __call__(self): return "WAVESETH" -WAVESETH = WAVESETH() +WAVESEUR = WAVESEUR() @dataclass(slots=True, frozen=True) class WAVESEUR: + """ + name: WAVESEUR + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 90000.00000000 + margin: False + """ name: str = "WAVESEUR" precision: int = 8 minimum_margin: float = None @@ -45446,11 +63235,20 @@ def __call__(self): return "WAVESEUR" -WAVESEUR = WAVESEUR() +WAVESPAX = WAVESPAX() @dataclass(slots=True, frozen=True) class WAVESPAX: + """ + name: WAVESPAX + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 900000.00000000 + margin: False + """ name: str = "WAVESPAX" precision: int = 8 minimum_margin: float = None @@ -45469,11 +63267,20 @@ def __call__(self): return "WAVESPAX" -WAVESPAX = WAVESPAX() +WAVESRUB = WAVESRUB() @dataclass(slots=True, frozen=True) class WAVESRUB: + """ + name: WAVESRUB + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 92233.00000000 + margin: False + """ name: str = "WAVESRUB" precision: int = 8 minimum_margin: float = None @@ -45492,11 +63299,20 @@ def __call__(self): return "WAVESRUB" -WAVESRUB = WAVESRUB() +WAVESTRY = WAVESTRY() @dataclass(slots=True, frozen=True) class WAVESTRY: + """ + name: WAVESTRY + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.00100000 + maximum_order_size: 92233.00000000 + margin: False + """ name: str = "WAVESTRY" precision: int = 8 minimum_margin: float = None @@ -45515,11 +63331,20 @@ def __call__(self): return "WAVESTRY" -WAVESTRY = WAVESTRY() +WAVESTUSD = WAVESTUSD() @dataclass(slots=True, frozen=True) class WAVESTUSD: + """ + name: WAVESTUSD + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 900000.00000000 + margin: False + """ name: str = "WAVESTUSD" precision: int = 8 minimum_margin: float = None @@ -45538,11 +63363,20 @@ def __call__(self): return "WAVESTUSD" -WAVESTUSD = WAVESTUSD() +WAVESUSDC = WAVESUSDC() @dataclass(slots=True, frozen=True) class WAVESUSDC: + """ + name: WAVESUSDC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 900000.00000000 + margin: False + """ name: str = "WAVESUSDC" precision: int = 8 minimum_margin: float = None @@ -45561,11 +63395,20 @@ def __call__(self): return "WAVESUSDC" -WAVESUSDC = WAVESUSDC() +WAVESUSDT = WAVESUSDT() @dataclass(slots=True, frozen=True) class WAVESUSDT: + """ + name: WAVESUSDT + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 90000.00000000 + margin: True + """ name: str = "WAVESUSDT" precision: int = 8 minimum_margin: float = None @@ -45584,11 +63427,20 @@ def __call__(self): return "WAVESUSDT" -WAVESUSDT = WAVESUSDT() +WAXPBNB = WAXPBNB() @dataclass(slots=True, frozen=True) class WAXPBNB: + """ + name: WAXPBNB + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 92141578.00000000 + margin: False + """ name: str = "WAXPBNB" precision: int = 8 minimum_margin: float = None @@ -45607,11 +63459,20 @@ def __call__(self): return "WAXPBNB" -WAXPBNB = WAXPBNB() +WAXPBTC = WAXPBTC() @dataclass(slots=True, frozen=True) class WAXPBTC: + """ + name: WAXPBTC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 92141578.00000000 + margin: True + """ name: str = "WAXPBTC" precision: int = 8 minimum_margin: float = None @@ -45630,11 +63491,20 @@ def __call__(self): return "WAXPBTC" -WAXPBTC = WAXPBTC() +WAXPBUSD = WAXPBUSD() @dataclass(slots=True, frozen=True) class WAXPBUSD: + """ + name: WAXPBUSD + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 92141578.00000000 + margin: True + """ name: str = "WAXPBUSD" precision: int = 8 minimum_margin: float = None @@ -45653,11 +63523,20 @@ def __call__(self): return "WAXPBUSD" -WAXPBUSD = WAXPBUSD() +WAXPUSDT = WAXPUSDT() @dataclass(slots=True, frozen=True) class WAXPUSDT: + """ + name: WAXPUSDT + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 92141578.00000000 + margin: True + """ name: str = "WAXPUSDT" precision: int = 8 minimum_margin: float = None @@ -45676,11 +63555,20 @@ def __call__(self): return "WAXPUSDT" -WAXPUSDT = WAXPUSDT() +WBTCBTC = WBTCBTC() @dataclass(slots=True, frozen=True) class WBTCBTC: + """ + name: WBTCBTC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.00001000 + maximum_order_size: 92141578.00000000 + margin: False + """ name: str = "WBTCBTC" precision: int = 8 minimum_margin: float = None @@ -45699,11 +63587,20 @@ def __call__(self): return "WBTCBTC" -WBTCBTC = WBTCBTC() +WBTCBUSD = WBTCBUSD() @dataclass(slots=True, frozen=True) class WBTCBUSD: + """ + name: WBTCBUSD + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.00001000 + maximum_order_size: 9000.00000000 + margin: False + """ name: str = "WBTCBUSD" precision: int = 8 minimum_margin: float = None @@ -45722,11 +63619,20 @@ def __call__(self): return "WBTCBUSD" -WBTCBUSD = WBTCBUSD() +WBTCETH = WBTCETH() @dataclass(slots=True, frozen=True) class WBTCETH: + """ + name: WBTCETH + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.00001000 + maximum_order_size: 100000.00000000 + margin: False + """ name: str = "WBTCETH" precision: int = 8 minimum_margin: float = None @@ -45745,11 +63651,20 @@ def __call__(self): return "WBTCETH" -WBTCETH = WBTCETH() +WINBNB = WINBNB() @dataclass(slots=True, frozen=True) class WINBNB: + """ + name: WINBNB + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 913205152.00000000 + margin: False + """ name: str = "WINBNB" precision: int = 8 minimum_margin: float = None @@ -45768,11 +63683,20 @@ def __call__(self): return "WINBNB" -WINBNB = WINBNB() +WINBRL = WINBRL() @dataclass(slots=True, frozen=True) class WINBRL: + """ + name: WINBRL + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 913205152.00000000 + margin: False + """ name: str = "WINBRL" precision: int = 8 minimum_margin: float = None @@ -45791,11 +63715,20 @@ def __call__(self): return "WINBRL" -WINBRL = WINBRL() +WINBTC = WINBTC() @dataclass(slots=True, frozen=True) class WINBTC: + """ + name: WINBTC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 90000000.00000000 + margin: False + """ name: str = "WINBTC" precision: int = 8 minimum_margin: float = None @@ -45814,11 +63747,20 @@ def __call__(self): return "WINBTC" -WINBTC = WINBTC() +WINBUSD = WINBUSD() @dataclass(slots=True, frozen=True) class WINBUSD: + """ + name: WINBUSD + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 913205152.00000000 + margin: False + """ name: str = "WINBUSD" precision: int = 8 minimum_margin: float = None @@ -45837,11 +63779,20 @@ def __call__(self): return "WINBUSD" -WINBUSD = WINBUSD() +WINEUR = WINEUR() @dataclass(slots=True, frozen=True) class WINEUR: + """ + name: WINEUR + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 913205152.00000000 + margin: False + """ name: str = "WINEUR" precision: int = 8 minimum_margin: float = None @@ -45860,11 +63811,20 @@ def __call__(self): return "WINEUR" -WINEUR = WINEUR() +WINGBNB = WINGBNB() @dataclass(slots=True, frozen=True) class WINGBNB: + """ + name: WINGBNB + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 900000.00000000 + margin: False + """ name: str = "WINGBNB" precision: int = 8 minimum_margin: float = None @@ -45883,11 +63843,20 @@ def __call__(self): return "WINGBNB" -WINGBNB = WINGBNB() +WINGBTC = WINGBTC() @dataclass(slots=True, frozen=True) class WINGBTC: + """ + name: WINGBTC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 10000000.00000000 + margin: False + """ name: str = "WINGBTC" precision: int = 8 minimum_margin: float = None @@ -45906,11 +63875,20 @@ def __call__(self): return "WINGBTC" -WINGBTC = WINGBTC() +WINGBUSD = WINGBUSD() @dataclass(slots=True, frozen=True) class WINGBUSD: + """ + name: WINGBUSD + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 90000.00000000 + margin: True + """ name: str = "WINGBUSD" precision: int = 8 minimum_margin: float = None @@ -45929,11 +63907,20 @@ def __call__(self): return "WINGBUSD" -WINGBUSD = WINGBUSD() +WINGETH = WINGETH() @dataclass(slots=True, frozen=True) class WINGETH: + """ + name: WINGETH + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.00100000 + maximum_order_size: 913205152.00000000 + margin: False + """ name: str = "WINGETH" precision: int = 8 minimum_margin: float = None @@ -45952,11 +63939,20 @@ def __call__(self): return "WINGETH" -WINGETH = WINGETH() +WINGSBTC = WINGSBTC() @dataclass(slots=True, frozen=True) class WINGSBTC: + """ + name: WINGSBTC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 90000000.00000000 + margin: False + """ name: str = "WINGSBTC" precision: int = 8 minimum_margin: float = None @@ -45975,11 +63971,20 @@ def __call__(self): return "WINGSBTC" -WINGSBTC = WINGSBTC() +WINGSETH = WINGSETH() @dataclass(slots=True, frozen=True) class WINGSETH: + """ + name: WINGSETH + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 90000000.00000000 + margin: False + """ name: str = "WINGSETH" precision: int = 8 minimum_margin: float = None @@ -45998,11 +64003,20 @@ def __call__(self): return "WINGSETH" -WINGSETH = WINGSETH() +WINGUSDT = WINGUSDT() @dataclass(slots=True, frozen=True) class WINGUSDT: + """ + name: WINGUSDT + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 90000.00000000 + margin: True + """ name: str = "WINGUSDT" precision: int = 8 minimum_margin: float = None @@ -46021,11 +64035,20 @@ def __call__(self): return "WINGUSDT" -WINGUSDT = WINGUSDT() +WINTRX = WINTRX() @dataclass(slots=True, frozen=True) class WINTRX: + """ + name: WINTRX + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 913205152.00000000 + margin: False + """ name: str = "WINTRX" precision: int = 8 minimum_margin: float = None @@ -46044,11 +64067,20 @@ def __call__(self): return "WINTRX" -WINTRX = WINTRX() +WINUSDC = WINUSDC() @dataclass(slots=True, frozen=True) class WINUSDC: + """ + name: WINUSDC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 913205152.00000000 + margin: False + """ name: str = "WINUSDC" precision: int = 8 minimum_margin: float = None @@ -46067,11 +64099,20 @@ def __call__(self): return "WINUSDC" -WINUSDC = WINUSDC() +WINUSDT = WINUSDT() @dataclass(slots=True, frozen=True) class WINUSDT: + """ + name: WINUSDT + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 913205152.00000000 + margin: False + """ name: str = "WINUSDT" precision: int = 8 minimum_margin: float = None @@ -46090,11 +64131,20 @@ def __call__(self): return "WINUSDT" -WINUSDT = WINUSDT() +WNXMBNB = WNXMBNB() @dataclass(slots=True, frozen=True) class WNXMBNB: + """ + name: WNXMBNB + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 9000000.00000000 + margin: False + """ name: str = "WNXMBNB" precision: int = 8 minimum_margin: float = None @@ -46113,11 +64163,20 @@ def __call__(self): return "WNXMBNB" -WNXMBNB = WNXMBNB() +WNXMBTC = WNXMBTC() @dataclass(slots=True, frozen=True) class WNXMBTC: + """ + name: WNXMBTC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 10000000.00000000 + margin: False + """ name: str = "WNXMBTC" precision: int = 8 minimum_margin: float = None @@ -46136,11 +64195,20 @@ def __call__(self): return "WNXMBTC" -WNXMBTC = WNXMBTC() +WNXMBUSD = WNXMBUSD() @dataclass(slots=True, frozen=True) class WNXMBUSD: + """ + name: WNXMBUSD + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.00100000 + maximum_order_size: 90000.00000000 + margin: False + """ name: str = "WNXMBUSD" precision: int = 8 minimum_margin: float = None @@ -46159,11 +64227,20 @@ def __call__(self): return "WNXMBUSD" -WNXMBUSD = WNXMBUSD() +WNXMUSDT = WNXMUSDT() @dataclass(slots=True, frozen=True) class WNXMUSDT: + """ + name: WNXMUSDT + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 90000.00000000 + margin: False + """ name: str = "WNXMUSDT" precision: int = 8 minimum_margin: float = None @@ -46182,11 +64259,20 @@ def __call__(self): return "WNXMUSDT" -WNXMUSDT = WNXMUSDT() +WOOBNB = WOOBNB() @dataclass(slots=True, frozen=True) class WOOBNB: + """ + name: WOOBNB + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 92141578.00000000 + margin: False + """ name: str = "WOOBNB" precision: int = 8 minimum_margin: float = None @@ -46205,11 +64291,20 @@ def __call__(self): return "WOOBNB" -WOOBNB = WOOBNB() +WOOBTC = WOOBTC() @dataclass(slots=True, frozen=True) class WOOBTC: + """ + name: WOOBTC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 92141578.00000000 + margin: False + """ name: str = "WOOBTC" precision: int = 8 minimum_margin: float = None @@ -46228,11 +64323,20 @@ def __call__(self): return "WOOBTC" -WOOBTC = WOOBTC() +WOOBUSD = WOOBUSD() @dataclass(slots=True, frozen=True) class WOOBUSD: + """ + name: WOOBUSD + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 92141578.00000000 + margin: False + """ name: str = "WOOBUSD" precision: int = 8 minimum_margin: float = None @@ -46251,11 +64355,20 @@ def __call__(self): return "WOOBUSD" -WOOBUSD = WOOBUSD() +WOOUSDT = WOOUSDT() @dataclass(slots=True, frozen=True) class WOOUSDT: + """ + name: WOOUSDT + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 92141578.00000000 + margin: True + """ name: str = "WOOUSDT" precision: int = 8 minimum_margin: float = None @@ -46274,11 +64387,20 @@ def __call__(self): return "WOOUSDT" -WOOUSDT = WOOUSDT() +WPRBTC = WPRBTC() @dataclass(slots=True, frozen=True) class WPRBTC: + """ + name: WPRBTC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 90000000.00000000 + margin: False + """ name: str = "WPRBTC" precision: int = 8 minimum_margin: float = None @@ -46297,11 +64419,20 @@ def __call__(self): return "WPRBTC" -WPRBTC = WPRBTC() +WPRETH = WPRETH() @dataclass(slots=True, frozen=True) class WPRETH: + """ + name: WPRETH + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 90000000.00000000 + margin: False + """ name: str = "WPRETH" precision: int = 8 minimum_margin: float = None @@ -46320,11 +64451,20 @@ def __call__(self): return "WPRETH" -WPRETH = WPRETH() +WRXBNB = WRXBNB() @dataclass(slots=True, frozen=True) class WRXBNB: + """ + name: WRXBNB + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 9000000.00000000 + margin: False + """ name: str = "WRXBNB" precision: int = 8 minimum_margin: float = None @@ -46343,11 +64483,20 @@ def __call__(self): return "WRXBNB" -WRXBNB = WRXBNB() +WRXBTC = WRXBTC() @dataclass(slots=True, frozen=True) class WRXBTC: + """ + name: WRXBTC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 90000000.00000000 + margin: False + """ name: str = "WRXBTC" precision: int = 8 minimum_margin: float = None @@ -46366,11 +64515,20 @@ def __call__(self): return "WRXBTC" -WRXBTC = WRXBTC() +WRXBUSD = WRXBUSD() @dataclass(slots=True, frozen=True) class WRXBUSD: + """ + name: WRXBUSD + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 900000.00000000 + margin: False + """ name: str = "WRXBUSD" precision: int = 8 minimum_margin: float = None @@ -46389,11 +64547,20 @@ def __call__(self): return "WRXBUSD" -WRXBUSD = WRXBUSD() +WRXEUR = WRXEUR() @dataclass(slots=True, frozen=True) class WRXEUR: + """ + name: WRXEUR + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 9222449.00000000 + margin: False + """ name: str = "WRXEUR" precision: int = 8 minimum_margin: float = None @@ -46412,11 +64579,20 @@ def __call__(self): return "WRXEUR" -WRXEUR = WRXEUR() +WRXUSDT = WRXUSDT() @dataclass(slots=True, frozen=True) class WRXUSDT: + """ + name: WRXUSDT + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 900000.00000000 + margin: False + """ name: str = "WRXUSDT" precision: int = 8 minimum_margin: float = None @@ -46435,11 +64611,20 @@ def __call__(self): return "WRXUSDT" -WRXUSDT = WRXUSDT() +WTCBNB = WTCBNB() @dataclass(slots=True, frozen=True) class WTCBNB: + """ + name: WTCBNB + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 900000.00000000 + margin: False + """ name: str = "WTCBNB" precision: int = 8 minimum_margin: float = None @@ -46458,11 +64643,20 @@ def __call__(self): return "WTCBNB" -WTCBNB = WTCBNB() +WTCBTC = WTCBTC() @dataclass(slots=True, frozen=True) class WTCBTC: + """ + name: WTCBTC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 9000000.00000000 + margin: False + """ name: str = "WTCBTC" precision: int = 8 minimum_margin: float = None @@ -46481,11 +64675,20 @@ def __call__(self): return "WTCBTC" -WTCBTC = WTCBTC() +WTCETH = WTCETH() @dataclass(slots=True, frozen=True) class WTCETH: + """ + name: WTCETH + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 90000000.00000000 + margin: False + """ name: str = "WTCETH" precision: int = 8 minimum_margin: float = None @@ -46504,11 +64707,20 @@ def __call__(self): return "WTCETH" -WTCETH = WTCETH() +WTCUSDT = WTCUSDT() @dataclass(slots=True, frozen=True) class WTCUSDT: + """ + name: WTCUSDT + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 900000.00000000 + margin: False + """ name: str = "WTCUSDT" precision: int = 8 minimum_margin: float = None @@ -46527,11 +64739,20 @@ def __call__(self): return "WTCUSDT" -WTCUSDT = WTCUSDT() +XECBUSD = XECBUSD() @dataclass(slots=True, frozen=True) class XECBUSD: + """ + name: XECBUSD + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00 + maximum_order_size: 46116860414.00 + margin: True + """ name: str = "XECBUSD" precision: int = 8 minimum_margin: float = None @@ -46550,11 +64771,20 @@ def __call__(self): return "XECBUSD" -XECBUSD = XECBUSD() +XECUSDT = XECUSDT() @dataclass(slots=True, frozen=True) class XECUSDT: + """ + name: XECUSDT + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00 + maximum_order_size: 46116860414.00 + margin: True + """ name: str = "XECUSDT" precision: int = 8 minimum_margin: float = None @@ -46573,11 +64803,20 @@ def __call__(self): return "XECUSDT" -XECUSDT = XECUSDT() +XEMBNB = XEMBNB() @dataclass(slots=True, frozen=True) class XEMBNB: + """ + name: XEMBNB + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 9000000.00000000 + margin: False + """ name: str = "XEMBNB" precision: int = 8 minimum_margin: float = None @@ -46596,11 +64835,20 @@ def __call__(self): return "XEMBNB" -XEMBNB = XEMBNB() +XEMBTC = XEMBTC() @dataclass(slots=True, frozen=True) class XEMBTC: + """ + name: XEMBTC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 90000000.00000000 + margin: False + """ name: str = "XEMBTC" precision: int = 8 minimum_margin: float = None @@ -46619,11 +64867,20 @@ def __call__(self): return "XEMBTC" -XEMBTC = XEMBTC() +XEMBUSD = XEMBUSD() @dataclass(slots=True, frozen=True) class XEMBUSD: + """ + name: XEMBUSD + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 9222449.00000000 + margin: False + """ name: str = "XEMBUSD" precision: int = 8 minimum_margin: float = None @@ -46642,11 +64899,20 @@ def __call__(self): return "XEMBUSD" -XEMBUSD = XEMBUSD() +XEMETH = XEMETH() @dataclass(slots=True, frozen=True) class XEMETH: + """ + name: XEMETH + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 90000000.00000000 + margin: False + """ name: str = "XEMETH" precision: int = 8 minimum_margin: float = None @@ -46665,11 +64931,20 @@ def __call__(self): return "XEMETH" -XEMETH = XEMETH() +XEMUSDT = XEMUSDT() @dataclass(slots=True, frozen=True) class XEMUSDT: + """ + name: XEMUSDT + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 9222449.00000000 + margin: False + """ name: str = "XEMUSDT" precision: int = 8 minimum_margin: float = None @@ -46688,11 +64963,20 @@ def __call__(self): return "XEMUSDT" -XEMUSDT = XEMUSDT() +XLMBNB = XLMBNB() @dataclass(slots=True, frozen=True) class XLMBNB: + """ + name: XLMBNB + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 9000000.00000000 + margin: False + """ name: str = "XLMBNB" precision: int = 8 minimum_margin: float = None @@ -46711,11 +64995,20 @@ def __call__(self): return "XLMBNB" -XLMBNB = XLMBNB() +XLMBTC = XLMBTC() @dataclass(slots=True, frozen=True) class XLMBTC: + """ + name: XLMBTC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 90000000.00000000 + margin: True + """ name: str = "XLMBTC" precision: int = 8 minimum_margin: float = None @@ -46734,11 +65027,20 @@ def __call__(self): return "XLMBTC" -XLMBTC = XLMBTC() +XLMBUSD = XLMBUSD() @dataclass(slots=True, frozen=True) class XLMBUSD: + """ + name: XLMBUSD + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 9000000.00000000 + margin: True + """ name: str = "XLMBUSD" precision: int = 8 minimum_margin: float = None @@ -46757,11 +65059,20 @@ def __call__(self): return "XLMBUSD" -XLMBUSD = XLMBUSD() +XLMDOWNUSDT = XLMDOWNUSDT() @dataclass(slots=True, frozen=True) class XLMDOWNUSDT: + """ + name: XLMDOWNUSDT + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 399280174.00000000 + margin: False + """ name: str = "XLMDOWNUSDT" precision: int = 8 minimum_margin: float = None @@ -46780,11 +65091,20 @@ def __call__(self): return "XLMDOWNUSDT" -XLMDOWNUSDT = XLMDOWNUSDT() +XLMETH = XLMETH() @dataclass(slots=True, frozen=True) class XLMETH: + """ + name: XLMETH + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 90000000.00000000 + margin: False + """ name: str = "XLMETH" precision: int = 8 minimum_margin: float = None @@ -46803,11 +65123,20 @@ def __call__(self): return "XLMETH" -XLMETH = XLMETH() +XLMEUR = XLMEUR() @dataclass(slots=True, frozen=True) class XLMEUR: + """ + name: XLMEUR + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 9000000.00000000 + margin: False + """ name: str = "XLMEUR" precision: int = 8 minimum_margin: float = None @@ -46826,11 +65155,20 @@ def __call__(self): return "XLMEUR" -XLMEUR = XLMEUR() +XLMPAX = XLMPAX() @dataclass(slots=True, frozen=True) class XLMPAX: + """ + name: XLMPAX + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 9000000.00000000 + margin: False + """ name: str = "XLMPAX" precision: int = 8 minimum_margin: float = None @@ -46849,11 +65187,20 @@ def __call__(self): return "XLMPAX" -XLMPAX = XLMPAX() +XLMTRY = XLMTRY() @dataclass(slots=True, frozen=True) class XLMTRY: + """ + name: XLMTRY + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 9222449.00000000 + margin: False + """ name: str = "XLMTRY" precision: int = 8 minimum_margin: float = None @@ -46872,11 +65219,20 @@ def __call__(self): return "XLMTRY" -XLMTRY = XLMTRY() +XLMTUSD = XLMTUSD() @dataclass(slots=True, frozen=True) class XLMTUSD: + """ + name: XLMTUSD + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 9000000.00000000 + margin: False + """ name: str = "XLMTUSD" precision: int = 8 minimum_margin: float = None @@ -46895,11 +65251,20 @@ def __call__(self): return "XLMTUSD" -XLMTUSD = XLMTUSD() +XLMUPUSDT = XLMUPUSDT() @dataclass(slots=True, frozen=True) class XLMUPUSDT: + """ + name: XLMUPUSDT + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 920000.00000000 + margin: False + """ name: str = "XLMUPUSDT" precision: int = 8 minimum_margin: float = None @@ -46918,11 +65283,20 @@ def __call__(self): return "XLMUPUSDT" -XLMUPUSDT = XLMUPUSDT() +XLMUSDC = XLMUSDC() @dataclass(slots=True, frozen=True) class XLMUSDC: + """ + name: XLMUSDC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 9000000.00000000 + margin: False + """ name: str = "XLMUSDC" precision: int = 8 minimum_margin: float = None @@ -46941,11 +65315,20 @@ def __call__(self): return "XLMUSDC" -XLMUSDC = XLMUSDC() +XLMUSDT = XLMUSDT() @dataclass(slots=True, frozen=True) class XLMUSDT: + """ + name: XLMUSDT + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 9000000.00000000 + margin: True + """ name: str = "XLMUSDT" precision: int = 8 minimum_margin: float = None @@ -46964,11 +65347,20 @@ def __call__(self): return "XLMUSDT" -XLMUSDT = XLMUSDT() +XMRBNB = XMRBNB() @dataclass(slots=True, frozen=True) class XMRBNB: + """ + name: XMRBNB + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.00100000 + maximum_order_size: 900000.00000000 + margin: False + """ name: str = "XMRBNB" precision: int = 8 minimum_margin: float = None @@ -46987,11 +65379,20 @@ def __call__(self): return "XMRBNB" -XMRBNB = XMRBNB() +XMRBTC = XMRBTC() @dataclass(slots=True, frozen=True) class XMRBTC: + """ + name: XMRBTC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.00100000 + maximum_order_size: 10000000.00000000 + margin: True + """ name: str = "XMRBTC" precision: int = 8 minimum_margin: float = None @@ -47010,11 +65411,20 @@ def __call__(self): return "XMRBTC" -XMRBTC = XMRBTC() +XMRBUSD = XMRBUSD() @dataclass(slots=True, frozen=True) class XMRBUSD: + """ + name: XMRBUSD + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.00100000 + maximum_order_size: 90000.00000000 + margin: True + """ name: str = "XMRBUSD" precision: int = 8 minimum_margin: float = None @@ -47033,11 +65443,20 @@ def __call__(self): return "XMRBUSD" -XMRBUSD = XMRBUSD() +XMRETH = XMRETH() @dataclass(slots=True, frozen=True) class XMRETH: + """ + name: XMRETH + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.00100000 + maximum_order_size: 9000000.00000000 + margin: True + """ name: str = "XMRETH" precision: int = 8 minimum_margin: float = None @@ -47056,11 +65475,20 @@ def __call__(self): return "XMRETH" -XMRETH = XMRETH() +XMRUSDT = XMRUSDT() @dataclass(slots=True, frozen=True) class XMRUSDT: + """ + name: XMRUSDT + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.00100000 + maximum_order_size: 90000.00000000 + margin: True + """ name: str = "XMRUSDT" precision: int = 8 minimum_margin: float = None @@ -47079,11 +65507,20 @@ def __call__(self): return "XMRUSDT" -XMRUSDT = XMRUSDT() +XNOBTC = XNOBTC() @dataclass(slots=True, frozen=True) class XNOBTC: + """ + name: XNOBTC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 92141578.00000000 + margin: False + """ name: str = "XNOBTC" precision: int = 8 minimum_margin: float = None @@ -47102,11 +65539,20 @@ def __call__(self): return "XNOBTC" -XNOBTC = XNOBTC() +XNOBUSD = XNOBUSD() @dataclass(slots=True, frozen=True) class XNOBUSD: + """ + name: XNOBUSD + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 92141578.00000000 + margin: False + """ name: str = "XNOBUSD" precision: int = 8 minimum_margin: float = None @@ -47125,11 +65571,20 @@ def __call__(self): return "XNOBUSD" -XNOBUSD = XNOBUSD() +XNOETH = XNOETH() @dataclass(slots=True, frozen=True) class XNOETH: + """ + name: XNOETH + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 92141578.00000000 + margin: False + """ name: str = "XNOETH" precision: int = 8 minimum_margin: float = None @@ -47148,11 +65603,20 @@ def __call__(self): return "XNOETH" -XNOETH = XNOETH() +XNOUSDT = XNOUSDT() @dataclass(slots=True, frozen=True) class XNOUSDT: + """ + name: XNOUSDT + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 92141578.00000000 + margin: False + """ name: str = "XNOUSDT" precision: int = 8 minimum_margin: float = None @@ -47171,11 +65635,20 @@ def __call__(self): return "XNOUSDT" -XNOUSDT = XNOUSDT() +XRPAUD = XRPAUD() @dataclass(slots=True, frozen=True) class XRPAUD: + """ + name: XRPAUD + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 900000.00000000 + margin: False + """ name: str = "XRPAUD" precision: int = 8 minimum_margin: float = None @@ -47194,11 +65667,20 @@ def __call__(self): return "XRPAUD" -XRPAUD = XRPAUD() +XRPBEARBUSD = XRPBEARBUSD() @dataclass(slots=True, frozen=True) class XRPBEARBUSD: + """ + name: XRPBEARBUSD + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.00001000 + maximum_order_size: 90000.00000000 + margin: False + """ name: str = "XRPBEARBUSD" precision: int = 8 minimum_margin: float = None @@ -47217,11 +65699,20 @@ def __call__(self): return "XRPBEARBUSD" -XRPBEARBUSD = XRPBEARBUSD() +XRPBEARUSDT = XRPBEARUSDT() @dataclass(slots=True, frozen=True) class XRPBEARUSDT: + """ + name: XRPBEARUSDT + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.00001000 + maximum_order_size: 90000.00000000 + margin: False + """ name: str = "XRPBEARUSDT" precision: int = 8 minimum_margin: float = None @@ -47240,11 +65731,20 @@ def __call__(self): return "XRPBEARUSDT" -XRPBEARUSDT = XRPBEARUSDT() +XRPBIDR = XRPBIDR() @dataclass(slots=True, frozen=True) class XRPBIDR: + """ + name: XRPBIDR + precision: 2 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 92233.00000000 + margin: False + """ name: str = "XRPBIDR" precision: int = 2 minimum_margin: float = None @@ -47263,11 +65763,20 @@ def __call__(self): return "XRPBIDR" -XRPBIDR = XRPBIDR() +XRPBKRW = XRPBKRW() @dataclass(slots=True, frozen=True) class XRPBKRW: + """ + name: XRPBKRW + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 922327.00000000 + margin: False + """ name: str = "XRPBKRW" precision: int = 8 minimum_margin: float = None @@ -47286,11 +65795,20 @@ def __call__(self): return "XRPBKRW" -XRPBKRW = XRPBKRW() +XRPBNB = XRPBNB() @dataclass(slots=True, frozen=True) class XRPBNB: + """ + name: XRPBNB + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 9000000.00000000 + margin: False + """ name: str = "XRPBNB" precision: int = 8 minimum_margin: float = None @@ -47309,11 +65827,20 @@ def __call__(self): return "XRPBNB" -XRPBNB = XRPBNB() +XRPBRL = XRPBRL() @dataclass(slots=True, frozen=True) class XRPBRL: + """ + name: XRPBRL + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 922327.00000000 + margin: False + """ name: str = "XRPBRL" precision: int = 8 minimum_margin: float = None @@ -47332,11 +65859,20 @@ def __call__(self): return "XRPBRL" -XRPBRL = XRPBRL() +XRPBTC = XRPBTC() @dataclass(slots=True, frozen=True) class XRPBTC: + """ + name: XRPBTC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 90000000.00000000 + margin: True + """ name: str = "XRPBTC" precision: int = 8 minimum_margin: float = None @@ -47355,11 +65891,20 @@ def __call__(self): return "XRPBTC" -XRPBTC = XRPBTC() +XRPBULLBUSD = XRPBULLBUSD() @dataclass(slots=True, frozen=True) class XRPBULLBUSD: + """ + name: XRPBULLBUSD + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.00001000 + maximum_order_size: 90000.00000000 + margin: False + """ name: str = "XRPBULLBUSD" precision: int = 8 minimum_margin: float = None @@ -47378,11 +65923,20 @@ def __call__(self): return "XRPBULLBUSD" -XRPBULLBUSD = XRPBULLBUSD() +XRPBULLUSDT = XRPBULLUSDT() @dataclass(slots=True, frozen=True) class XRPBULLUSDT: + """ + name: XRPBULLUSDT + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.00001000 + maximum_order_size: 90000.00000000 + margin: False + """ name: str = "XRPBULLUSDT" precision: int = 8 minimum_margin: float = None @@ -47401,11 +65955,20 @@ def __call__(self): return "XRPBULLUSDT" -XRPBULLUSDT = XRPBULLUSDT() +XRPBUSD = XRPBUSD() @dataclass(slots=True, frozen=True) class XRPBUSD: + """ + name: XRPBUSD + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 900000.00000000 + margin: True + """ name: str = "XRPBUSD" precision: int = 8 minimum_margin: float = None @@ -47424,11 +65987,20 @@ def __call__(self): return "XRPBUSD" -XRPBUSD = XRPBUSD() +XRPDOWNUSDT = XRPDOWNUSDT() @dataclass(slots=True, frozen=True) class XRPDOWNUSDT: + """ + name: XRPDOWNUSDT + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 99999999.00000000 + margin: False + """ name: str = "XRPDOWNUSDT" precision: int = 8 minimum_margin: float = None @@ -47447,11 +66019,20 @@ def __call__(self): return "XRPDOWNUSDT" -XRPDOWNUSDT = XRPDOWNUSDT() +XRPETH = XRPETH() @dataclass(slots=True, frozen=True) class XRPETH: + """ + name: XRPETH + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 90000000.00000000 + margin: True + """ name: str = "XRPETH" precision: int = 8 minimum_margin: float = None @@ -47470,11 +66051,20 @@ def __call__(self): return "XRPETH" -XRPETH = XRPETH() +XRPEUR = XRPEUR() @dataclass(slots=True, frozen=True) class XRPEUR: + """ + name: XRPEUR + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 900000.00000000 + margin: False + """ name: str = "XRPEUR" precision: int = 8 minimum_margin: float = None @@ -47493,11 +66083,20 @@ def __call__(self): return "XRPEUR" -XRPEUR = XRPEUR() +XRPGBP = XRPGBP() @dataclass(slots=True, frozen=True) class XRPGBP: + """ + name: XRPGBP + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 9000000.00000000 + margin: False + """ name: str = "XRPGBP" precision: int = 8 minimum_margin: float = None @@ -47516,11 +66115,20 @@ def __call__(self): return "XRPGBP" -XRPGBP = XRPGBP() +XRPNGN = XRPNGN() @dataclass(slots=True, frozen=True) class XRPNGN: + """ + name: XRPNGN + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 922320.00000000 + margin: False + """ name: str = "XRPNGN" precision: int = 8 minimum_margin: float = None @@ -47539,11 +66147,20 @@ def __call__(self): return "XRPNGN" -XRPNGN = XRPNGN() +XRPPAX = XRPPAX() @dataclass(slots=True, frozen=True) class XRPPAX: + """ + name: XRPPAX + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 900000.00000000 + margin: False + """ name: str = "XRPPAX" precision: int = 8 minimum_margin: float = None @@ -47562,11 +66179,20 @@ def __call__(self): return "XRPPAX" -XRPPAX = XRPPAX() +XRPRUB = XRPRUB() @dataclass(slots=True, frozen=True) class XRPRUB: + """ + name: XRPRUB + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 9222449.00000000 + margin: False + """ name: str = "XRPRUB" precision: int = 8 minimum_margin: float = None @@ -47585,11 +66211,20 @@ def __call__(self): return "XRPRUB" -XRPRUB = XRPRUB() +XRPTRY = XRPTRY() @dataclass(slots=True, frozen=True) class XRPTRY: + """ + name: XRPTRY + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 92141578.00000000 + margin: False + """ name: str = "XRPTRY" precision: int = 8 minimum_margin: float = None @@ -47608,11 +66243,20 @@ def __call__(self): return "XRPTRY" -XRPTRY = XRPTRY() +XRPTUSD = XRPTUSD() @dataclass(slots=True, frozen=True) class XRPTUSD: + """ + name: XRPTUSD + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 900000.00000000 + margin: False + """ name: str = "XRPTUSD" precision: int = 8 minimum_margin: float = None @@ -47631,11 +66275,20 @@ def __call__(self): return "XRPTUSD" -XRPTUSD = XRPTUSD() +XRPUPUSDT = XRPUPUSDT() @dataclass(slots=True, frozen=True) class XRPUPUSDT: + """ + name: XRPUPUSDT + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 920000.00000000 + margin: False + """ name: str = "XRPUPUSDT" precision: int = 8 minimum_margin: float = None @@ -47654,11 +66307,20 @@ def __call__(self): return "XRPUPUSDT" -XRPUPUSDT = XRPUPUSDT() +XRPUSDC = XRPUSDC() @dataclass(slots=True, frozen=True) class XRPUSDC: + """ + name: XRPUSDC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 900000.00000000 + margin: False + """ name: str = "XRPUSDC" precision: int = 8 minimum_margin: float = None @@ -47677,11 +66339,20 @@ def __call__(self): return "XRPUSDC" -XRPUSDC = XRPUSDC() +XRPUSDT = XRPUSDT() @dataclass(slots=True, frozen=True) class XRPUSDT: + """ + name: XRPUSDT + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 9222449.00000000 + margin: True + """ name: str = "XRPUSDT" precision: int = 8 minimum_margin: float = None @@ -47700,11 +66371,20 @@ def __call__(self): return "XRPUSDT" -XRPUSDT = XRPUSDT() +XTZBNB = XTZBNB() @dataclass(slots=True, frozen=True) class XTZBNB: + """ + name: XTZBNB + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 9000000.00000000 + margin: False + """ name: str = "XTZBNB" precision: int = 8 minimum_margin: float = None @@ -47723,11 +66403,20 @@ def __call__(self): return "XTZBNB" -XTZBNB = XTZBNB() +XTZBTC = XTZBTC() @dataclass(slots=True, frozen=True) class XTZBTC: + """ + name: XTZBTC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 90000000.00000000 + margin: True + """ name: str = "XTZBTC" precision: int = 8 minimum_margin: float = None @@ -47746,11 +66435,20 @@ def __call__(self): return "XTZBTC" -XTZBTC = XTZBTC() +XTZBUSD = XTZBUSD() @dataclass(slots=True, frozen=True) class XTZBUSD: + """ + name: XTZBUSD + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 900000.00000000 + margin: True + """ name: str = "XTZBUSD" precision: int = 8 minimum_margin: float = None @@ -47769,11 +66467,20 @@ def __call__(self): return "XTZBUSD" -XTZBUSD = XTZBUSD() +XTZDOWNUSDT = XTZDOWNUSDT() @dataclass(slots=True, frozen=True) class XTZDOWNUSDT: + """ + name: XTZDOWNUSDT + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 49991176.00000000 + margin: False + """ name: str = "XTZDOWNUSDT" precision: int = 8 minimum_margin: float = None @@ -47792,11 +66499,20 @@ def __call__(self): return "XTZDOWNUSDT" -XTZDOWNUSDT = XTZDOWNUSDT() +XTZETH = XTZETH() @dataclass(slots=True, frozen=True) class XTZETH: + """ + name: XTZETH + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 92141578.00000000 + margin: False + """ name: str = "XTZETH" precision: int = 8 minimum_margin: float = None @@ -47815,11 +66531,20 @@ def __call__(self): return "XTZETH" -XTZETH = XTZETH() +XTZTRY = XTZTRY() @dataclass(slots=True, frozen=True) class XTZTRY: + """ + name: XTZTRY + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 9222449.00000000 + margin: False + """ name: str = "XTZTRY" precision: int = 8 minimum_margin: float = None @@ -47838,11 +66563,20 @@ def __call__(self): return "XTZTRY" -XTZTRY = XTZTRY() +XTZUPUSDT = XTZUPUSDT() @dataclass(slots=True, frozen=True) class XTZUPUSDT: + """ + name: XTZUPUSDT + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 920000.00000000 + margin: False + """ name: str = "XTZUPUSDT" precision: int = 8 minimum_margin: float = None @@ -47861,11 +66595,20 @@ def __call__(self): return "XTZUPUSDT" -XTZUPUSDT = XTZUPUSDT() +XTZUSDT = XTZUSDT() @dataclass(slots=True, frozen=True) class XTZUSDT: + """ + name: XTZUSDT + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 900000.00000000 + margin: True + """ name: str = "XTZUSDT" precision: int = 8 minimum_margin: float = None @@ -47884,11 +66627,20 @@ def __call__(self): return "XTZUSDT" -XTZUSDT = XTZUSDT() +XVGBTC = XVGBTC() @dataclass(slots=True, frozen=True) class XVGBTC: + """ + name: XVGBTC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 90000000.00000000 + margin: False + """ name: str = "XVGBTC" precision: int = 8 minimum_margin: float = None @@ -47907,11 +66659,20 @@ def __call__(self): return "XVGBTC" -XVGBTC = XVGBTC() +XVGBUSD = XVGBUSD() @dataclass(slots=True, frozen=True) class XVGBUSD: + """ + name: XVGBUSD + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 9000000.00000000 + margin: False + """ name: str = "XVGBUSD" precision: int = 8 minimum_margin: float = None @@ -47930,11 +66691,20 @@ def __call__(self): return "XVGBUSD" -XVGBUSD = XVGBUSD() +XVGETH = XVGETH() @dataclass(slots=True, frozen=True) class XVGETH: + """ + name: XVGETH + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 90000000.00000000 + margin: False + """ name: str = "XVGETH" precision: int = 8 minimum_margin: float = None @@ -47953,11 +66723,20 @@ def __call__(self): return "XVGETH" -XVGETH = XVGETH() +XVGUSDT = XVGUSDT() @dataclass(slots=True, frozen=True) class XVGUSDT: + """ + name: XVGUSDT + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 9222449.00000000 + margin: False + """ name: str = "XVGUSDT" precision: int = 8 minimum_margin: float = None @@ -47976,11 +66755,20 @@ def __call__(self): return "XVGUSDT" -XVGUSDT = XVGUSDT() +XVSBNB = XVSBNB() @dataclass(slots=True, frozen=True) class XVSBNB: + """ + name: XVSBNB + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 900000.00000000 + margin: False + """ name: str = "XVSBNB" precision: int = 8 minimum_margin: float = None @@ -47999,11 +66787,20 @@ def __call__(self): return "XVSBNB" -XVSBNB = XVSBNB() +XVSBTC = XVSBTC() @dataclass(slots=True, frozen=True) class XVSBTC: + """ + name: XVSBTC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 90000000.00000000 + margin: True + """ name: str = "XVSBTC" precision: int = 8 minimum_margin: float = None @@ -48022,11 +66819,20 @@ def __call__(self): return "XVSBTC" -XVSBTC = XVSBTC() +XVSBUSD = XVSBUSD() @dataclass(slots=True, frozen=True) class XVSBUSD: + """ + name: XVSBUSD + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 900000.00000000 + margin: True + """ name: str = "XVSBUSD" precision: int = 8 minimum_margin: float = None @@ -48045,11 +66851,20 @@ def __call__(self): return "XVSBUSD" -XVSBUSD = XVSBUSD() +XVSUSDT = XVSUSDT() @dataclass(slots=True, frozen=True) class XVSUSDT: + """ + name: XVSUSDT + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 900000.00000000 + margin: True + """ name: str = "XVSUSDT" precision: int = 8 minimum_margin: float = None @@ -48068,11 +66883,20 @@ def __call__(self): return "XVSUSDT" -XVSUSDT = XVSUSDT() +XZCBNB = XZCBNB() @dataclass(slots=True, frozen=True) class XZCBNB: + """ + name: XZCBNB + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 900000.00000000 + margin: False + """ name: str = "XZCBNB" precision: int = 8 minimum_margin: float = None @@ -48091,11 +66915,20 @@ def __call__(self): return "XZCBNB" -XZCBNB = XZCBNB() +XZCBTC = XZCBTC() @dataclass(slots=True, frozen=True) class XZCBTC: + """ + name: XZCBTC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 90000000.00000000 + margin: False + """ name: str = "XZCBTC" precision: int = 8 minimum_margin: float = None @@ -48114,11 +66947,20 @@ def __call__(self): return "XZCBTC" -XZCBTC = XZCBTC() +XZCETH = XZCETH() @dataclass(slots=True, frozen=True) class XZCETH: + """ + name: XZCETH + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 90000000.00000000 + margin: False + """ name: str = "XZCETH" precision: int = 8 minimum_margin: float = None @@ -48137,11 +66979,20 @@ def __call__(self): return "XZCETH" -XZCETH = XZCETH() +XZCUSDT = XZCUSDT() @dataclass(slots=True, frozen=True) class XZCUSDT: + """ + name: XZCUSDT + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.00100000 + maximum_order_size: 90000.00000000 + margin: False + """ name: str = "XZCUSDT" precision: int = 8 minimum_margin: float = None @@ -48160,11 +67011,20 @@ def __call__(self): return "XZCUSDT" -XZCUSDT = XZCUSDT() +XZCXRP = XZCXRP() @dataclass(slots=True, frozen=True) class XZCXRP: + """ + name: XZCXRP + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.00100000 + maximum_order_size: 90000.00000000 + margin: False + """ name: str = "XZCXRP" precision: int = 8 minimum_margin: float = None @@ -48183,11 +67043,20 @@ def __call__(self): return "XZCXRP" -XZCXRP = XZCXRP() +YFIBNB = YFIBNB() @dataclass(slots=True, frozen=True) class YFIBNB: + """ + name: YFIBNB + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.00001000 + maximum_order_size: 10000.00000000 + margin: False + """ name: str = "YFIBNB" precision: int = 8 minimum_margin: float = None @@ -48206,11 +67075,20 @@ def __call__(self): return "YFIBNB" -YFIBNB = YFIBNB() +YFIBTC = YFIBTC() @dataclass(slots=True, frozen=True) class YFIBTC: + """ + name: YFIBTC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.00001000 + maximum_order_size: 9000.00000000 + margin: False + """ name: str = "YFIBTC" precision: int = 8 minimum_margin: float = None @@ -48229,11 +67107,20 @@ def __call__(self): return "YFIBTC" -YFIBTC = YFIBTC() +YFIBUSD = YFIBUSD() @dataclass(slots=True, frozen=True) class YFIBUSD: + """ + name: YFIBUSD + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.00001000 + maximum_order_size: 9000.00000000 + margin: False + """ name: str = "YFIBUSD" precision: int = 8 minimum_margin: float = None @@ -48252,11 +67139,20 @@ def __call__(self): return "YFIBUSD" -YFIBUSD = YFIBUSD() +YFIDOWNUSDT = YFIDOWNUSDT() @dataclass(slots=True, frozen=True) class YFIDOWNUSDT: + """ + name: YFIDOWNUSDT + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 30000.00000000 + margin: False + """ name: str = "YFIDOWNUSDT" precision: int = 8 minimum_margin: float = None @@ -48275,11 +67171,20 @@ def __call__(self): return "YFIDOWNUSDT" -YFIDOWNUSDT = YFIDOWNUSDT() +YFIEUR = YFIEUR() @dataclass(slots=True, frozen=True) class YFIEUR: + """ + name: YFIEUR + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.00001000 + maximum_order_size: 9000.00000000 + margin: False + """ name: str = "YFIEUR" precision: int = 8 minimum_margin: float = None @@ -48298,11 +67203,20 @@ def __call__(self): return "YFIEUR" -YFIEUR = YFIEUR() +YFIIBNB = YFIIBNB() @dataclass(slots=True, frozen=True) class YFIIBNB: + """ + name: YFIIBNB + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.00010000 + maximum_order_size: 90000.00000000 + margin: False + """ name: str = "YFIIBNB" precision: int = 8 minimum_margin: float = None @@ -48321,11 +67235,20 @@ def __call__(self): return "YFIIBNB" -YFIIBNB = YFIIBNB() +YFIIBTC = YFIIBTC() @dataclass(slots=True, frozen=True) class YFIIBTC: + """ + name: YFIIBTC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.00010000 + maximum_order_size: 92141578.00000000 + margin: False + """ name: str = "YFIIBTC" precision: int = 8 minimum_margin: float = None @@ -48344,11 +67267,20 @@ def __call__(self): return "YFIIBTC" -YFIIBTC = YFIIBTC() +YFIIBUSD = YFIIBUSD() @dataclass(slots=True, frozen=True) class YFIIBUSD: + """ + name: YFIIBUSD + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.00010000 + maximum_order_size: 9000.00000000 + margin: False + """ name: str = "YFIIBUSD" precision: int = 8 minimum_margin: float = None @@ -48367,11 +67299,20 @@ def __call__(self): return "YFIIBUSD" -YFIIBUSD = YFIIBUSD() +YFIIUSDT = YFIIUSDT() @dataclass(slots=True, frozen=True) class YFIIUSDT: + """ + name: YFIIUSDT + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.00010000 + maximum_order_size: 9000.00000000 + margin: False + """ name: str = "YFIIUSDT" precision: int = 8 minimum_margin: float = None @@ -48390,11 +67331,20 @@ def __call__(self): return "YFIIUSDT" -YFIIUSDT = YFIIUSDT() +YFIUPUSDT = YFIUPUSDT() @dataclass(slots=True, frozen=True) class YFIUPUSDT: + """ + name: YFIUPUSDT + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 920000.00000000 + margin: False + """ name: str = "YFIUPUSDT" precision: int = 8 minimum_margin: float = None @@ -48413,11 +67363,20 @@ def __call__(self): return "YFIUPUSDT" -YFIUPUSDT = YFIUPUSDT() +YFIUSDT = YFIUSDT() @dataclass(slots=True, frozen=True) class YFIUSDT: + """ + name: YFIUSDT + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.00001000 + maximum_order_size: 9000.00000000 + margin: False + """ name: str = "YFIUSDT" precision: int = 8 minimum_margin: float = None @@ -48436,11 +67395,20 @@ def __call__(self): return "YFIUSDT" -YFIUSDT = YFIUSDT() +YGGBNB = YGGBNB() @dataclass(slots=True, frozen=True) class YGGBNB: + """ + name: YGGBNB + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 92141578.00000000 + margin: False + """ name: str = "YGGBNB" precision: int = 8 minimum_margin: float = None @@ -48459,11 +67427,20 @@ def __call__(self): return "YGGBNB" -YGGBNB = YGGBNB() +YGGBTC = YGGBTC() @dataclass(slots=True, frozen=True) class YGGBTC: + """ + name: YGGBTC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 92141578.00000000 + margin: False + """ name: str = "YGGBTC" precision: int = 8 minimum_margin: float = None @@ -48482,11 +67459,20 @@ def __call__(self): return "YGGBTC" -YGGBTC = YGGBTC() +YGGBUSD = YGGBUSD() @dataclass(slots=True, frozen=True) class YGGBUSD: + """ + name: YGGBUSD + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 92141578.00000000 + margin: True + """ name: str = "YGGBUSD" precision: int = 8 minimum_margin: float = None @@ -48505,11 +67491,20 @@ def __call__(self): return "YGGBUSD" -YGGBUSD = YGGBUSD() +YGGUSDT = YGGUSDT() @dataclass(slots=True, frozen=True) class YGGUSDT: + """ + name: YGGUSDT + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 92141578.00000000 + margin: True + """ name: str = "YGGUSDT" precision: int = 8 minimum_margin: float = None @@ -48528,11 +67523,20 @@ def __call__(self): return "YGGUSDT" -YGGUSDT = YGGUSDT() +YOYOBNB = YOYOBNB() @dataclass(slots=True, frozen=True) class YOYOBNB: + """ + name: YOYOBNB + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 9000000.00000000 + margin: False + """ name: str = "YOYOBNB" precision: int = 8 minimum_margin: float = None @@ -48551,11 +67555,20 @@ def __call__(self): return "YOYOBNB" -YOYOBNB = YOYOBNB() +YOYOBTC = YOYOBTC() @dataclass(slots=True, frozen=True) class YOYOBTC: + """ + name: YOYOBTC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 90000000.00000000 + margin: False + """ name: str = "YOYOBTC" precision: int = 8 minimum_margin: float = None @@ -48574,11 +67587,20 @@ def __call__(self): return "YOYOBTC" -YOYOBTC = YOYOBTC() +YOYOETH = YOYOETH() @dataclass(slots=True, frozen=True) class YOYOETH: + """ + name: YOYOETH + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 90000000.00000000 + margin: False + """ name: str = "YOYOETH" precision: int = 8 minimum_margin: float = None @@ -48597,11 +67619,20 @@ def __call__(self): return "YOYOETH" -YOYOETH = YOYOETH() +ZECBNB = ZECBNB() @dataclass(slots=True, frozen=True) class ZECBNB: + """ + name: ZECBNB + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.00100000 + maximum_order_size: 900000.00000000 + margin: False + """ name: str = "ZECBNB" precision: int = 8 minimum_margin: float = None @@ -48620,11 +67651,20 @@ def __call__(self): return "ZECBNB" -ZECBNB = ZECBNB() +ZECBTC = ZECBTC() @dataclass(slots=True, frozen=True) class ZECBTC: + """ + name: ZECBTC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.00100000 + maximum_order_size: 10000000.00000000 + margin: True + """ name: str = "ZECBTC" precision: int = 8 minimum_margin: float = None @@ -48643,11 +67683,20 @@ def __call__(self): return "ZECBTC" -ZECBTC = ZECBTC() +ZECBUSD = ZECBUSD() @dataclass(slots=True, frozen=True) class ZECBUSD: + """ + name: ZECBUSD + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.00100000 + maximum_order_size: 90000.00000000 + margin: False + """ name: str = "ZECBUSD" precision: int = 8 minimum_margin: float = None @@ -48666,11 +67715,20 @@ def __call__(self): return "ZECBUSD" -ZECBUSD = ZECBUSD() +ZECETH = ZECETH() @dataclass(slots=True, frozen=True) class ZECETH: + """ + name: ZECETH + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.00100000 + maximum_order_size: 9000000.00000000 + margin: False + """ name: str = "ZECETH" precision: int = 8 minimum_margin: float = None @@ -48689,11 +67747,20 @@ def __call__(self): return "ZECETH" -ZECETH = ZECETH() +ZECPAX = ZECPAX() @dataclass(slots=True, frozen=True) class ZECPAX: + """ + name: ZECPAX + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.00001000 + maximum_order_size: 90000.00000000 + margin: False + """ name: str = "ZECPAX" precision: int = 8 minimum_margin: float = None @@ -48712,11 +67779,20 @@ def __call__(self): return "ZECPAX" -ZECPAX = ZECPAX() +ZECTUSD = ZECTUSD() @dataclass(slots=True, frozen=True) class ZECTUSD: + """ + name: ZECTUSD + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.00001000 + maximum_order_size: 90000.00000000 + margin: False + """ name: str = "ZECTUSD" precision: int = 8 minimum_margin: float = None @@ -48735,11 +67811,20 @@ def __call__(self): return "ZECTUSD" -ZECTUSD = ZECTUSD() +ZECUSDC = ZECUSDC() @dataclass(slots=True, frozen=True) class ZECUSDC: + """ + name: ZECUSDC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.00100000 + maximum_order_size: 90000.00000000 + margin: False + """ name: str = "ZECUSDC" precision: int = 8 minimum_margin: float = None @@ -48758,11 +67843,20 @@ def __call__(self): return "ZECUSDC" -ZECUSDC = ZECUSDC() +ZECUSDT = ZECUSDT() @dataclass(slots=True, frozen=True) class ZECUSDT: + """ + name: ZECUSDT + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.00100000 + maximum_order_size: 90000.00000000 + margin: True + """ name: str = "ZECUSDT" precision: int = 8 minimum_margin: float = None @@ -48781,11 +67875,20 @@ def __call__(self): return "ZECUSDT" -ZECUSDT = ZECUSDT() +ZENBNB = ZENBNB() @dataclass(slots=True, frozen=True) class ZENBNB: + """ + name: ZENBNB + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 900000.00000000 + margin: False + """ name: str = "ZENBNB" precision: int = 8 minimum_margin: float = None @@ -48804,11 +67907,20 @@ def __call__(self): return "ZENBNB" -ZENBNB = ZENBNB() +ZENBTC = ZENBTC() @dataclass(slots=True, frozen=True) class ZENBTC: + """ + name: ZENBTC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 90000000.00000000 + margin: False + """ name: str = "ZENBTC" precision: int = 8 minimum_margin: float = None @@ -48827,11 +67939,20 @@ def __call__(self): return "ZENBTC" -ZENBTC = ZENBTC() +ZENBUSD = ZENBUSD() @dataclass(slots=True, frozen=True) class ZENBUSD: + """ + name: ZENBUSD + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 9222449.00000000 + margin: False + """ name: str = "ZENBUSD" precision: int = 8 minimum_margin: float = None @@ -48850,11 +67971,20 @@ def __call__(self): return "ZENBUSD" -ZENBUSD = ZENBUSD() +ZENETH = ZENETH() @dataclass(slots=True, frozen=True) class ZENETH: + """ + name: ZENETH + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 9000000.00000000 + margin: False + """ name: str = "ZENETH" precision: int = 8 minimum_margin: float = None @@ -48873,11 +68003,20 @@ def __call__(self): return "ZENETH" -ZENETH = ZENETH() +ZENUSDT = ZENUSDT() @dataclass(slots=True, frozen=True) class ZENUSDT: + """ + name: ZENUSDT + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.01000000 + maximum_order_size: 900000.00000000 + margin: False + """ name: str = "ZENUSDT" precision: int = 8 minimum_margin: float = None @@ -48896,11 +68035,20 @@ def __call__(self): return "ZENUSDT" -ZENUSDT = ZENUSDT() +ZILBIDR = ZILBIDR() @dataclass(slots=True, frozen=True) class ZILBIDR: + """ + name: ZILBIDR + precision: 2 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 90000000.00000000 + margin: False + """ name: str = "ZILBIDR" precision: int = 2 minimum_margin: float = None @@ -48919,11 +68067,20 @@ def __call__(self): return "ZILBIDR" -ZILBIDR = ZILBIDR() +ZILBNB = ZILBNB() @dataclass(slots=True, frozen=True) class ZILBNB: + """ + name: ZILBNB + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 9000000.00000000 + margin: False + """ name: str = "ZILBNB" precision: int = 8 minimum_margin: float = None @@ -48942,11 +68099,20 @@ def __call__(self): return "ZILBNB" -ZILBNB = ZILBNB() +ZILBTC = ZILBTC() @dataclass(slots=True, frozen=True) class ZILBTC: + """ + name: ZILBTC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 90000000.00000000 + margin: True + """ name: str = "ZILBTC" precision: int = 8 minimum_margin: float = None @@ -48965,11 +68131,20 @@ def __call__(self): return "ZILBTC" -ZILBTC = ZILBTC() +ZILBUSD = ZILBUSD() @dataclass(slots=True, frozen=True) class ZILBUSD: + """ + name: ZILBUSD + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 9000000.00000000 + margin: True + """ name: str = "ZILBUSD" precision: int = 8 minimum_margin: float = None @@ -48988,11 +68163,20 @@ def __call__(self): return "ZILBUSD" -ZILBUSD = ZILBUSD() +ZILETH = ZILETH() @dataclass(slots=True, frozen=True) class ZILETH: + """ + name: ZILETH + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 90000000.00000000 + margin: False + """ name: str = "ZILETH" precision: int = 8 minimum_margin: float = None @@ -49011,11 +68195,20 @@ def __call__(self): return "ZILETH" -ZILETH = ZILETH() +ZILEUR = ZILEUR() @dataclass(slots=True, frozen=True) class ZILEUR: + """ + name: ZILEUR + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 9000000.00000000 + margin: False + """ name: str = "ZILEUR" precision: int = 8 minimum_margin: float = None @@ -49034,11 +68227,20 @@ def __call__(self): return "ZILEUR" -ZILEUR = ZILEUR() +ZILTRY = ZILTRY() @dataclass(slots=True, frozen=True) class ZILTRY: + """ + name: ZILTRY + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 9222449.00000000 + margin: False + """ name: str = "ZILTRY" precision: int = 8 minimum_margin: float = None @@ -49057,11 +68259,20 @@ def __call__(self): return "ZILTRY" -ZILTRY = ZILTRY() +ZILUSDT = ZILUSDT() @dataclass(slots=True, frozen=True) class ZILUSDT: + """ + name: ZILUSDT + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 9000000.00000000 + margin: True + """ name: str = "ZILUSDT" precision: int = 8 minimum_margin: float = None @@ -49080,11 +68291,20 @@ def __call__(self): return "ZILUSDT" -ZILUSDT = ZILUSDT() +ZRXBNB = ZRXBNB() @dataclass(slots=True, frozen=True) class ZRXBNB: + """ + name: ZRXBNB + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.10000000 + maximum_order_size: 9000000.00000000 + margin: False + """ name: str = "ZRXBNB" precision: int = 8 minimum_margin: float = None @@ -49103,11 +68323,20 @@ def __call__(self): return "ZRXBNB" -ZRXBNB = ZRXBNB() +ZRXBTC = ZRXBTC() @dataclass(slots=True, frozen=True) class ZRXBTC: + """ + name: ZRXBTC + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 90000000.00000000 + margin: True + """ name: str = "ZRXBTC" precision: int = 8 minimum_margin: float = None @@ -49126,11 +68355,20 @@ def __call__(self): return "ZRXBTC" -ZRXBTC = ZRXBTC() +ZRXBUSD = ZRXBUSD() @dataclass(slots=True, frozen=True) class ZRXBUSD: + """ + name: ZRXBUSD + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 900000.00000000 + margin: False + """ name: str = "ZRXBUSD" precision: int = 8 minimum_margin: float = None @@ -49149,11 +68387,20 @@ def __call__(self): return "ZRXBUSD" -ZRXBUSD = ZRXBUSD() +ZRXETH = ZRXETH() @dataclass(slots=True, frozen=True) class ZRXETH: + """ + name: ZRXETH + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 90000000.00000000 + margin: False + """ name: str = "ZRXETH" precision: int = 8 minimum_margin: float = None @@ -49172,11 +68419,20 @@ def __call__(self): return "ZRXETH" -ZRXETH = ZRXETH() +ZRXUSDT = ZRXUSDT() @dataclass(slots=True, frozen=True) class ZRXUSDT: + """ + name: ZRXUSDT + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: 1.00000000 + maximum_order_size: 900000.00000000 + margin: True + """ name: str = "ZRXUSDT" precision: int = 8 minimum_margin: float = None @@ -49193,8 +68449,3 @@ def __str__(self): def __call__(self): return "ZRXUSDT" - - -ZRXUSDT = ZRXUSDT() - - diff --git a/symbols/bitfinex.py b/symbols/bitfinex.py index aee8929..8b82c23 100644 --- a/symbols/bitfinex.py +++ b/symbols/bitfinex.py @@ -1,8 +1,22 @@ from dataclasses import dataclass + + +ONEINCH_USD = ONEINCH_USD() + + @dataclass(slots=True, frozen=True) class ONEINCH_USD: + """ + name: t1INCH:USD + precision: 5 + minimum_margin: 15.0 + initial_margin: 30.0 + minimum_order_size: 2.0 + maximum_order_size: 100000.0 + margin: False + """ name: str = "t1INCH:USD" precision: int = 5 minimum_margin: float = 15.0 @@ -21,11 +35,20 @@ def __call__(self): return "t1INCH:USD" -ONEINCH_USD = ONEINCH_USD() +ONEINCH_UST = ONEINCH_UST() @dataclass(slots=True, frozen=True) class ONEINCH_UST: + """ + name: t1INCH:UST + precision: 5 + minimum_margin: 15.0 + initial_margin: 30.0 + minimum_order_size: 2.0 + maximum_order_size: 100000.0 + margin: False + """ name: str = "t1INCH:UST" precision: int = 5 minimum_margin: float = 15.0 @@ -44,11 +67,20 @@ def __call__(self): return "t1INCH:UST" -ONEINCH_UST = ONEINCH_UST() +AAABBB = AAABBB() @dataclass(slots=True, frozen=True) class AAABBB: + """ + name: tAAABBB + precision: 5 + minimum_margin: 15.0 + initial_margin: 30.0 + minimum_order_size: 2.0 + maximum_order_size: 100.0 + margin: False + """ name: str = "tAAABBB" precision: int = 5 minimum_margin: float = 15.0 @@ -67,11 +99,20 @@ def __call__(self): return "tAAABBB" -AAABBB = AAABBB() +AAVE_USD = AAVE_USD() @dataclass(slots=True, frozen=True) class AAVE_USD: + """ + name: tAAVE:USD + precision: 5 + minimum_margin: 15.0 + initial_margin: 30.0 + minimum_order_size: 0.02 + maximum_order_size: 5000.0 + margin: False + """ name: str = "tAAVE:USD" precision: int = 5 minimum_margin: float = 15.0 @@ -90,11 +131,20 @@ def __call__(self): return "tAAVE:USD" -AAVE_USD = AAVE_USD() +AAVE_UST = AAVE_UST() @dataclass(slots=True, frozen=True) class AAVE_UST: + """ + name: tAAVE:UST + precision: 5 + minimum_margin: 15.0 + initial_margin: 30.0 + minimum_order_size: 0.02 + maximum_order_size: 5000.0 + margin: False + """ name: str = "tAAVE:UST" precision: int = 5 minimum_margin: float = 15.0 @@ -113,11 +163,20 @@ def __call__(self): return "tAAVE:UST" -AAVE_UST = AAVE_UST() +AAVEF0_USTF0 = AAVEF0_USTF0() @dataclass(slots=True, frozen=True) class AAVEF0_USTF0: + """ + name: tAAVEF0:USTF0 + precision: 5 + minimum_margin: 0.5 + initial_margin: 1.0 + minimum_order_size: 0.02 + maximum_order_size: 5000.0 + margin: True + """ name: str = "tAAVEF0:USTF0" precision: int = 5 minimum_margin: float = 0.5 @@ -136,11 +195,20 @@ def __call__(self): return "tAAVEF0:USTF0" -AAVEF0_USTF0 = AAVEF0_USTF0() +ADABTC = ADABTC() @dataclass(slots=True, frozen=True) class ADABTC: + """ + name: tADABTC + precision: 5 + minimum_margin: 15.0 + initial_margin: 30.0 + minimum_order_size: 4.0 + maximum_order_size: 250000.0 + margin: True + """ name: str = "tADABTC" precision: int = 5 minimum_margin: float = 15.0 @@ -159,11 +227,20 @@ def __call__(self): return "tADABTC" -ADABTC = ADABTC() +ADAF0_USTF0 = ADAF0_USTF0() @dataclass(slots=True, frozen=True) class ADAF0_USTF0: + """ + name: tADAF0:USTF0 + precision: 5 + minimum_margin: 0.5 + initial_margin: 1.0 + minimum_order_size: 4.0 + maximum_order_size: 250000.0 + margin: True + """ name: str = "tADAF0:USTF0" precision: int = 5 minimum_margin: float = 0.5 @@ -182,11 +259,20 @@ def __call__(self): return "tADAF0:USTF0" -ADAF0_USTF0 = ADAF0_USTF0() +ADAUSD = ADAUSD() @dataclass(slots=True, frozen=True) class ADAUSD: + """ + name: tADAUSD + precision: 5 + minimum_margin: 15.0 + initial_margin: 30.0 + minimum_order_size: 4.0 + maximum_order_size: 250000.0 + margin: True + """ name: str = "tADAUSD" precision: int = 5 minimum_margin: float = 15.0 @@ -205,11 +291,20 @@ def __call__(self): return "tADAUSD" -ADAUSD = ADAUSD() +ADAUST = ADAUST() @dataclass(slots=True, frozen=True) class ADAUST: + """ + name: tADAUST + precision: 5 + minimum_margin: 15.0 + initial_margin: 30.0 + minimum_order_size: 4.0 + maximum_order_size: 250000.0 + margin: True + """ name: str = "tADAUST" precision: int = 5 minimum_margin: float = 15.0 @@ -228,11 +323,20 @@ def __call__(self): return "tADAUST" -ADAUST = ADAUST() +AIXUSD = AIXUSD() @dataclass(slots=True, frozen=True) class AIXUSD: + """ + name: tAIXUSD + precision: 5 + minimum_margin: 15.0 + initial_margin: 30.0 + minimum_order_size: 570.0 + maximum_order_size: 2500000.0 + margin: False + """ name: str = "tAIXUSD" precision: int = 5 minimum_margin: float = 15.0 @@ -251,11 +355,20 @@ def __call__(self): return "tAIXUSD" -AIXUSD = AIXUSD() +AIXUST = AIXUST() @dataclass(slots=True, frozen=True) class AIXUST: + """ + name: tAIXUST + precision: 5 + minimum_margin: 15.0 + initial_margin: 30.0 + minimum_order_size: 570.0 + maximum_order_size: 2500000.0 + margin: False + """ name: str = "tAIXUST" precision: int = 5 minimum_margin: float = 15.0 @@ -274,11 +387,20 @@ def __call__(self): return "tAIXUST" -AIXUST = AIXUST() +ALBT_USD = ALBT_USD() @dataclass(slots=True, frozen=True) class ALBT_USD: + """ + name: tALBT:USD + precision: 5 + minimum_margin: 15.0 + initial_margin: 30.0 + minimum_order_size: 22.0 + maximum_order_size: 50000.0 + margin: False + """ name: str = "tALBT:USD" precision: int = 5 minimum_margin: float = 15.0 @@ -297,11 +419,20 @@ def __call__(self): return "tALBT:USD" -ALBT_USD = ALBT_USD() +ALGBTC = ALGBTC() @dataclass(slots=True, frozen=True) class ALGBTC: + """ + name: tALGBTC + precision: 5 + minimum_margin: 15.0 + initial_margin: 30.0 + minimum_order_size: 6.0 + maximum_order_size: 150000.0 + margin: False + """ name: str = "tALGBTC" precision: int = 5 minimum_margin: float = 15.0 @@ -320,11 +451,20 @@ def __call__(self): return "tALGBTC" -ALGBTC = ALGBTC() +ALGF0_USTF0 = ALGF0_USTF0() @dataclass(slots=True, frozen=True) class ALGF0_USTF0: + """ + name: tALGF0:USTF0 + precision: 5 + minimum_margin: 0.5 + initial_margin: 1.0 + minimum_order_size: 6.0 + maximum_order_size: 250000.0 + margin: True + """ name: str = "tALGF0:USTF0" precision: int = 5 minimum_margin: float = 0.5 @@ -343,11 +483,20 @@ def __call__(self): return "tALGF0:USTF0" -ALGF0_USTF0 = ALGF0_USTF0() +ALGUSD = ALGUSD() @dataclass(slots=True, frozen=True) class ALGUSD: + """ + name: tALGUSD + precision: 5 + minimum_margin: 25.0 + initial_margin: 50.0 + minimum_order_size: 6.0 + maximum_order_size: 150000.0 + margin: True + """ name: str = "tALGUSD" precision: int = 5 minimum_margin: float = 25.0 @@ -366,11 +515,20 @@ def __call__(self): return "tALGUSD" -ALGUSD = ALGUSD() +ALGUST = ALGUST() @dataclass(slots=True, frozen=True) class ALGUST: + """ + name: tALGUST + precision: 5 + minimum_margin: 25.0 + initial_margin: 50.0 + minimum_order_size: 6.0 + maximum_order_size: 150000.0 + margin: True + """ name: str = "tALGUST" precision: int = 5 minimum_margin: float = 25.0 @@ -389,11 +547,20 @@ def __call__(self): return "tALGUST" -ALGUST = ALGUST() +AMPBTC = AMPBTC() @dataclass(slots=True, frozen=True) class AMPBTC: + """ + name: tAMPBTC + precision: 5 + minimum_margin: 15.0 + initial_margin: 30.0 + minimum_order_size: 2.0 + maximum_order_size: 25000.0 + margin: False + """ name: str = "tAMPBTC" precision: int = 5 minimum_margin: float = 15.0 @@ -412,11 +579,20 @@ def __call__(self): return "tAMPBTC" -AMPBTC = AMPBTC() +AMPF0_USTF0 = AMPF0_USTF0() @dataclass(slots=True, frozen=True) class AMPF0_USTF0: + """ + name: tAMPF0:USTF0 + precision: 5 + minimum_margin: 2.5 + initial_margin: 5.0 + minimum_order_size: 2.0 + maximum_order_size: 100000.0 + margin: True + """ name: str = "tAMPF0:USTF0" precision: int = 5 minimum_margin: float = 2.5 @@ -435,11 +611,20 @@ def __call__(self): return "tAMPF0:USTF0" -AMPF0_USTF0 = AMPF0_USTF0() +AMPUSD = AMPUSD() @dataclass(slots=True, frozen=True) class AMPUSD: + """ + name: tAMPUSD + precision: 5 + minimum_margin: 15.0 + initial_margin: 30.0 + minimum_order_size: 2.0 + maximum_order_size: 25000.0 + margin: False + """ name: str = "tAMPUSD" precision: int = 5 minimum_margin: float = 15.0 @@ -458,11 +643,20 @@ def __call__(self): return "tAMPUSD" -AMPUSD = AMPUSD() +AMPUST = AMPUST() @dataclass(slots=True, frozen=True) class AMPUST: + """ + name: tAMPUST + precision: 5 + minimum_margin: 15.0 + initial_margin: 30.0 + minimum_order_size: 2.0 + maximum_order_size: 25000.0 + margin: False + """ name: str = "tAMPUST" precision: int = 5 minimum_margin: float = 15.0 @@ -481,11 +675,20 @@ def __call__(self): return "tAMPUST" -AMPUST = AMPUST() +ANCUSD = ANCUSD() @dataclass(slots=True, frozen=True) class ANCUSD: + """ + name: tANCUSD + precision: 5 + minimum_margin: 15.0 + initial_margin: 30.0 + minimum_order_size: 10.0 + maximum_order_size: 100000.0 + margin: False + """ name: str = "tANCUSD" precision: int = 5 minimum_margin: float = 15.0 @@ -504,11 +707,20 @@ def __call__(self): return "tANCUSD" -ANCUSD = ANCUSD() +ANTBTC = ANTBTC() @dataclass(slots=True, frozen=True) class ANTBTC: + """ + name: tANTBTC + precision: 5 + minimum_margin: 15.0 + initial_margin: 30.0 + minimum_order_size: 2.0 + maximum_order_size: 10000.0 + margin: False + """ name: str = "tANTBTC" precision: int = 5 minimum_margin: float = 15.0 @@ -527,11 +739,20 @@ def __call__(self): return "tANTBTC" -ANTBTC = ANTBTC() +ANTUSD = ANTUSD() @dataclass(slots=True, frozen=True) class ANTUSD: + """ + name: tANTUSD + precision: 5 + minimum_margin: 15.0 + initial_margin: 30.0 + minimum_order_size: 2.0 + maximum_order_size: 10000.0 + margin: False + """ name: str = "tANTUSD" precision: int = 5 minimum_margin: float = 15.0 @@ -550,11 +771,20 @@ def __call__(self): return "tANTUSD" -ANTUSD = ANTUSD() +APEF0_USTF0 = APEF0_USTF0() @dataclass(slots=True, frozen=True) class APEF0_USTF0: + """ + name: tAPEF0:USTF0 + precision: 5 + minimum_margin: 0.5 + initial_margin: 1.0 + minimum_order_size: 0.4 + maximum_order_size: 50000.0 + margin: True + """ name: str = "tAPEF0:USTF0" precision: int = 5 minimum_margin: float = 0.5 @@ -573,11 +803,20 @@ def __call__(self): return "tAPEF0:USTF0" -APEF0_USTF0 = APEF0_USTF0() +APENFT_USD = APENFT_USD() @dataclass(slots=True, frozen=True) class APENFT_USD: + """ + name: tAPENFT:USD + precision: 5 + minimum_margin: 15.0 + initial_margin: 30.0 + minimum_order_size: 0.001 + maximum_order_size: 40000000000.0 + margin: False + """ name: str = "tAPENFT:USD" precision: int = 5 minimum_margin: float = 15.0 @@ -596,11 +835,20 @@ def __call__(self): return "tAPENFT:USD" -APENFT_USD = APENFT_USD() +APENFT_UST = APENFT_UST() @dataclass(slots=True, frozen=True) class APENFT_UST: + """ + name: tAPENFT:UST + precision: 5 + minimum_margin: 15.0 + initial_margin: 30.0 + minimum_order_size: 0.001 + maximum_order_size: 40000000000.0 + margin: False + """ name: str = "tAPENFT:UST" precision: int = 5 minimum_margin: float = 15.0 @@ -619,11 +867,20 @@ def __call__(self): return "tAPENFT:UST" -APENFT_UST = APENFT_UST() +APEUSD = APEUSD() @dataclass(slots=True, frozen=True) class APEUSD: + """ + name: tAPEUSD + precision: 5 + minimum_margin: 30.0 + initial_margin: 60.0 + minimum_order_size: 0.4 + maximum_order_size: 50000.0 + margin: True + """ name: str = "tAPEUSD" precision: int = 5 minimum_margin: float = 30.0 @@ -642,11 +899,20 @@ def __call__(self): return "tAPEUSD" -APEUSD = APEUSD() +APEUST = APEUST() @dataclass(slots=True, frozen=True) class APEUST: + """ + name: tAPEUST + precision: 5 + minimum_margin: 30.0 + initial_margin: 60.0 + minimum_order_size: 0.4 + maximum_order_size: 50000.0 + margin: True + """ name: str = "tAPEUST" precision: int = 5 minimum_margin: float = 30.0 @@ -665,11 +931,20 @@ def __call__(self): return "tAPEUST" -APEUST = APEUST() +APTF0_USTF0 = APTF0_USTF0() @dataclass(slots=True, frozen=True) class APTF0_USTF0: + """ + name: tAPTF0:USTF0 + precision: 5 + minimum_margin: 0.5 + initial_margin: 1.0 + minimum_order_size: 0.001 + maximum_order_size: 30000.0 + margin: True + """ name: str = "tAPTF0:USTF0" precision: int = 5 minimum_margin: float = 0.5 @@ -688,11 +963,20 @@ def __call__(self): return "tAPTF0:USTF0" -APTF0_USTF0 = APTF0_USTF0() +APTUSD = APTUSD() @dataclass(slots=True, frozen=True) class APTUSD: + """ + name: tAPTUSD + precision: 5 + minimum_margin: 15.0 + initial_margin: 30.0 + minimum_order_size: 0.001 + maximum_order_size: 30000.0 + margin: False + """ name: str = "tAPTUSD" precision: int = 5 minimum_margin: float = 15.0 @@ -711,11 +995,20 @@ def __call__(self): return "tAPTUSD" -APTUSD = APTUSD() +APTUST = APTUST() @dataclass(slots=True, frozen=True) class APTUST: + """ + name: tAPTUST + precision: 5 + minimum_margin: 15.0 + initial_margin: 30.0 + minimum_order_size: 0.001 + maximum_order_size: 30000.0 + margin: False + """ name: str = "tAPTUST" precision: int = 5 minimum_margin: float = 15.0 @@ -734,11 +1027,20 @@ def __call__(self): return "tAPTUST" -APTUST = APTUST() +ATLAS_USD = ATLAS_USD() @dataclass(slots=True, frozen=True) class ATLAS_USD: + """ + name: tATLAS:USD + precision: 5 + minimum_margin: 15.0 + initial_margin: 30.0 + minimum_order_size: 232.0 + maximum_order_size: 25000000.0 + margin: False + """ name: str = "tATLAS:USD" precision: int = 5 minimum_margin: float = 15.0 @@ -757,11 +1059,20 @@ def __call__(self): return "tATLAS:USD" -ATLAS_USD = ATLAS_USD() +ATLAS_UST = ATLAS_UST() @dataclass(slots=True, frozen=True) class ATLAS_UST: + """ + name: tATLAS:UST + precision: 5 + minimum_margin: 15.0 + initial_margin: 30.0 + minimum_order_size: 232.0 + maximum_order_size: 25000000.0 + margin: False + """ name: str = "tATLAS:UST" precision: int = 5 minimum_margin: float = 15.0 @@ -780,11 +1091,20 @@ def __call__(self): return "tATLAS:UST" -ATLAS_UST = ATLAS_UST() +ATOBTC = ATOBTC() @dataclass(slots=True, frozen=True) class ATOBTC: + """ + name: tATOBTC + precision: 5 + minimum_margin: 15.0 + initial_margin: 30.0 + minimum_order_size: 0.2 + maximum_order_size: 100000.0 + margin: False + """ name: str = "tATOBTC" precision: int = 5 minimum_margin: float = 15.0 @@ -803,11 +1123,20 @@ def __call__(self): return "tATOBTC" -ATOBTC = ATOBTC() +ATOETH = ATOETH() @dataclass(slots=True, frozen=True) class ATOETH: + """ + name: tATOETH + precision: 5 + minimum_margin: 15.0 + initial_margin: 30.0 + minimum_order_size: 0.2 + maximum_order_size: 100000.0 + margin: False + """ name: str = "tATOETH" precision: int = 5 minimum_margin: float = 15.0 @@ -826,11 +1155,20 @@ def __call__(self): return "tATOETH" -ATOETH = ATOETH() +ATOF0_USTF0 = ATOF0_USTF0() @dataclass(slots=True, frozen=True) class ATOF0_USTF0: + """ + name: tATOF0:USTF0 + precision: 5 + minimum_margin: 0.5 + initial_margin: 1.0 + minimum_order_size: 0.2 + maximum_order_size: 100000.0 + margin: True + """ name: str = "tATOF0:USTF0" precision: int = 5 minimum_margin: float = 0.5 @@ -849,11 +1187,20 @@ def __call__(self): return "tATOF0:USTF0" -ATOF0_USTF0 = ATOF0_USTF0() +ATOUSD = ATOUSD() @dataclass(slots=True, frozen=True) class ATOUSD: + """ + name: tATOUSD + precision: 5 + minimum_margin: 25.0 + initial_margin: 50.0 + minimum_order_size: 0.2 + maximum_order_size: 100000.0 + margin: True + """ name: str = "tATOUSD" precision: int = 5 minimum_margin: float = 25.0 @@ -872,11 +1219,20 @@ def __call__(self): return "tATOUSD" -ATOUSD = ATOUSD() +ATOUST = ATOUST() @dataclass(slots=True, frozen=True) class ATOUST: + """ + name: tATOUST + precision: 5 + minimum_margin: 15.0 + initial_margin: 30.0 + minimum_order_size: 0.2 + maximum_order_size: 100000.0 + margin: True + """ name: str = "tATOUST" precision: int = 5 minimum_margin: float = 15.0 @@ -895,11 +1251,20 @@ def __call__(self): return "tATOUST" -ATOUST = ATOUST() +AVAX_BTC = AVAX_BTC() @dataclass(slots=True, frozen=True) class AVAX_BTC: + """ + name: tAVAX:BTC + precision: 5 + minimum_margin: 15.0 + initial_margin: 30.0 + minimum_order_size: 0.08 + maximum_order_size: 50000.0 + margin: True + """ name: str = "tAVAX:BTC" precision: int = 5 minimum_margin: float = 15.0 @@ -918,11 +1283,20 @@ def __call__(self): return "tAVAX:BTC" -AVAX_BTC = AVAX_BTC() +AVAX_USD = AVAX_USD() @dataclass(slots=True, frozen=True) class AVAX_USD: + """ + name: tAVAX:USD + precision: 5 + minimum_margin: 15.0 + initial_margin: 30.0 + minimum_order_size: 0.08 + maximum_order_size: 50000.0 + margin: True + """ name: str = "tAVAX:USD" precision: int = 5 minimum_margin: float = 15.0 @@ -941,11 +1315,20 @@ def __call__(self): return "tAVAX:USD" -AVAX_USD = AVAX_USD() +AVAX_UST = AVAX_UST() @dataclass(slots=True, frozen=True) class AVAX_UST: + """ + name: tAVAX:UST + precision: 5 + minimum_margin: 15.0 + initial_margin: 30.0 + minimum_order_size: 0.08 + maximum_order_size: 50000.0 + margin: True + """ name: str = "tAVAX:UST" precision: int = 5 minimum_margin: float = 15.0 @@ -964,11 +1347,20 @@ def __call__(self): return "tAVAX:UST" -AVAX_UST = AVAX_UST() +AVAXF0_BTCF0 = AVAXF0_BTCF0() @dataclass(slots=True, frozen=True) class AVAXF0_BTCF0: + """ + name: tAVAXF0:BTCF0 + precision: 5 + minimum_margin: 0.5 + initial_margin: 1.0 + minimum_order_size: 0.08 + maximum_order_size: 50000.0 + margin: True + """ name: str = "tAVAXF0:BTCF0" precision: int = 5 minimum_margin: float = 0.5 @@ -987,11 +1379,20 @@ def __call__(self): return "tAVAXF0:BTCF0" -AVAXF0_BTCF0 = AVAXF0_BTCF0() +AVAXF0_USTF0 = AVAXF0_USTF0() @dataclass(slots=True, frozen=True) class AVAXF0_USTF0: + """ + name: tAVAXF0:USTF0 + precision: 5 + minimum_margin: 0.5 + initial_margin: 1.0 + minimum_order_size: 0.08 + maximum_order_size: 10000.0 + margin: True + """ name: str = "tAVAXF0:USTF0" precision: int = 5 minimum_margin: float = 0.5 @@ -1010,11 +1411,20 @@ def __call__(self): return "tAVAXF0:USTF0" -AVAXF0_USTF0 = AVAXF0_USTF0() +AXSF0_USTF0 = AXSF0_USTF0() @dataclass(slots=True, frozen=True) class AXSF0_USTF0: + """ + name: tAXSF0:USTF0 + precision: 5 + minimum_margin: 0.5 + initial_margin: 1.0 + minimum_order_size: 0.2 + maximum_order_size: 10000.0 + margin: True + """ name: str = "tAXSF0:USTF0" precision: int = 5 minimum_margin: float = 0.5 @@ -1033,11 +1443,20 @@ def __call__(self): return "tAXSF0:USTF0" -AXSF0_USTF0 = AXSF0_USTF0() +AXSUSD = AXSUSD() @dataclass(slots=True, frozen=True) class AXSUSD: + """ + name: tAXSUSD + precision: 5 + minimum_margin: 15.0 + initial_margin: 30.0 + minimum_order_size: 0.2 + maximum_order_size: 10000.0 + margin: True + """ name: str = "tAXSUSD" precision: int = 5 minimum_margin: float = 15.0 @@ -1056,11 +1475,20 @@ def __call__(self): return "tAXSUSD" -AXSUSD = AXSUSD() +AXSUST = AXSUST() @dataclass(slots=True, frozen=True) class AXSUST: + """ + name: tAXSUST + precision: 5 + minimum_margin: 15.0 + initial_margin: 30.0 + minimum_order_size: 0.2 + maximum_order_size: 10000.0 + margin: True + """ name: str = "tAXSUST" precision: int = 5 minimum_margin: float = 15.0 @@ -1079,11 +1507,20 @@ def __call__(self): return "tAXSUST" -AXSUST = AXSUST() +B2MUSD = B2MUSD() @dataclass(slots=True, frozen=True) class B2MUSD: + """ + name: tB2MUSD + precision: 5 + minimum_margin: 15.0 + initial_margin: 30.0 + minimum_order_size: 144.0 + maximum_order_size: 5000000.0 + margin: False + """ name: str = "tB2MUSD" precision: int = 5 minimum_margin: float = 15.0 @@ -1102,11 +1539,20 @@ def __call__(self): return "tB2MUSD" -B2MUSD = B2MUSD() +B2MUST = B2MUST() @dataclass(slots=True, frozen=True) class B2MUST: + """ + name: tB2MUST + precision: 5 + minimum_margin: 15.0 + initial_margin: 30.0 + minimum_order_size: 144.0 + maximum_order_size: 5000000.0 + margin: False + """ name: str = "tB2MUST" precision: int = 5 minimum_margin: float = 15.0 @@ -1125,11 +1571,20 @@ def __call__(self): return "tB2MUST" -B2MUST = B2MUST() +BALUSD = BALUSD() @dataclass(slots=True, frozen=True) class BALUSD: + """ + name: tBALUSD + precision: 5 + minimum_margin: 15.0 + initial_margin: 30.0 + minimum_order_size: 0.4 + maximum_order_size: 10000.0 + margin: False + """ name: str = "tBALUSD" precision: int = 5 minimum_margin: float = 15.0 @@ -1148,11 +1603,20 @@ def __call__(self): return "tBALUSD" -BALUSD = BALUSD() +BALUST = BALUST() @dataclass(slots=True, frozen=True) class BALUST: + """ + name: tBALUST + precision: 5 + minimum_margin: 15.0 + initial_margin: 30.0 + minimum_order_size: 0.4 + maximum_order_size: 10000.0 + margin: False + """ name: str = "tBALUST" precision: int = 5 minimum_margin: float = 15.0 @@ -1171,11 +1635,20 @@ def __call__(self): return "tBALUST" -BALUST = BALUST() +BAND_USD = BAND_USD() @dataclass(slots=True, frozen=True) class BAND_USD: + """ + name: tBAND:USD + precision: 5 + minimum_margin: 15.0 + initial_margin: 30.0 + minimum_order_size: 2.0 + maximum_order_size: 50000.0 + margin: False + """ name: str = "tBAND:USD" precision: int = 5 minimum_margin: float = 15.0 @@ -1194,11 +1667,20 @@ def __call__(self): return "tBAND:USD" -BAND_USD = BAND_USD() +BAND_UST = BAND_UST() @dataclass(slots=True, frozen=True) class BAND_UST: + """ + name: tBAND:UST + precision: 5 + minimum_margin: 15.0 + initial_margin: 30.0 + minimum_order_size: 2.0 + maximum_order_size: 50000.0 + margin: False + """ name: str = "tBAND:UST" precision: int = 5 minimum_margin: float = 15.0 @@ -1217,11 +1699,20 @@ def __call__(self): return "tBAND:UST" -BAND_UST = BAND_UST() +BATUSD = BATUSD() @dataclass(slots=True, frozen=True) class BATUSD: + """ + name: tBATUSD + precision: 5 + minimum_margin: 15.0 + initial_margin: 30.0 + minimum_order_size: 6.0 + maximum_order_size: 200000.0 + margin: False + """ name: str = "tBATUSD" precision: int = 5 minimum_margin: float = 15.0 @@ -1240,11 +1731,20 @@ def __call__(self): return "tBATUSD" -BATUSD = BATUSD() +BATUST = BATUST() @dataclass(slots=True, frozen=True) class BATUST: + """ + name: tBATUST + precision: 5 + minimum_margin: 15.0 + initial_margin: 30.0 + minimum_order_size: 6.0 + maximum_order_size: 200000.0 + margin: False + """ name: str = "tBATUST" precision: int = 5 minimum_margin: float = 15.0 @@ -1263,11 +1763,20 @@ def __call__(self): return "tBATUST" -BATUST = BATUST() +BCHABC_USD = BCHABC_USD() @dataclass(slots=True, frozen=True) class BCHABC_USD: + """ + name: tBCHABC:USD + precision: 5 + minimum_margin: 15.0 + initial_margin: 30.0 + minimum_order_size: 40962.0 + maximum_order_size: 1000000000.0 + margin: False + """ name: str = "tBCHABC:USD" precision: int = 5 minimum_margin: float = 15.0 @@ -1286,11 +1795,20 @@ def __call__(self): return "tBCHABC:USD" -BCHABC_USD = BCHABC_USD() +BCHN_USD = BCHN_USD() @dataclass(slots=True, frozen=True) class BCHN_USD: + """ + name: tBCHN:USD + precision: 5 + minimum_margin: 15.0 + initial_margin: 30.0 + minimum_order_size: 0.02 + maximum_order_size: 1000.0 + margin: True + """ name: str = "tBCHN:USD" precision: int = 5 minimum_margin: float = 15.0 @@ -1309,11 +1827,20 @@ def __call__(self): return "tBCHN:USD" -BCHN_USD = BCHN_USD() +BEST_USD = BEST_USD() @dataclass(slots=True, frozen=True) class BEST_USD: + """ + name: tBEST:USD + precision: 5 + minimum_margin: 15.0 + initial_margin: 30.0 + minimum_order_size: 4.0 + maximum_order_size: 50000.0 + margin: False + """ name: str = "tBEST:USD" precision: int = 5 minimum_margin: float = 15.0 @@ -1332,11 +1859,20 @@ def __call__(self): return "tBEST:USD" -BEST_USD = BEST_USD() +BMNBTC = BMNBTC() @dataclass(slots=True, frozen=True) class BMNBTC: + """ + name: tBMNBTC + precision: 5 + minimum_margin: 15.0 + initial_margin: 30.0 + minimum_order_size: 0.00002 + maximum_order_size: 1.0 + margin: False + """ name: str = "tBMNBTC" precision: int = 5 minimum_margin: float = 15.0 @@ -1355,11 +1891,20 @@ def __call__(self): return "tBMNBTC" -BMNBTC = BMNBTC() +BMNUSD = BMNUSD() @dataclass(slots=True, frozen=True) class BMNUSD: + """ + name: tBMNUSD + precision: 5 + minimum_margin: 15.0 + initial_margin: 30.0 + minimum_order_size: 0.00002 + maximum_order_size: 1.0 + margin: False + """ name: str = "tBMNUSD" precision: int = 5 minimum_margin: float = 15.0 @@ -1378,11 +1923,20 @@ def __call__(self): return "tBMNUSD" -BMNUSD = BMNUSD() +BNTUSD = BNTUSD() @dataclass(slots=True, frozen=True) class BNTUSD: + """ + name: tBNTUSD + precision: 5 + minimum_margin: 15.0 + initial_margin: 30.0 + minimum_order_size: 2.0 + maximum_order_size: 20000.0 + margin: False + """ name: str = "tBNTUSD" precision: int = 5 minimum_margin: float = 15.0 @@ -1401,11 +1955,20 @@ def __call__(self): return "tBNTUSD" -BNTUSD = BNTUSD() +BOBA_USD = BOBA_USD() @dataclass(slots=True, frozen=True) class BOBA_USD: + """ + name: tBOBA:USD + precision: 5 + minimum_margin: 15.0 + initial_margin: 30.0 + minimum_order_size: 4.0 + maximum_order_size: 50000.0 + margin: False + """ name: str = "tBOBA:USD" precision: int = 5 minimum_margin: float = 15.0 @@ -1424,11 +1987,20 @@ def __call__(self): return "tBOBA:USD" -BOBA_USD = BOBA_USD() +BOBA_UST = BOBA_UST() @dataclass(slots=True, frozen=True) class BOBA_UST: + """ + name: tBOBA:UST + precision: 5 + minimum_margin: 15.0 + initial_margin: 30.0 + minimum_order_size: 4.0 + maximum_order_size: 50000.0 + margin: False + """ name: str = "tBOBA:UST" precision: int = 5 minimum_margin: float = 15.0 @@ -1447,11 +2019,20 @@ def __call__(self): return "tBOBA:UST" -BOBA_UST = BOBA_UST() +BOOUSD = BOOUSD() @dataclass(slots=True, frozen=True) class BOOUSD: + """ + name: tBOOUSD + precision: 5 + minimum_margin: 15.0 + initial_margin: 30.0 + minimum_order_size: 0.001 + maximum_order_size: 45000.0 + margin: False + """ name: str = "tBOOUSD" precision: int = 5 minimum_margin: float = 15.0 @@ -1470,11 +2051,20 @@ def __call__(self): return "tBOOUSD" -BOOUSD = BOOUSD() +BOOUST = BOOUST() @dataclass(slots=True, frozen=True) class BOOUST: + """ + name: tBOOUST + precision: 5 + minimum_margin: 15.0 + initial_margin: 30.0 + minimum_order_size: 0.001 + maximum_order_size: 45000.0 + margin: False + """ name: str = "tBOOUST" precision: int = 5 minimum_margin: float = 15.0 @@ -1493,11 +2083,20 @@ def __call__(self): return "tBOOUST" -BOOUST = BOOUST() +BOSON_USD = BOSON_USD() @dataclass(slots=True, frozen=True) class BOSON_USD: + """ + name: tBOSON:USD + precision: 5 + minimum_margin: 15.0 + initial_margin: 30.0 + minimum_order_size: 6.0 + maximum_order_size: 50000.0 + margin: False + """ name: str = "tBOSON:USD" precision: int = 5 minimum_margin: float = 15.0 @@ -1516,11 +2115,20 @@ def __call__(self): return "tBOSON:USD" -BOSON_USD = BOSON_USD() +BOSON_UST = BOSON_UST() @dataclass(slots=True, frozen=True) class BOSON_UST: + """ + name: tBOSON:UST + precision: 5 + minimum_margin: 15.0 + initial_margin: 30.0 + minimum_order_size: 6.0 + maximum_order_size: 50000.0 + margin: False + """ name: str = "tBOSON:UST" precision: int = 5 minimum_margin: float = 15.0 @@ -1539,11 +2147,20 @@ def __call__(self): return "tBOSON:UST" -BOSON_UST = BOSON_UST() +BTC_CNHT = BTC_CNHT() @dataclass(slots=True, frozen=True) class BTC_CNHT: + """ + name: tBTC:CNHT + precision: 5 + minimum_margin: 15.0 + initial_margin: 30.0 + minimum_order_size: 0.00006 + maximum_order_size: 5000.0 + margin: False + """ name: str = "tBTC:CNHT" precision: int = 5 minimum_margin: float = 15.0 @@ -1562,11 +2179,20 @@ def __call__(self): return "tBTC:CNHT" -BTC_CNHT = BTC_CNHT() +BTC_MXNT = BTC_MXNT() @dataclass(slots=True, frozen=True) class BTC_MXNT: + """ + name: tBTC:MXNT + precision: 5 + minimum_margin: 15.0 + initial_margin: 30.0 + minimum_order_size: 0.001 + maximum_order_size: 500.0 + margin: False + """ name: str = "tBTC:MXNT" precision: int = 5 minimum_margin: float = 15.0 @@ -1585,11 +2211,20 @@ def __call__(self): return "tBTC:MXNT" -BTC_MXNT = BTC_MXNT() +BTC_XAUT = BTC_XAUT() @dataclass(slots=True, frozen=True) class BTC_XAUT: + """ + name: tBTC:XAUT + precision: 5 + minimum_margin: 15.0 + initial_margin: 30.0 + minimum_order_size: 0.0002 + maximum_order_size: 250.0 + margin: False + """ name: str = "tBTC:XAUT" precision: int = 5 minimum_margin: float = 15.0 @@ -1608,11 +2243,20 @@ def __call__(self): return "tBTC:XAUT" -BTC_XAUT = BTC_XAUT() +BTCDOMF0_USTF0 = BTCDOMF0_USTF0() @dataclass(slots=True, frozen=True) class BTCDOMF0_USTF0: + """ + name: tBTCDOMF0:USTF0 + precision: 5 + minimum_margin: 0.5 + initial_margin: 1.0 + minimum_order_size: 0.01 + maximum_order_size: 5000.0 + margin: True + """ name: str = "tBTCDOMF0:USTF0" precision: int = 5 minimum_margin: float = 0.5 @@ -1631,11 +2275,20 @@ def __call__(self): return "tBTCDOMF0:USTF0" -BTCDOMF0_USTF0 = BTCDOMF0_USTF0() +BTCEUR = BTCEUR() @dataclass(slots=True, frozen=True) class BTCEUR: + """ + name: tBTCEUR + precision: 5 + minimum_margin: 10.0 + initial_margin: 20.0 + minimum_order_size: 0.00006 + maximum_order_size: 2000.0 + margin: True + """ name: str = "tBTCEUR" precision: int = 5 minimum_margin: float = 10.0 @@ -1654,11 +2307,20 @@ def __call__(self): return "tBTCEUR" -BTCEUR = BTCEUR() +BTCEUT = BTCEUT() @dataclass(slots=True, frozen=True) class BTCEUT: + """ + name: tBTCEUT + precision: 5 + minimum_margin: 15.0 + initial_margin: 30.0 + minimum_order_size: 0.00006 + maximum_order_size: 2000.0 + margin: True + """ name: str = "tBTCEUT" precision: int = 5 minimum_margin: float = 15.0 @@ -1677,11 +2339,20 @@ def __call__(self): return "tBTCEUT" -BTCEUT = BTCEUT() +BTCF0_EUTF0 = BTCF0_EUTF0() @dataclass(slots=True, frozen=True) class BTCF0_EUTF0: + """ + name: tBTCF0:EUTF0 + precision: 5 + minimum_margin: 0.5 + initial_margin: 1.0 + minimum_order_size: 0.0002 + maximum_order_size: 2000.0 + margin: True + """ name: str = "tBTCF0:EUTF0" precision: int = 5 minimum_margin: float = 0.5 @@ -1700,11 +2371,20 @@ def __call__(self): return "tBTCF0:EUTF0" -BTCF0_EUTF0 = BTCF0_EUTF0() +BTCF0_USTF0 = BTCF0_USTF0() @dataclass(slots=True, frozen=True) class BTCF0_USTF0: + """ + name: tBTCF0:USTF0 + precision: 5 + minimum_margin: 0.5 + initial_margin: 1.0 + minimum_order_size: 0.00006 + maximum_order_size: 100.0 + margin: True + """ name: str = "tBTCF0:USTF0" precision: int = 5 minimum_margin: float = 0.5 @@ -1723,11 +2403,20 @@ def __call__(self): return "tBTCF0:USTF0" -BTCF0_USTF0 = BTCF0_USTF0() +BTCGBP = BTCGBP() @dataclass(slots=True, frozen=True) class BTCGBP: + """ + name: tBTCGBP + precision: 5 + minimum_margin: 15.0 + initial_margin: 30.0 + minimum_order_size: 0.00006 + maximum_order_size: 2000.0 + margin: True + """ name: str = "tBTCGBP" precision: int = 5 minimum_margin: float = 15.0 @@ -1746,11 +2435,20 @@ def __call__(self): return "tBTCGBP" -BTCGBP = BTCGBP() +BTCJPY = BTCJPY() @dataclass(slots=True, frozen=True) class BTCJPY: + """ + name: tBTCJPY + precision: 5 + minimum_margin: 15.0 + initial_margin: 30.0 + minimum_order_size: 0.00006 + maximum_order_size: 2000.0 + margin: True + """ name: str = "tBTCJPY" precision: int = 5 minimum_margin: float = 15.0 @@ -1769,11 +2467,20 @@ def __call__(self): return "tBTCJPY" -BTCJPY = BTCJPY() +BTCMIM = BTCMIM() @dataclass(slots=True, frozen=True) class BTCMIM: + """ + name: tBTCMIM + precision: 5 + minimum_margin: 15.0 + initial_margin: 30.0 + minimum_order_size: 0.0002 + maximum_order_size: 2500.0 + margin: False + """ name: str = "tBTCMIM" precision: int = 5 minimum_margin: float = 15.0 @@ -1792,11 +2499,20 @@ def __call__(self): return "tBTCMIM" -BTCMIM = BTCMIM() +BTCTRY = BTCTRY() @dataclass(slots=True, frozen=True) class BTCTRY: + """ + name: tBTCTRY + precision: 5 + minimum_margin: 15.0 + initial_margin: 30.0 + minimum_order_size: 0.001 + maximum_order_size: 500000.0 + margin: False + """ name: str = "tBTCTRY" precision: int = 5 minimum_margin: float = 15.0 @@ -1815,11 +2531,20 @@ def __call__(self): return "tBTCTRY" -BTCTRY = BTCTRY() +BTCUSD = BTCUSD() @dataclass(slots=True, frozen=True) class BTCUSD: + """ + name: tBTCUSD + precision: 5 + minimum_margin: 5.0 + initial_margin: 10.0 + minimum_order_size: 0.00006 + maximum_order_size: 2000.0 + margin: True + """ name: str = "tBTCUSD" precision: int = 5 minimum_margin: float = 5.0 @@ -1838,11 +2563,20 @@ def __call__(self): return "tBTCUSD" -BTCUSD = BTCUSD() +BTCUST = BTCUST() @dataclass(slots=True, frozen=True) class BTCUST: + """ + name: tBTCUST + precision: 5 + minimum_margin: 10.0 + initial_margin: 20.0 + minimum_order_size: 0.00006 + maximum_order_size: 2000.0 + margin: True + """ name: str = "tBTCUST" precision: int = 5 minimum_margin: float = 10.0 @@ -1861,11 +2595,20 @@ def __call__(self): return "tBTCUST" -BTCUST = BTCUST() +BTGBTC = BTGBTC() @dataclass(slots=True, frozen=True) class BTGBTC: + """ + name: tBTGBTC + precision: 5 + minimum_margin: 15.0 + initial_margin: 30.0 + minimum_order_size: 0.1 + maximum_order_size: 10000.0 + margin: False + """ name: str = "tBTGBTC" precision: int = 5 minimum_margin: float = 15.0 @@ -1884,11 +2627,20 @@ def __call__(self): return "tBTGBTC" -BTGBTC = BTGBTC() +BTGUSD = BTGUSD() @dataclass(slots=True, frozen=True) class BTGUSD: + """ + name: tBTGUSD + precision: 5 + minimum_margin: 15.0 + initial_margin: 30.0 + minimum_order_size: 0.1 + maximum_order_size: 10000.0 + margin: False + """ name: str = "tBTGUSD" precision: int = 5 minimum_margin: float = 15.0 @@ -1907,11 +2659,20 @@ def __call__(self): return "tBTGUSD" -BTGUSD = BTGUSD() +BTSE_USD = BTSE_USD() @dataclass(slots=True, frozen=True) class BTSE_USD: + """ + name: tBTSE:USD + precision: 5 + minimum_margin: 15.0 + initial_margin: 30.0 + minimum_order_size: 0.4 + maximum_order_size: 10000.0 + margin: False + """ name: str = "tBTSE:USD" precision: int = 5 minimum_margin: float = 15.0 @@ -1930,11 +2691,20 @@ def __call__(self): return "tBTSE:USD" -BTSE_USD = BTSE_USD() +BTTUSD = BTTUSD() @dataclass(slots=True, frozen=True) class BTTUSD: + """ + name: tBTTUSD + precision: 5 + minimum_margin: 15.0 + initial_margin: 30.0 + minimum_order_size: 1970444.0 + maximum_order_size: 25000000000.0 + margin: False + """ name: str = "tBTTUSD" precision: int = 5 minimum_margin: float = 15.0 @@ -1953,11 +2723,20 @@ def __call__(self): return "tBTTUSD" -BTTUSD = BTTUSD() +CCDBTC = CCDBTC() @dataclass(slots=True, frozen=True) class CCDBTC: + """ + name: tCCDBTC + precision: 5 + minimum_margin: 15.0 + initial_margin: 30.0 + minimum_order_size: 100.0 + maximum_order_size: 1000000.0 + margin: False + """ name: str = "tCCDBTC" precision: int = 5 minimum_margin: float = 15.0 @@ -1976,11 +2755,20 @@ def __call__(self): return "tCCDBTC" -CCDBTC = CCDBTC() +CCDUSD = CCDUSD() @dataclass(slots=True, frozen=True) class CCDUSD: + """ + name: tCCDUSD + precision: 5 + minimum_margin: 15.0 + initial_margin: 30.0 + minimum_order_size: 100.0 + maximum_order_size: 1000000.0 + margin: False + """ name: str = "tCCDUSD" precision: int = 5 minimum_margin: float = 15.0 @@ -1999,11 +2787,20 @@ def __call__(self): return "tCCDUSD" -CCDUSD = CCDUSD() +CCDUST = CCDUST() @dataclass(slots=True, frozen=True) class CCDUST: + """ + name: tCCDUST + precision: 5 + minimum_margin: 15.0 + initial_margin: 30.0 + minimum_order_size: 100.0 + maximum_order_size: 1000000.0 + margin: False + """ name: str = "tCCDUST" precision: int = 5 minimum_margin: float = 15.0 @@ -2022,11 +2819,20 @@ def __call__(self): return "tCCDUST" -CCDUST = CCDUST() +CHEX_USD = CHEX_USD() @dataclass(slots=True, frozen=True) class CHEX_USD: + """ + name: tCHEX:USD + precision: 5 + minimum_margin: 15.0 + initial_margin: 30.0 + minimum_order_size: 88.0 + maximum_order_size: 1000000.0 + margin: False + """ name: str = "tCHEX:USD" precision: int = 5 minimum_margin: float = 15.0 @@ -2045,11 +2851,20 @@ def __call__(self): return "tCHEX:USD" -CHEX_USD = CHEX_USD() +CHSB_BTC = CHSB_BTC() @dataclass(slots=True, frozen=True) class CHSB_BTC: + """ + name: tCHSB:BTC + precision: 5 + minimum_margin: 15.0 + initial_margin: 30.0 + minimum_order_size: 8.0 + maximum_order_size: 500000.0 + margin: False + """ name: str = "tCHSB:BTC" precision: int = 5 minimum_margin: float = 15.0 @@ -2068,11 +2883,20 @@ def __call__(self): return "tCHSB:BTC" -CHSB_BTC = CHSB_BTC() +CHSB_USD = CHSB_USD() @dataclass(slots=True, frozen=True) class CHSB_USD: + """ + name: tCHSB:USD + precision: 5 + minimum_margin: 15.0 + initial_margin: 30.0 + minimum_order_size: 8.0 + maximum_order_size: 500000.0 + margin: False + """ name: str = "tCHSB:USD" precision: int = 5 minimum_margin: float = 15.0 @@ -2091,11 +2915,20 @@ def __call__(self): return "tCHSB:USD" -CHSB_USD = CHSB_USD() +CHSB_UST = CHSB_UST() @dataclass(slots=True, frozen=True) class CHSB_UST: + """ + name: tCHSB:UST + precision: 5 + minimum_margin: 15.0 + initial_margin: 30.0 + minimum_order_size: 8.0 + maximum_order_size: 500000.0 + margin: False + """ name: str = "tCHSB:UST" precision: int = 5 minimum_margin: float = 15.0 @@ -2114,11 +2947,20 @@ def __call__(self): return "tCHSB:UST" -CHSB_UST = CHSB_UST() +CHZUSD = CHZUSD() @dataclass(slots=True, frozen=True) class CHZUSD: + """ + name: tCHZUSD + precision: 5 + minimum_margin: 15.0 + initial_margin: 30.0 + minimum_order_size: 16.0 + maximum_order_size: 250000.0 + margin: False + """ name: str = "tCHZUSD" precision: int = 5 minimum_margin: float = 15.0 @@ -2137,11 +2979,20 @@ def __call__(self): return "tCHZUSD" -CHZUSD = CHZUSD() +CHZUST = CHZUST() @dataclass(slots=True, frozen=True) class CHZUST: + """ + name: tCHZUST + precision: 5 + minimum_margin: 15.0 + initial_margin: 30.0 + minimum_order_size: 16.0 + maximum_order_size: 250000.0 + margin: False + """ name: str = "tCHZUST" precision: int = 5 minimum_margin: float = 15.0 @@ -2160,11 +3011,20 @@ def __call__(self): return "tCHZUST" -CHZUST = CHZUST() +CLOUSD = CLOUSD() @dataclass(slots=True, frozen=True) class CLOUSD: + """ + name: tCLOUSD + precision: 5 + minimum_margin: 15.0 + initial_margin: 30.0 + minimum_order_size: 624.0 + maximum_order_size: 1000000.0 + margin: False + """ name: str = "tCLOUSD" precision: int = 5 minimum_margin: float = 15.0 @@ -2183,11 +3043,20 @@ def __call__(self): return "tCLOUSD" -CLOUSD = CLOUSD() +CNH_CNHT = CNH_CNHT() @dataclass(slots=True, frozen=True) class CNH_CNHT: + """ + name: tCNH:CNHT + precision: 5 + minimum_margin: 15.0 + initial_margin: 30.0 + minimum_order_size: 14.0 + maximum_order_size: 500000.0 + margin: False + """ name: str = "tCNH:CNHT" precision: int = 5 minimum_margin: float = 15.0 @@ -2206,11 +3075,20 @@ def __call__(self): return "tCNH:CNHT" -CNH_CNHT = CNH_CNHT() +COMP_USD = COMP_USD() @dataclass(slots=True, frozen=True) class COMP_USD: + """ + name: tCOMP:USD + precision: 5 + minimum_margin: 15.0 + initial_margin: 30.0 + minimum_order_size: 0.04 + maximum_order_size: 5000.0 + margin: True + """ name: str = "tCOMP:USD" precision: int = 5 minimum_margin: float = 15.0 @@ -2229,11 +3107,20 @@ def __call__(self): return "tCOMP:USD" -COMP_USD = COMP_USD() +COMP_UST = COMP_UST() @dataclass(slots=True, frozen=True) class COMP_UST: + """ + name: tCOMP:UST + precision: 5 + minimum_margin: 15.0 + initial_margin: 30.0 + minimum_order_size: 0.04 + maximum_order_size: 5000.0 + margin: True + """ name: str = "tCOMP:UST" precision: int = 5 minimum_margin: float = 15.0 @@ -2252,11 +3139,20 @@ def __call__(self): return "tCOMP:UST" -COMP_UST = COMP_UST() +COMPF0_USTF0 = COMPF0_USTF0() @dataclass(slots=True, frozen=True) class COMPF0_USTF0: + """ + name: tCOMPF0:USTF0 + precision: 5 + minimum_margin: 0.5 + initial_margin: 1.0 + minimum_order_size: 0.04 + maximum_order_size: 5000.0 + margin: True + """ name: str = "tCOMPF0:USTF0" precision: int = 5 minimum_margin: float = 0.5 @@ -2275,11 +3171,20 @@ def __call__(self): return "tCOMPF0:USTF0" -COMPF0_USTF0 = COMPF0_USTF0() +CONV_USD = CONV_USD() @dataclass(slots=True, frozen=True) class CONV_USD: + """ + name: tCONV:USD + precision: 5 + minimum_margin: 15.0 + initial_margin: 30.0 + minimum_order_size: 0.001 + maximum_order_size: 50000000.0 + margin: False + """ name: str = "tCONV:USD" precision: int = 5 minimum_margin: float = 15.0 @@ -2298,11 +3203,20 @@ def __call__(self): return "tCONV:USD" -CONV_USD = CONV_USD() +CONV_UST = CONV_UST() @dataclass(slots=True, frozen=True) class CONV_UST: + """ + name: tCONV:UST + precision: 5 + minimum_margin: 15.0 + initial_margin: 30.0 + minimum_order_size: 0.001 + maximum_order_size: 50000000.0 + margin: False + """ name: str = "tCONV:UST" precision: int = 5 minimum_margin: float = 15.0 @@ -2321,11 +3235,20 @@ def __call__(self): return "tCONV:UST" -CONV_UST = CONV_UST() +CRVF0_USTF0 = CRVF0_USTF0() @dataclass(slots=True, frozen=True) class CRVF0_USTF0: + """ + name: tCRVF0:USTF0 + precision: 5 + minimum_margin: 0.5 + initial_margin: 1.0 + minimum_order_size: 2.0 + maximum_order_size: 50000.0 + margin: True + """ name: str = "tCRVF0:USTF0" precision: int = 5 minimum_margin: float = 0.5 @@ -2344,11 +3267,20 @@ def __call__(self): return "tCRVF0:USTF0" -CRVF0_USTF0 = CRVF0_USTF0() +CRVUSD = CRVUSD() @dataclass(slots=True, frozen=True) class CRVUSD: + """ + name: tCRVUSD + precision: 5 + minimum_margin: 15.0 + initial_margin: 30.0 + minimum_order_size: 2.0 + maximum_order_size: 50000.0 + margin: False + """ name: str = "tCRVUSD" precision: int = 5 minimum_margin: float = 15.0 @@ -2367,11 +3299,20 @@ def __call__(self): return "tCRVUSD" -CRVUSD = CRVUSD() +CRVUST = CRVUST() @dataclass(slots=True, frozen=True) class CRVUST: + """ + name: tCRVUST + precision: 5 + minimum_margin: 15.0 + initial_margin: 30.0 + minimum_order_size: 2.0 + maximum_order_size: 50000.0 + margin: False + """ name: str = "tCRVUST" precision: int = 5 minimum_margin: float = 15.0 @@ -2390,11 +3331,20 @@ def __call__(self): return "tCRVUST" -CRVUST = CRVUST() +DAIBTC = DAIBTC() @dataclass(slots=True, frozen=True) class DAIBTC: + """ + name: tDAIBTC + precision: 5 + minimum_margin: 15.0 + initial_margin: 30.0 + minimum_order_size: 2.0 + maximum_order_size: 200000.0 + margin: False + """ name: str = "tDAIBTC" precision: int = 5 minimum_margin: float = 15.0 @@ -2413,11 +3363,20 @@ def __call__(self): return "tDAIBTC" -DAIBTC = DAIBTC() +DAIETH = DAIETH() @dataclass(slots=True, frozen=True) class DAIETH: + """ + name: tDAIETH + precision: 5 + minimum_margin: 15.0 + initial_margin: 30.0 + minimum_order_size: 2.0 + maximum_order_size: 200000.0 + margin: False + """ name: str = "tDAIETH" precision: int = 5 minimum_margin: float = 15.0 @@ -2436,11 +3395,20 @@ def __call__(self): return "tDAIETH" -DAIETH = DAIETH() +DAIUSD = DAIUSD() @dataclass(slots=True, frozen=True) class DAIUSD: + """ + name: tDAIUSD + precision: 5 + minimum_margin: 33.0 + initial_margin: 66.0 + minimum_order_size: 2.0 + maximum_order_size: 200000.0 + margin: True + """ name: str = "tDAIUSD" precision: int = 5 minimum_margin: float = 33.0 @@ -2459,11 +3427,20 @@ def __call__(self): return "tDAIUSD" -DAIUSD = DAIUSD() +DGBUSD = DGBUSD() @dataclass(slots=True, frozen=True) class DGBUSD: + """ + name: tDGBUSD + precision: 5 + minimum_margin: 15.0 + initial_margin: 30.0 + minimum_order_size: 184.0 + maximum_order_size: 2500000.0 + margin: False + """ name: str = "tDGBUSD" precision: int = 5 minimum_margin: float = 15.0 @@ -2482,11 +3459,20 @@ def __call__(self): return "tDGBUSD" -DGBUSD = DGBUSD() +DOGE_BTC = DOGE_BTC() @dataclass(slots=True, frozen=True) class DOGE_BTC: + """ + name: tDOGE:BTC + precision: 5 + minimum_margin: 15.0 + initial_margin: 30.0 + minimum_order_size: 26.0 + maximum_order_size: 1500000.0 + margin: True + """ name: str = "tDOGE:BTC" precision: int = 5 minimum_margin: float = 15.0 @@ -2505,11 +3491,20 @@ def __call__(self): return "tDOGE:BTC" -DOGE_BTC = DOGE_BTC() +DOGE_USD = DOGE_USD() @dataclass(slots=True, frozen=True) class DOGE_USD: + """ + name: tDOGE:USD + precision: 5 + minimum_margin: 15.0 + initial_margin: 30.0 + minimum_order_size: 26.0 + maximum_order_size: 1500000.0 + margin: True + """ name: str = "tDOGE:USD" precision: int = 5 minimum_margin: float = 15.0 @@ -2528,11 +3523,20 @@ def __call__(self): return "tDOGE:USD" -DOGE_USD = DOGE_USD() +DOGE_UST = DOGE_UST() @dataclass(slots=True, frozen=True) class DOGE_UST: + """ + name: tDOGE:UST + precision: 5 + minimum_margin: 15.0 + initial_margin: 30.0 + minimum_order_size: 26.0 + maximum_order_size: 1500000.0 + margin: True + """ name: str = "tDOGE:UST" precision: int = 5 minimum_margin: float = 15.0 @@ -2551,11 +3555,20 @@ def __call__(self): return "tDOGE:UST" -DOGE_UST = DOGE_UST() +DOGEF0_USTF0 = DOGEF0_USTF0() @dataclass(slots=True, frozen=True) class DOGEF0_USTF0: + """ + name: tDOGEF0:USTF0 + precision: 5 + minimum_margin: 0.5 + initial_margin: 1.0 + minimum_order_size: 26.0 + maximum_order_size: 1500000.0 + margin: True + """ name: str = "tDOGEF0:USTF0" precision: int = 5 minimum_margin: float = 0.5 @@ -2574,11 +3587,20 @@ def __call__(self): return "tDOGEF0:USTF0" -DOGEF0_USTF0 = DOGEF0_USTF0() +DORA_USD = DORA_USD() @dataclass(slots=True, frozen=True) class DORA_USD: + """ + name: tDORA:USD + precision: 5 + minimum_margin: 15.0 + initial_margin: 30.0 + minimum_order_size: 0.8 + maximum_order_size: 25000.0 + margin: False + """ name: str = "tDORA:USD" precision: int = 5 minimum_margin: float = 15.0 @@ -2597,11 +3619,20 @@ def __call__(self): return "tDORA:USD" -DORA_USD = DORA_USD() +DORA_UST = DORA_UST() @dataclass(slots=True, frozen=True) class DORA_UST: + """ + name: tDORA:UST + precision: 5 + minimum_margin: 15.0 + initial_margin: 30.0 + minimum_order_size: 0.8 + maximum_order_size: 25000.0 + margin: False + """ name: str = "tDORA:UST" precision: int = 5 minimum_margin: float = 15.0 @@ -2620,11 +3651,20 @@ def __call__(self): return "tDORA:UST" -DORA_UST = DORA_UST() +DOTBTC = DOTBTC() @dataclass(slots=True, frozen=True) class DOTBTC: + """ + name: tDOTBTC + precision: 5 + minimum_margin: 15.0 + initial_margin: 30.0 + minimum_order_size: 0.2 + maximum_order_size: 50000.0 + margin: True + """ name: str = "tDOTBTC" precision: int = 5 minimum_margin: float = 15.0 @@ -2643,11 +3683,20 @@ def __call__(self): return "tDOTBTC" -DOTBTC = DOTBTC() +DOTF0_BTCF0 = DOTF0_BTCF0() @dataclass(slots=True, frozen=True) class DOTF0_BTCF0: + """ + name: tDOTF0:BTCF0 + precision: 5 + minimum_margin: 0.5 + initial_margin: 1.0 + minimum_order_size: 0.2 + maximum_order_size: 50000.0 + margin: True + """ name: str = "tDOTF0:BTCF0" precision: int = 5 minimum_margin: float = 0.5 @@ -2666,11 +3715,20 @@ def __call__(self): return "tDOTF0:BTCF0" -DOTF0_BTCF0 = DOTF0_BTCF0() +DOTF0_USTF0 = DOTF0_USTF0() @dataclass(slots=True, frozen=True) class DOTF0_USTF0: + """ + name: tDOTF0:USTF0 + precision: 5 + minimum_margin: 0.5 + initial_margin: 1.0 + minimum_order_size: 0.2 + maximum_order_size: 50000.0 + margin: True + """ name: str = "tDOTF0:USTF0" precision: int = 5 minimum_margin: float = 0.5 @@ -2689,11 +3747,20 @@ def __call__(self): return "tDOTF0:USTF0" -DOTF0_USTF0 = DOTF0_USTF0() +DOTUSD = DOTUSD() @dataclass(slots=True, frozen=True) class DOTUSD: + """ + name: tDOTUSD + precision: 5 + minimum_margin: 15.0 + initial_margin: 30.0 + minimum_order_size: 0.2 + maximum_order_size: 50000.0 + margin: True + """ name: str = "tDOTUSD" precision: int = 5 minimum_margin: float = 15.0 @@ -2712,11 +3779,20 @@ def __call__(self): return "tDOTUSD" -DOTUSD = DOTUSD() +DOTUST = DOTUST() @dataclass(slots=True, frozen=True) class DOTUST: + """ + name: tDOTUST + precision: 5 + minimum_margin: 15.0 + initial_margin: 30.0 + minimum_order_size: 0.2 + maximum_order_size: 50000.0 + margin: True + """ name: str = "tDOTUST" precision: int = 5 minimum_margin: float = 15.0 @@ -2735,11 +3811,20 @@ def __call__(self): return "tDOTUST" -DOTUST = DOTUST() +DSHBTC = DSHBTC() @dataclass(slots=True, frozen=True) class DSHBTC: + """ + name: tDSHBTC + precision: 5 + minimum_margin: 15.0 + initial_margin: 30.0 + minimum_order_size: 0.04 + maximum_order_size: 5000.0 + margin: True + """ name: str = "tDSHBTC" precision: int = 5 minimum_margin: float = 15.0 @@ -2758,11 +3843,20 @@ def __call__(self): return "tDSHBTC" -DSHBTC = DSHBTC() +DSHUSD = DSHUSD() @dataclass(slots=True, frozen=True) class DSHUSD: + """ + name: tDSHUSD + precision: 5 + minimum_margin: 15.0 + initial_margin: 30.0 + minimum_order_size: 0.04 + maximum_order_size: 5000.0 + margin: True + """ name: str = "tDSHUSD" precision: int = 5 minimum_margin: float = 15.0 @@ -2781,11 +3875,20 @@ def __call__(self): return "tDSHUSD" -DSHUSD = DSHUSD() +DUSK_BTC = DUSK_BTC() @dataclass(slots=True, frozen=True) class DUSK_BTC: + """ + name: tDUSK:BTC + precision: 5 + minimum_margin: 15.0 + initial_margin: 30.0 + minimum_order_size: 18.0 + maximum_order_size: 100000.0 + margin: False + """ name: str = "tDUSK:BTC" precision: int = 5 minimum_margin: float = 15.0 @@ -2804,11 +3907,20 @@ def __call__(self): return "tDUSK:BTC" -DUSK_BTC = DUSK_BTC() +DUSK_USD = DUSK_USD() @dataclass(slots=True, frozen=True) class DUSK_USD: + """ + name: tDUSK:USD + precision: 5 + minimum_margin: 15.0 + initial_margin: 30.0 + minimum_order_size: 18.0 + maximum_order_size: 100000.0 + margin: False + """ name: str = "tDUSK:USD" precision: int = 5 minimum_margin: float = 15.0 @@ -2827,11 +3939,20 @@ def __call__(self): return "tDUSK:USD" -DUSK_USD = DUSK_USD() +DVFUSD = DVFUSD() @dataclass(slots=True, frozen=True) class DVFUSD: + """ + name: tDVFUSD + precision: 5 + minimum_margin: 15.0 + initial_margin: 30.0 + minimum_order_size: 1.0 + maximum_order_size: 50000.0 + margin: False + """ name: str = "tDVFUSD" precision: int = 5 minimum_margin: float = 15.0 @@ -2850,11 +3971,20 @@ def __call__(self): return "tDVFUSD" -DVFUSD = DVFUSD() +EDOUSD = EDOUSD() @dataclass(slots=True, frozen=True) class EDOUSD: + """ + name: tEDOUSD + precision: 5 + minimum_margin: 15.0 + initial_margin: 30.0 + minimum_order_size: 8.0 + maximum_order_size: 50000.0 + margin: True + """ name: str = "tEDOUSD" precision: int = 5 minimum_margin: float = 15.0 @@ -2873,11 +4003,20 @@ def __call__(self): return "tEDOUSD" -EDOUSD = EDOUSD() +EGLD_USD = EGLD_USD() @dataclass(slots=True, frozen=True) class EGLD_USD: + """ + name: tEGLD:USD + precision: 5 + minimum_margin: 15.0 + initial_margin: 30.0 + minimum_order_size: 0.02 + maximum_order_size: 5000.0 + margin: True + """ name: str = "tEGLD:USD" precision: int = 5 minimum_margin: float = 15.0 @@ -2896,11 +4035,20 @@ def __call__(self): return "tEGLD:USD" -EGLD_USD = EGLD_USD() +EGLD_UST = EGLD_UST() @dataclass(slots=True, frozen=True) class EGLD_UST: + """ + name: tEGLD:UST + precision: 5 + minimum_margin: 15.0 + initial_margin: 30.0 + minimum_order_size: 0.02 + maximum_order_size: 5000.0 + margin: True + """ name: str = "tEGLD:UST" precision: int = 5 minimum_margin: float = 15.0 @@ -2919,11 +4067,20 @@ def __call__(self): return "tEGLD:UST" -EGLD_UST = EGLD_UST() +EGLDF0_USTF0 = EGLDF0_USTF0() @dataclass(slots=True, frozen=True) class EGLDF0_USTF0: + """ + name: tEGLDF0:USTF0 + precision: 5 + minimum_margin: 0.5 + initial_margin: 1.0 + minimum_order_size: 0.02 + maximum_order_size: 5000.0 + margin: True + """ name: str = "tEGLDF0:USTF0" precision: int = 5 minimum_margin: float = 0.5 @@ -2942,11 +4099,20 @@ def __call__(self): return "tEGLDF0:USTF0" -EGLDF0_USTF0 = EGLDF0_USTF0() +ENJUSD = ENJUSD() @dataclass(slots=True, frozen=True) class ENJUSD: + """ + name: tENJUSD + precision: 5 + minimum_margin: 15.0 + initial_margin: 30.0 + minimum_order_size: 4.0 + maximum_order_size: 500000.0 + margin: False + """ name: str = "tENJUSD" precision: int = 5 minimum_margin: float = 15.0 @@ -2965,11 +4131,20 @@ def __call__(self): return "tENJUSD" -ENJUSD = ENJUSD() +EOSBTC = EOSBTC() @dataclass(slots=True, frozen=True) class EOSBTC: + """ + name: tEOSBTC + precision: 5 + minimum_margin: 15.0 + initial_margin: 30.0 + minimum_order_size: 2.0 + maximum_order_size: 50000.0 + margin: True + """ name: str = "tEOSBTC" precision: int = 5 minimum_margin: float = 15.0 @@ -2988,11 +4163,20 @@ def __call__(self): return "tEOSBTC" -EOSBTC = EOSBTC() +EOSETH = EOSETH() @dataclass(slots=True, frozen=True) class EOSETH: + """ + name: tEOSETH + precision: 5 + minimum_margin: 15.0 + initial_margin: 30.0 + minimum_order_size: 2.0 + maximum_order_size: 50000.0 + margin: True + """ name: str = "tEOSETH" precision: int = 5 minimum_margin: float = 15.0 @@ -3011,11 +4195,20 @@ def __call__(self): return "tEOSETH" -EOSETH = EOSETH() +EOSEUR = EOSEUR() @dataclass(slots=True, frozen=True) class EOSEUR: + """ + name: tEOSEUR + precision: 5 + minimum_margin: 15.0 + initial_margin: 30.0 + minimum_order_size: 2.0 + maximum_order_size: 50000.0 + margin: True + """ name: str = "tEOSEUR" precision: int = 5 minimum_margin: float = 15.0 @@ -3034,11 +4227,20 @@ def __call__(self): return "tEOSEUR" -EOSEUR = EOSEUR() +EOSF0_USTF0 = EOSF0_USTF0() @dataclass(slots=True, frozen=True) class EOSF0_USTF0: + """ + name: tEOSF0:USTF0 + precision: 5 + minimum_margin: 0.5 + initial_margin: 1.0 + minimum_order_size: 2.0 + maximum_order_size: 250000.0 + margin: True + """ name: str = "tEOSF0:USTF0" precision: int = 5 minimum_margin: float = 0.5 @@ -3057,11 +4259,20 @@ def __call__(self): return "tEOSF0:USTF0" -EOSF0_USTF0 = EOSF0_USTF0() +EOSUSD = EOSUSD() @dataclass(slots=True, frozen=True) class EOSUSD: + """ + name: tEOSUSD + precision: 5 + minimum_margin: 10.0 + initial_margin: 20.0 + minimum_order_size: 2.0 + maximum_order_size: 50000.0 + margin: True + """ name: str = "tEOSUSD" precision: int = 5 minimum_margin: float = 10.0 @@ -3080,11 +4291,20 @@ def __call__(self): return "tEOSUSD" -EOSUSD = EOSUSD() +EOSUST = EOSUST() @dataclass(slots=True, frozen=True) class EOSUST: + """ + name: tEOSUST + precision: 5 + minimum_margin: 10.0 + initial_margin: 20.0 + minimum_order_size: 2.0 + maximum_order_size: 50000.0 + margin: True + """ name: str = "tEOSUST" precision: int = 5 minimum_margin: float = 10.0 @@ -3103,11 +4323,20 @@ def __call__(self): return "tEOSUST" -EOSUST = EOSUST() +ETCBTC = ETCBTC() @dataclass(slots=True, frozen=True) class ETCBTC: + """ + name: tETCBTC + precision: 5 + minimum_margin: 15.0 + initial_margin: 30.0 + minimum_order_size: 0.1 + maximum_order_size: 100000.0 + margin: True + """ name: str = "tETCBTC" precision: int = 5 minimum_margin: float = 15.0 @@ -3126,11 +4355,20 @@ def __call__(self): return "tETCBTC" -ETCBTC = ETCBTC() +ETCF0_USTF0 = ETCF0_USTF0() @dataclass(slots=True, frozen=True) class ETCF0_USTF0: + """ + name: tETCF0:USTF0 + precision: 5 + minimum_margin: 0.5 + initial_margin: 1.0 + minimum_order_size: 0.1 + maximum_order_size: 100000.0 + margin: True + """ name: str = "tETCF0:USTF0" precision: int = 5 minimum_margin: float = 0.5 @@ -3149,11 +4387,20 @@ def __call__(self): return "tETCF0:USTF0" -ETCF0_USTF0 = ETCF0_USTF0() +ETCUSD = ETCUSD() @dataclass(slots=True, frozen=True) class ETCUSD: + """ + name: tETCUSD + precision: 5 + minimum_margin: 15.0 + initial_margin: 30.0 + minimum_order_size: 0.1 + maximum_order_size: 100000.0 + margin: True + """ name: str = "tETCUSD" precision: int = 5 minimum_margin: float = 15.0 @@ -3172,11 +4419,20 @@ def __call__(self): return "tETCUSD" -ETCUSD = ETCUSD() +ETCUST = ETCUST() @dataclass(slots=True, frozen=True) class ETCUST: + """ + name: tETCUST + precision: 5 + minimum_margin: 15.0 + initial_margin: 30.0 + minimum_order_size: 0.1 + maximum_order_size: 100000.0 + margin: True + """ name: str = "tETCUST" precision: int = 5 minimum_margin: float = 15.0 @@ -3195,11 +4451,20 @@ def __call__(self): return "tETCUST" -ETCUST = ETCUST() +ETH2X_ETH = ETH2X_ETH() @dataclass(slots=True, frozen=True) class ETH2X_ETH: + """ + name: tETH2X:ETH + precision: 5 + minimum_margin: 15.0 + initial_margin: 30.0 + minimum_order_size: 0.002 + maximum_order_size: 5000.0 + margin: False + """ name: str = "tETH2X:ETH" precision: int = 5 minimum_margin: float = 15.0 @@ -3218,11 +4483,20 @@ def __call__(self): return "tETH2X:ETH" -ETH2X_ETH = ETH2X_ETH() +ETH2X_USD = ETH2X_USD() @dataclass(slots=True, frozen=True) class ETH2X_USD: + """ + name: tETH2X:USD + precision: 5 + minimum_margin: 15.0 + initial_margin: 30.0 + minimum_order_size: 0.002 + maximum_order_size: 5000.0 + margin: False + """ name: str = "tETH2X:USD" precision: int = 5 minimum_margin: float = 15.0 @@ -3241,11 +4515,20 @@ def __call__(self): return "tETH2X:USD" -ETH2X_USD = ETH2X_USD() +ETH2X_UST = ETH2X_UST() @dataclass(slots=True, frozen=True) class ETH2X_UST: + """ + name: tETH2X:UST + precision: 5 + minimum_margin: 15.0 + initial_margin: 30.0 + minimum_order_size: 0.002 + maximum_order_size: 5000.0 + margin: False + """ name: str = "tETH2X:UST" precision: int = 5 minimum_margin: float = 15.0 @@ -3264,11 +4547,20 @@ def __call__(self): return "tETH2X:UST" -ETH2X_UST = ETH2X_UST() +ETH_MXNT = ETH_MXNT() @dataclass(slots=True, frozen=True) class ETH_MXNT: + """ + name: tETH:MXNT + precision: 5 + minimum_margin: 15.0 + initial_margin: 30.0 + minimum_order_size: 0.001 + maximum_order_size: 2000.0 + margin: False + """ name: str = "tETH:MXNT" precision: int = 5 minimum_margin: float = 15.0 @@ -3287,11 +4579,20 @@ def __call__(self): return "tETH:MXNT" -ETH_MXNT = ETH_MXNT() +ETH_XAUT = ETH_XAUT() @dataclass(slots=True, frozen=True) class ETH_XAUT: + """ + name: tETH:XAUT + precision: 5 + minimum_margin: 15.0 + initial_margin: 30.0 + minimum_order_size: 0.002 + maximum_order_size: 2500.0 + margin: False + """ name: str = "tETH:XAUT" precision: int = 5 minimum_margin: float = 15.0 @@ -3310,11 +4611,20 @@ def __call__(self): return "tETH:XAUT" -ETH_XAUT = ETH_XAUT() +ETHBTC = ETHBTC() @dataclass(slots=True, frozen=True) class ETHBTC: + """ + name: tETHBTC + precision: 5 + minimum_margin: 10.0 + initial_margin: 20.0 + minimum_order_size: 0.002 + maximum_order_size: 5000.0 + margin: True + """ name: str = "tETHBTC" precision: int = 5 minimum_margin: float = 10.0 @@ -3333,11 +4643,20 @@ def __call__(self): return "tETHBTC" -ETHBTC = ETHBTC() +ETHEUR = ETHEUR() @dataclass(slots=True, frozen=True) class ETHEUR: + """ + name: tETHEUR + precision: 5 + minimum_margin: 15.0 + initial_margin: 30.0 + minimum_order_size: 0.002 + maximum_order_size: 5000.0 + margin: True + """ name: str = "tETHEUR" precision: int = 5 minimum_margin: float = 15.0 @@ -3356,11 +4675,20 @@ def __call__(self): return "tETHEUR" -ETHEUR = ETHEUR() +ETHEUT = ETHEUT() @dataclass(slots=True, frozen=True) class ETHEUT: + """ + name: tETHEUT + precision: 5 + minimum_margin: 15.0 + initial_margin: 30.0 + minimum_order_size: 0.002 + maximum_order_size: 2000.0 + margin: True + """ name: str = "tETHEUT" precision: int = 5 minimum_margin: float = 15.0 @@ -3379,11 +4707,20 @@ def __call__(self): return "tETHEUT" -ETHEUT = ETHEUT() +ETHF0_BTCF0 = ETHF0_BTCF0() @dataclass(slots=True, frozen=True) class ETHF0_BTCF0: + """ + name: tETHF0:BTCF0 + precision: 5 + minimum_margin: 0.5 + initial_margin: 1.0 + minimum_order_size: 0.002 + maximum_order_size: 100.0 + margin: True + """ name: str = "tETHF0:BTCF0" precision: int = 5 minimum_margin: float = 0.5 @@ -3402,11 +4739,20 @@ def __call__(self): return "tETHF0:BTCF0" -ETHF0_BTCF0 = ETHF0_BTCF0() +ETHF0_EUTF0 = ETHF0_EUTF0() @dataclass(slots=True, frozen=True) class ETHF0_EUTF0: + """ + name: tETHF0:EUTF0 + precision: 5 + minimum_margin: 0.5 + initial_margin: 1.0 + minimum_order_size: 0.002 + maximum_order_size: 5000.0 + margin: True + """ name: str = "tETHF0:EUTF0" precision: int = 5 minimum_margin: float = 0.5 @@ -3425,11 +4771,20 @@ def __call__(self): return "tETHF0:EUTF0" -ETHF0_EUTF0 = ETHF0_EUTF0() +ETHF0_USTF0 = ETHF0_USTF0() @dataclass(slots=True, frozen=True) class ETHF0_USTF0: + """ + name: tETHF0:USTF0 + precision: 5 + minimum_margin: 0.5 + initial_margin: 1.0 + minimum_order_size: 0.002 + maximum_order_size: 1000.0 + margin: True + """ name: str = "tETHF0:USTF0" precision: int = 5 minimum_margin: float = 0.5 @@ -3448,11 +4803,20 @@ def __call__(self): return "tETHF0:USTF0" -ETHF0_USTF0 = ETHF0_USTF0() +ETHGBP = ETHGBP() @dataclass(slots=True, frozen=True) class ETHGBP: + """ + name: tETHGBP + precision: 5 + minimum_margin: 15.0 + initial_margin: 30.0 + minimum_order_size: 0.002 + maximum_order_size: 5000.0 + margin: True + """ name: str = "tETHGBP" precision: int = 5 minimum_margin: float = 15.0 @@ -3471,11 +4835,20 @@ def __call__(self): return "tETHGBP" -ETHGBP = ETHGBP() +ETHJPY = ETHJPY() @dataclass(slots=True, frozen=True) class ETHJPY: + """ + name: tETHJPY + precision: 5 + minimum_margin: 15.0 + initial_margin: 30.0 + minimum_order_size: 0.002 + maximum_order_size: 5000.0 + margin: True + """ name: str = "tETHJPY" precision: int = 5 minimum_margin: float = 15.0 @@ -3494,11 +4867,20 @@ def __call__(self): return "tETHJPY" -ETHJPY = ETHJPY() +ETHUSD = ETHUSD() @dataclass(slots=True, frozen=True) class ETHUSD: + """ + name: tETHUSD + precision: 5 + minimum_margin: 10.0 + initial_margin: 20.0 + minimum_order_size: 0.002 + maximum_order_size: 5000.0 + margin: True + """ name: str = "tETHUSD" precision: int = 5 minimum_margin: float = 10.0 @@ -3517,11 +4899,20 @@ def __call__(self): return "tETHUSD" -ETHUSD = ETHUSD() +ETHUST = ETHUST() @dataclass(slots=True, frozen=True) class ETHUST: + """ + name: tETHUST + precision: 5 + minimum_margin: 10.0 + initial_margin: 20.0 + minimum_order_size: 0.002 + maximum_order_size: 2000.0 + margin: True + """ name: str = "tETHUST" precision: int = 5 minimum_margin: float = 10.0 @@ -3540,11 +4931,20 @@ def __call__(self): return "tETHUST" -ETHUST = ETHUST() +ETHW_USD = ETHW_USD() @dataclass(slots=True, frozen=True) class ETHW_USD: + """ + name: tETHW:USD + precision: 5 + minimum_margin: 30.0 + initial_margin: 60.0 + minimum_order_size: 0.001 + maximum_order_size: 50000.0 + margin: True + """ name: str = "tETHW:USD" precision: int = 5 minimum_margin: float = 30.0 @@ -3563,11 +4963,20 @@ def __call__(self): return "tETHW:USD" -ETHW_USD = ETHW_USD() +ETHW_UST = ETHW_UST() @dataclass(slots=True, frozen=True) class ETHW_UST: + """ + name: tETHW:UST + precision: 5 + minimum_margin: 30.0 + initial_margin: 60.0 + minimum_order_size: 0.001 + maximum_order_size: 50000.0 + margin: True + """ name: str = "tETHW:UST" precision: int = 5 minimum_margin: float = 30.0 @@ -3586,11 +4995,20 @@ def __call__(self): return "tETHW:UST" -ETHW_UST = ETHW_UST() +ETPUSD = ETPUSD() @dataclass(slots=True, frozen=True) class ETPUSD: + """ + name: tETPUSD + precision: 5 + minimum_margin: 15.0 + initial_margin: 30.0 + minimum_order_size: 42.0 + maximum_order_size: 250000.0 + margin: False + """ name: str = "tETPUSD" precision: int = 5 minimum_margin: float = 15.0 @@ -3609,11 +5027,20 @@ def __call__(self): return "tETPUSD" -ETPUSD = ETPUSD() +EURF0_USTF0 = EURF0_USTF0() @dataclass(slots=True, frozen=True) class EURF0_USTF0: + """ + name: tEURF0:USTF0 + precision: 5 + minimum_margin: 0.5 + initial_margin: 1.0 + minimum_order_size: 2.0 + maximum_order_size: 250000.0 + margin: True + """ name: str = "tEURF0:USTF0" precision: int = 5 minimum_margin: float = 0.5 @@ -3632,11 +5059,20 @@ def __call__(self): return "tEURF0:USTF0" -EURF0_USTF0 = EURF0_USTF0() +EURUST = EURUST() @dataclass(slots=True, frozen=True) class EURUST: + """ + name: tEURUST + precision: 5 + minimum_margin: 15.0 + initial_margin: 30.0 + minimum_order_size: 2.0 + maximum_order_size: 1000000.0 + margin: False + """ name: str = "tEURUST" precision: int = 5 minimum_margin: float = 15.0 @@ -3655,11 +5091,20 @@ def __call__(self): return "tEURUST" -EURUST = EURUST() +EUSUSD = EUSUSD() @dataclass(slots=True, frozen=True) class EUSUSD: + """ + name: tEUSUSD + precision: 5 + minimum_margin: 15.0 + initial_margin: 30.0 + minimum_order_size: 2.0 + maximum_order_size: 250000.0 + margin: False + """ name: str = "tEUSUSD" precision: int = 5 minimum_margin: float = 15.0 @@ -3678,11 +5123,20 @@ def __call__(self): return "tEUSUSD" -EUSUSD = EUSUSD() +EUT_MXNT = EUT_MXNT() @dataclass(slots=True, frozen=True) class EUT_MXNT: + """ + name: tEUT:MXNT + precision: 5 + minimum_margin: 15.0 + initial_margin: 30.0 + minimum_order_size: 0.001 + maximum_order_size: 10000000.0 + margin: False + """ name: str = "tEUT:MXNT" precision: int = 5 minimum_margin: float = 15.0 @@ -3701,11 +5155,20 @@ def __call__(self): return "tEUT:MXNT" -EUT_MXNT = EUT_MXNT() +EUTEUR = EUTEUR() @dataclass(slots=True, frozen=True) class EUTEUR: + """ + name: tEUTEUR + precision: 5 + minimum_margin: 15.0 + initial_margin: 30.0 + minimum_order_size: 2.0 + maximum_order_size: 100000.0 + margin: False + """ name: str = "tEUTEUR" precision: int = 5 minimum_margin: float = 15.0 @@ -3724,11 +5187,20 @@ def __call__(self): return "tEUTEUR" -EUTEUR = EUTEUR() +EUTUSD = EUTUSD() @dataclass(slots=True, frozen=True) class EUTUSD: + """ + name: tEUTUSD + precision: 5 + minimum_margin: 15.0 + initial_margin: 30.0 + minimum_order_size: 2.0 + maximum_order_size: 100000.0 + margin: False + """ name: str = "tEUTUSD" precision: int = 5 minimum_margin: float = 15.0 @@ -3747,11 +5219,20 @@ def __call__(self): return "tEUTUSD" -EUTUSD = EUTUSD() +EUTUST = EUTUST() @dataclass(slots=True, frozen=True) class EUTUST: + """ + name: tEUTUST + precision: 5 + minimum_margin: 15.0 + initial_margin: 30.0 + minimum_order_size: 2.0 + maximum_order_size: 100000.0 + margin: False + """ name: str = "tEUTUST" precision: int = 5 minimum_margin: float = 15.0 @@ -3770,11 +5251,20 @@ def __call__(self): return "tEUTUST" -EUTUST = EUTUST() +EXOUSD = EXOUSD() @dataclass(slots=True, frozen=True) class EXOUSD: + """ + name: tEXOUSD + precision: 5 + minimum_margin: 15.0 + initial_margin: 30.0 + minimum_order_size: 2.0 + maximum_order_size: 10000.0 + margin: False + """ name: str = "tEXOUSD" precision: int = 5 minimum_margin: float = 15.0 @@ -3793,11 +5283,20 @@ def __call__(self): return "tEXOUSD" -EXOUSD = EXOUSD() +FBTUSD = FBTUSD() @dataclass(slots=True, frozen=True) class FBTUSD: + """ + name: tFBTUSD + precision: 5 + minimum_margin: 15.0 + initial_margin: 30.0 + minimum_order_size: 0.001 + maximum_order_size: 100000.0 + margin: False + """ name: str = "tFBTUSD" precision: int = 5 minimum_margin: float = 15.0 @@ -3816,11 +5315,20 @@ def __call__(self): return "tFBTUSD" -FBTUSD = FBTUSD() +FBTUST = FBTUST() @dataclass(slots=True, frozen=True) class FBTUST: + """ + name: tFBTUST + precision: 5 + minimum_margin: 15.0 + initial_margin: 30.0 + minimum_order_size: 0.001 + maximum_order_size: 100000.0 + margin: False + """ name: str = "tFBTUST" precision: int = 5 minimum_margin: float = 15.0 @@ -3839,11 +5347,20 @@ def __call__(self): return "tFBTUST" -FBTUST = FBTUST() +FCLUSD = FCLUSD() @dataclass(slots=True, frozen=True) class FCLUSD: + """ + name: tFCLUSD + precision: 5 + minimum_margin: 15.0 + initial_margin: 30.0 + minimum_order_size: 62.0 + maximum_order_size: 1000000.0 + margin: False + """ name: str = "tFCLUSD" precision: int = 5 minimum_margin: float = 15.0 @@ -3862,11 +5379,20 @@ def __call__(self): return "tFCLUSD" -FCLUSD = FCLUSD() +FCLUST = FCLUST() @dataclass(slots=True, frozen=True) class FCLUST: + """ + name: tFCLUST + precision: 5 + minimum_margin: 15.0 + initial_margin: 30.0 + minimum_order_size: 62.0 + maximum_order_size: 1000000.0 + margin: False + """ name: str = "tFCLUST" precision: int = 5 minimum_margin: float = 15.0 @@ -3885,11 +5411,20 @@ def __call__(self): return "tFCLUST" -FCLUST = FCLUST() +FETUSD = FETUSD() @dataclass(slots=True, frozen=True) class FETUSD: + """ + name: tFETUSD + precision: 5 + minimum_margin: 15.0 + initial_margin: 30.0 + minimum_order_size: 14.0 + maximum_order_size: 250000.0 + margin: False + """ name: str = "tFETUSD" precision: int = 5 minimum_margin: float = 15.0 @@ -3908,11 +5443,20 @@ def __call__(self): return "tFETUSD" -FETUSD = FETUSD() +FETUST = FETUST() @dataclass(slots=True, frozen=True) class FETUST: + """ + name: tFETUST + precision: 5 + minimum_margin: 15.0 + initial_margin: 30.0 + minimum_order_size: 14.0 + maximum_order_size: 250000.0 + margin: False + """ name: str = "tFETUST" precision: int = 5 minimum_margin: float = 15.0 @@ -3931,11 +5475,20 @@ def __call__(self): return "tFETUST" -FETUST = FETUST() +FILF0_USTF0 = FILF0_USTF0() @dataclass(slots=True, frozen=True) class FILF0_USTF0: + """ + name: tFILF0:USTF0 + precision: 5 + minimum_margin: 0.5 + initial_margin: 1.0 + minimum_order_size: 0.2 + maximum_order_size: 10000.0 + margin: True + """ name: str = "tFILF0:USTF0" precision: int = 5 minimum_margin: float = 0.5 @@ -3954,11 +5507,20 @@ def __call__(self): return "tFILF0:USTF0" -FILF0_USTF0 = FILF0_USTF0() +FILUSD = FILUSD() @dataclass(slots=True, frozen=True) class FILUSD: + """ + name: tFILUSD + precision: 5 + minimum_margin: 15.0 + initial_margin: 30.0 + minimum_order_size: 0.2 + maximum_order_size: 10000.0 + margin: True + """ name: str = "tFILUSD" precision: int = 5 minimum_margin: float = 15.0 @@ -3977,11 +5539,20 @@ def __call__(self): return "tFILUSD" -FILUSD = FILUSD() +FILUST = FILUST() @dataclass(slots=True, frozen=True) class FILUST: + """ + name: tFILUST + precision: 5 + minimum_margin: 15.0 + initial_margin: 30.0 + minimum_order_size: 0.2 + maximum_order_size: 10000.0 + margin: True + """ name: str = "tFILUST" precision: int = 5 minimum_margin: float = 15.0 @@ -4000,11 +5571,20 @@ def __call__(self): return "tFILUST" -FILUST = FILUST() +FLRUSD = FLRUSD() @dataclass(slots=True, frozen=True) class FLRUSD: + """ + name: tFLRUSD + precision: 5 + minimum_margin: 15.0 + initial_margin: 30.0 + minimum_order_size: 0.001 + maximum_order_size: 1000000.0 + margin: False + """ name: str = "tFLRUSD" precision: int = 5 minimum_margin: float = 15.0 @@ -4023,11 +5603,20 @@ def __call__(self): return "tFLRUSD" -FLRUSD = FLRUSD() +FLRUST = FLRUST() @dataclass(slots=True, frozen=True) class FLRUST: + """ + name: tFLRUST + precision: 5 + minimum_margin: 15.0 + initial_margin: 30.0 + minimum_order_size: 0.001 + maximum_order_size: 1000000.0 + margin: False + """ name: str = "tFLRUST" precision: int = 5 minimum_margin: float = 15.0 @@ -4046,11 +5635,20 @@ def __call__(self): return "tFLRUST" -FLRUST = FLRUST() +FORTH_USD = FORTH_USD() @dataclass(slots=True, frozen=True) class FORTH_USD: + """ + name: tFORTH:USD + precision: 5 + minimum_margin: 15.0 + initial_margin: 30.0 + minimum_order_size: 0.6 + maximum_order_size: 100000.0 + margin: False + """ name: str = "tFORTH:USD" precision: int = 5 minimum_margin: float = 15.0 @@ -4069,11 +5667,20 @@ def __call__(self): return "tFORTH:USD" -FORTH_USD = FORTH_USD() +FORTH_UST = FORTH_UST() @dataclass(slots=True, frozen=True) class FORTH_UST: + """ + name: tFORTH:UST + precision: 5 + minimum_margin: 15.0 + initial_margin: 30.0 + minimum_order_size: 0.6 + maximum_order_size: 100000.0 + margin: False + """ name: str = "tFORTH:UST" precision: int = 5 minimum_margin: float = 15.0 @@ -4092,11 +5699,20 @@ def __call__(self): return "tFORTH:UST" -FORTH_UST = FORTH_UST() +FTMF0_USTF0 = FTMF0_USTF0() @dataclass(slots=True, frozen=True) class FTMF0_USTF0: + """ + name: tFTMF0:USTF0 + precision: 5 + minimum_margin: 0.5 + initial_margin: 1.0 + minimum_order_size: 6.0 + maximum_order_size: 250000.0 + margin: True + """ name: str = "tFTMF0:USTF0" precision: int = 5 minimum_margin: float = 0.5 @@ -4115,11 +5731,20 @@ def __call__(self): return "tFTMF0:USTF0" -FTMF0_USTF0 = FTMF0_USTF0() +FTMUSD = FTMUSD() @dataclass(slots=True, frozen=True) class FTMUSD: + """ + name: tFTMUSD + precision: 5 + minimum_margin: 15.0 + initial_margin: 30.0 + minimum_order_size: 6.0 + maximum_order_size: 250000.0 + margin: True + """ name: str = "tFTMUSD" precision: int = 5 minimum_margin: float = 15.0 @@ -4138,11 +5763,20 @@ def __call__(self): return "tFTMUSD" -FTMUSD = FTMUSD() +FTMUST = FTMUST() @dataclass(slots=True, frozen=True) class FTMUST: + """ + name: tFTMUST + precision: 5 + minimum_margin: 15.0 + initial_margin: 30.0 + minimum_order_size: 6.0 + maximum_order_size: 250000.0 + margin: True + """ name: str = "tFTMUST" precision: int = 5 minimum_margin: float = 15.0 @@ -4161,11 +5795,20 @@ def __call__(self): return "tFTMUST" -FTMUST = FTMUST() +FUNUSD = FUNUSD() @dataclass(slots=True, frozen=True) class FUNUSD: + """ + name: tFUNUSD + precision: 5 + minimum_margin: 15.0 + initial_margin: 30.0 + minimum_order_size: 226.0 + maximum_order_size: 5000000.0 + margin: False + """ name: str = "tFUNUSD" precision: int = 5 minimum_margin: float = 15.0 @@ -4184,11 +5827,20 @@ def __call__(self): return "tFUNUSD" -FUNUSD = FUNUSD() +GALA_USD = GALA_USD() @dataclass(slots=True, frozen=True) class GALA_USD: + """ + name: tGALA:USD + precision: 5 + minimum_margin: 15.0 + initial_margin: 30.0 + minimum_order_size: 26.0 + maximum_order_size: 500000.0 + margin: False + """ name: str = "tGALA:USD" precision: int = 5 minimum_margin: float = 15.0 @@ -4207,11 +5859,20 @@ def __call__(self): return "tGALA:USD" -GALA_USD = GALA_USD() +GALA_UST = GALA_UST() @dataclass(slots=True, frozen=True) class GALA_UST: + """ + name: tGALA:UST + precision: 5 + minimum_margin: 15.0 + initial_margin: 30.0 + minimum_order_size: 26.0 + maximum_order_size: 500000.0 + margin: False + """ name: str = "tGALA:UST" precision: int = 5 minimum_margin: float = 15.0 @@ -4230,11 +5891,20 @@ def __call__(self): return "tGALA:UST" -GALA_UST = GALA_UST() +GALAF0_USTF0 = GALAF0_USTF0() @dataclass(slots=True, frozen=True) class GALAF0_USTF0: + """ + name: tGALAF0:USTF0 + precision: 5 + minimum_margin: 0.5 + initial_margin: 1.0 + minimum_order_size: 26.0 + maximum_order_size: 500000.0 + margin: True + """ name: str = "tGALAF0:USTF0" precision: int = 5 minimum_margin: float = 0.5 @@ -4253,11 +5923,20 @@ def __call__(self): return "tGALAF0:USTF0" -GALAF0_USTF0 = GALAF0_USTF0() +GBPEUT = GBPEUT() @dataclass(slots=True, frozen=True) class GBPEUT: + """ + name: tGBPEUT + precision: 5 + minimum_margin: 15.0 + initial_margin: 30.0 + minimum_order_size: 2.0 + maximum_order_size: 500000.0 + margin: False + """ name: str = "tGBPEUT" precision: int = 5 minimum_margin: float = 15.0 @@ -4276,11 +5955,20 @@ def __call__(self): return "tGBPEUT" -GBPEUT = GBPEUT() +GBPF0_USTF0 = GBPF0_USTF0() @dataclass(slots=True, frozen=True) class GBPF0_USTF0: + """ + name: tGBPF0:USTF0 + precision: 5 + minimum_margin: 0.5 + initial_margin: 1.0 + minimum_order_size: 2.0 + maximum_order_size: 250000.0 + margin: True + """ name: str = "tGBPF0:USTF0" precision: int = 5 minimum_margin: float = 0.5 @@ -4299,11 +5987,20 @@ def __call__(self): return "tGBPF0:USTF0" -GBPF0_USTF0 = GBPF0_USTF0() +GBPUST = GBPUST() @dataclass(slots=True, frozen=True) class GBPUST: + """ + name: tGBPUST + precision: 5 + minimum_margin: 15.0 + initial_margin: 30.0 + minimum_order_size: 2.0 + maximum_order_size: 500000.0 + margin: False + """ name: str = "tGBPUST" precision: int = 5 minimum_margin: float = 15.0 @@ -4322,11 +6019,20 @@ def __call__(self): return "tGBPUST" -GBPUST = GBPUST() +GNOUSD = GNOUSD() @dataclass(slots=True, frozen=True) class GNOUSD: + """ + name: tGNOUSD + precision: 5 + minimum_margin: 15.0 + initial_margin: 30.0 + minimum_order_size: 0.02 + maximum_order_size: 1000.0 + margin: False + """ name: str = "tGNOUSD" precision: int = 5 minimum_margin: float = 15.0 @@ -4345,11 +6051,20 @@ def __call__(self): return "tGNOUSD" -GNOUSD = GNOUSD() +GNTUSD = GNTUSD() @dataclass(slots=True, frozen=True) class GNTUSD: + """ + name: tGNTUSD + precision: 5 + minimum_margin: 15.0 + initial_margin: 30.0 + minimum_order_size: 6.0 + maximum_order_size: 250000.0 + margin: False + """ name: str = "tGNTUSD" precision: int = 5 minimum_margin: float = 15.0 @@ -4368,11 +6083,20 @@ def __call__(self): return "tGNTUSD" -GNTUSD = GNTUSD() +GRTUSD = GRTUSD() @dataclass(slots=True, frozen=True) class GRTUSD: + """ + name: tGRTUSD + precision: 5 + minimum_margin: 15.0 + initial_margin: 30.0 + minimum_order_size: 14.0 + maximum_order_size: 100000.0 + margin: False + """ name: str = "tGRTUSD" precision: int = 5 minimum_margin: float = 15.0 @@ -4391,11 +6115,20 @@ def __call__(self): return "tGRTUSD" -GRTUSD = GRTUSD() +GRTUST = GRTUST() @dataclass(slots=True, frozen=True) class GRTUST: + """ + name: tGRTUST + precision: 5 + minimum_margin: 15.0 + initial_margin: 30.0 + minimum_order_size: 14.0 + maximum_order_size: 100000.0 + margin: False + """ name: str = "tGRTUST" precision: int = 5 minimum_margin: float = 15.0 @@ -4414,11 +6147,20 @@ def __call__(self): return "tGRTUST" -GRTUST = GRTUST() +GTXUSD = GTXUSD() @dataclass(slots=True, frozen=True) class GTXUSD: + """ + name: tGTXUSD + precision: 5 + minimum_margin: 15.0 + initial_margin: 30.0 + minimum_order_size: 0.6 + maximum_order_size: 10000.0 + margin: False + """ name: str = "tGTXUSD" precision: int = 5 minimum_margin: float = 15.0 @@ -4437,11 +6179,20 @@ def __call__(self): return "tGTXUSD" -GTXUSD = GTXUSD() +GTXUST = GTXUST() @dataclass(slots=True, frozen=True) class GTXUST: + """ + name: tGTXUST + precision: 5 + minimum_margin: 15.0 + initial_margin: 30.0 + minimum_order_size: 0.6 + maximum_order_size: 10000.0 + margin: False + """ name: str = "tGTXUST" precision: int = 5 minimum_margin: float = 15.0 @@ -4460,11 +6211,20 @@ def __call__(self): return "tGTXUST" -GTXUST = GTXUST() +GXTUSD = GXTUSD() @dataclass(slots=True, frozen=True) class GXTUSD: + """ + name: tGXTUSD + precision: 5 + minimum_margin: 15.0 + initial_margin: 30.0 + minimum_order_size: 0.001 + maximum_order_size: 500000.0 + margin: False + """ name: str = "tGXTUSD" precision: int = 5 minimum_margin: float = 15.0 @@ -4483,11 +6243,20 @@ def __call__(self): return "tGXTUSD" -GXTUSD = GXTUSD() +GXTUST = GXTUST() @dataclass(slots=True, frozen=True) class GXTUST: + """ + name: tGXTUST + precision: 5 + minimum_margin: 15.0 + initial_margin: 30.0 + minimum_order_size: 0.001 + maximum_order_size: 500000.0 + margin: False + """ name: str = "tGXTUST" precision: int = 5 minimum_margin: float = 15.0 @@ -4506,11 +6275,20 @@ def __call__(self): return "tGXTUST" -GXTUST = GXTUST() +HECUSD = HECUSD() @dataclass(slots=True, frozen=True) class HECUSD: + """ + name: tHECUSD + precision: 5 + minimum_margin: 15.0 + initial_margin: 30.0 + minimum_order_size: 0.001 + maximum_order_size: 10000.0 + margin: False + """ name: str = "tHECUSD" precision: int = 5 minimum_margin: float = 15.0 @@ -4529,11 +6307,20 @@ def __call__(self): return "tHECUSD" -HECUSD = HECUSD() +HECUST = HECUST() @dataclass(slots=True, frozen=True) class HECUST: + """ + name: tHECUST + precision: 5 + minimum_margin: 15.0 + initial_margin: 30.0 + minimum_order_size: 0.001 + maximum_order_size: 10000.0 + margin: False + """ name: str = "tHECUST" precision: int = 5 minimum_margin: float = 15.0 @@ -4552,11 +6339,20 @@ def __call__(self): return "tHECUST" -HECUST = HECUST() +HIXUSD = HIXUSD() @dataclass(slots=True, frozen=True) class HIXUSD: + """ + name: tHIXUSD + precision: 5 + minimum_margin: 15.0 + initial_margin: 30.0 + minimum_order_size: 18.0 + maximum_order_size: 500000.0 + margin: False + """ name: str = "tHIXUSD" precision: int = 5 minimum_margin: float = 15.0 @@ -4575,11 +6371,20 @@ def __call__(self): return "tHIXUSD" -HIXUSD = HIXUSD() +HIXUST = HIXUST() @dataclass(slots=True, frozen=True) class HIXUST: + """ + name: tHIXUST + precision: 5 + minimum_margin: 15.0 + initial_margin: 30.0 + minimum_order_size: 18.0 + maximum_order_size: 500000.0 + margin: False + """ name: str = "tHIXUST" precision: int = 5 minimum_margin: float = 15.0 @@ -4598,11 +6403,20 @@ def __call__(self): return "tHIXUST" -HIXUST = HIXUST() +HMTUSD = HMTUSD() @dataclass(slots=True, frozen=True) class HMTUSD: + """ + name: tHMTUSD + precision: 5 + minimum_margin: 15.0 + initial_margin: 30.0 + minimum_order_size: 8.0 + maximum_order_size: 100000.0 + margin: False + """ name: str = "tHMTUSD" precision: int = 5 minimum_margin: float = 15.0 @@ -4621,11 +6435,20 @@ def __call__(self): return "tHMTUSD" -HMTUSD = HMTUSD() +HMTUST = HMTUST() @dataclass(slots=True, frozen=True) class HMTUST: + """ + name: tHMTUST + precision: 5 + minimum_margin: 15.0 + initial_margin: 30.0 + minimum_order_size: 8.0 + maximum_order_size: 100000.0 + margin: False + """ name: str = "tHMTUST" precision: int = 5 minimum_margin: float = 15.0 @@ -4644,11 +6467,20 @@ def __call__(self): return "tHMTUST" -HMTUST = HMTUST() +HTXUSD = HTXUSD() @dataclass(slots=True, frozen=True) class HTXUSD: + """ + name: tHTXUSD + precision: 5 + minimum_margin: 15.0 + initial_margin: 30.0 + minimum_order_size: 0.001 + maximum_order_size: 100000.0 + margin: False + """ name: str = "tHTXUSD" precision: int = 5 minimum_margin: float = 15.0 @@ -4667,11 +6499,20 @@ def __call__(self): return "tHTXUSD" -HTXUSD = HTXUSD() +HTXUST = HTXUST() @dataclass(slots=True, frozen=True) class HTXUST: + """ + name: tHTXUST + precision: 5 + minimum_margin: 15.0 + initial_margin: 30.0 + minimum_order_size: 0.001 + maximum_order_size: 100000.0 + margin: False + """ name: str = "tHTXUST" precision: int = 5 minimum_margin: float = 15.0 @@ -4690,11 +6531,20 @@ def __call__(self): return "tHTXUST" -HTXUST = HTXUST() +ICEUSD = ICEUSD() @dataclass(slots=True, frozen=True) class ICEUSD: + """ + name: tICEUSD + precision: 5 + minimum_margin: 15.0 + initial_margin: 30.0 + minimum_order_size: 4.0 + maximum_order_size: 25000.0 + margin: False + """ name: str = "tICEUSD" precision: int = 5 minimum_margin: float = 15.0 @@ -4713,11 +6563,20 @@ def __call__(self): return "tICEUSD" -ICEUSD = ICEUSD() +ICPBTC = ICPBTC() @dataclass(slots=True, frozen=True) class ICPBTC: + """ + name: tICPBTC + precision: 5 + minimum_margin: 15.0 + initial_margin: 30.0 + minimum_order_size: 0.2 + maximum_order_size: 10000.0 + margin: False + """ name: str = "tICPBTC" precision: int = 5 minimum_margin: float = 15.0 @@ -4736,11 +6595,20 @@ def __call__(self): return "tICPBTC" -ICPBTC = ICPBTC() +ICPF0_USTF0 = ICPF0_USTF0() @dataclass(slots=True, frozen=True) class ICPF0_USTF0: + """ + name: tICPF0:USTF0 + precision: 5 + minimum_margin: 0.5 + initial_margin: 1.0 + minimum_order_size: 0.2 + maximum_order_size: 10000.0 + margin: True + """ name: str = "tICPF0:USTF0" precision: int = 5 minimum_margin: float = 0.5 @@ -4759,11 +6627,20 @@ def __call__(self): return "tICPF0:USTF0" -ICPF0_USTF0 = ICPF0_USTF0() +ICPUSD = ICPUSD() @dataclass(slots=True, frozen=True) class ICPUSD: + """ + name: tICPUSD + precision: 5 + minimum_margin: 15.0 + initial_margin: 30.0 + minimum_order_size: 0.2 + maximum_order_size: 10000.0 + margin: False + """ name: str = "tICPUSD" precision: int = 5 minimum_margin: float = 15.0 @@ -4782,11 +6659,20 @@ def __call__(self): return "tICPUSD" -ICPUSD = ICPUSD() +ICPUST = ICPUST() @dataclass(slots=True, frozen=True) class ICPUST: + """ + name: tICPUST + precision: 5 + minimum_margin: 15.0 + initial_margin: 30.0 + minimum_order_size: 0.2 + maximum_order_size: 10000.0 + margin: False + """ name: str = "tICPUST" precision: int = 5 minimum_margin: float = 15.0 @@ -4805,11 +6691,20 @@ def __call__(self): return "tICPUST" -ICPUST = ICPUST() +IDXUSD = IDXUSD() @dataclass(slots=True, frozen=True) class IDXUSD: + """ + name: tIDXUSD + precision: 5 + minimum_margin: 15.0 + initial_margin: 30.0 + minimum_order_size: 20.0 + maximum_order_size: 1000000.0 + margin: False + """ name: str = "tIDXUSD" precision: int = 5 minimum_margin: float = 15.0 @@ -4828,11 +6723,20 @@ def __call__(self): return "tIDXUSD" -IDXUSD = IDXUSD() +IDXUST = IDXUST() @dataclass(slots=True, frozen=True) class IDXUST: + """ + name: tIDXUST + precision: 5 + minimum_margin: 15.0 + initial_margin: 30.0 + minimum_order_size: 20.0 + maximum_order_size: 1000000.0 + margin: False + """ name: str = "tIDXUST" precision: int = 5 minimum_margin: float = 15.0 @@ -4851,11 +6755,20 @@ def __call__(self): return "tIDXUST" -IDXUST = IDXUST() +IOTBTC = IOTBTC() @dataclass(slots=True, frozen=True) class IOTBTC: + """ + name: tIOTBTC + precision: 5 + minimum_margin: 15.0 + initial_margin: 30.0 + minimum_order_size: 6.0 + maximum_order_size: 100000.0 + margin: True + """ name: str = "tIOTBTC" precision: int = 5 minimum_margin: float = 15.0 @@ -4874,11 +6787,20 @@ def __call__(self): return "tIOTBTC" -IOTBTC = IOTBTC() +IOTETH = IOTETH() @dataclass(slots=True, frozen=True) class IOTETH: + """ + name: tIOTETH + precision: 5 + minimum_margin: 15.0 + initial_margin: 30.0 + minimum_order_size: 6.0 + maximum_order_size: 100000.0 + margin: True + """ name: str = "tIOTETH" precision: int = 5 minimum_margin: float = 15.0 @@ -4897,11 +6819,20 @@ def __call__(self): return "tIOTETH" -IOTETH = IOTETH() +IOTF0_USTF0 = IOTF0_USTF0() @dataclass(slots=True, frozen=True) class IOTF0_USTF0: + """ + name: tIOTF0:USTF0 + precision: 5 + minimum_margin: 0.5 + initial_margin: 1.0 + minimum_order_size: 6.0 + maximum_order_size: 250000.0 + margin: True + """ name: str = "tIOTF0:USTF0" precision: int = 5 minimum_margin: float = 0.5 @@ -4920,11 +6851,20 @@ def __call__(self): return "tIOTF0:USTF0" -IOTF0_USTF0 = IOTF0_USTF0() +IOTUSD = IOTUSD() @dataclass(slots=True, frozen=True) class IOTUSD: + """ + name: tIOTUSD + precision: 5 + minimum_margin: 15.0 + initial_margin: 30.0 + minimum_order_size: 6.0 + maximum_order_size: 100000.0 + margin: True + """ name: str = "tIOTUSD" precision: int = 5 minimum_margin: float = 15.0 @@ -4943,11 +6883,20 @@ def __call__(self): return "tIOTUSD" -IOTUSD = IOTUSD() +IQXUSD = IQXUSD() @dataclass(slots=True, frozen=True) class IQXUSD: + """ + name: tIQXUSD + precision: 5 + minimum_margin: 15.0 + initial_margin: 30.0 + minimum_order_size: 334.0 + maximum_order_size: 100000000.0 + margin: False + """ name: str = "tIQXUSD" precision: int = 5 minimum_margin: float = 15.0 @@ -4966,11 +6915,20 @@ def __call__(self): return "tIQXUSD" -IQXUSD = IQXUSD() +JASMY_USD = JASMY_USD() @dataclass(slots=True, frozen=True) class JASMY_USD: + """ + name: tJASMY:USD + precision: 5 + minimum_margin: 15.0 + initial_margin: 30.0 + minimum_order_size: 168.0 + maximum_order_size: 2500000.0 + margin: False + """ name: str = "tJASMY:USD" precision: int = 5 minimum_margin: float = 15.0 @@ -4989,11 +6947,20 @@ def __call__(self): return "tJASMY:USD" -JASMY_USD = JASMY_USD() +JASMY_UST = JASMY_UST() @dataclass(slots=True, frozen=True) class JASMY_UST: + """ + name: tJASMY:UST + precision: 5 + minimum_margin: 15.0 + initial_margin: 30.0 + minimum_order_size: 168.0 + maximum_order_size: 2500000.0 + margin: False + """ name: str = "tJASMY:UST" precision: int = 5 minimum_margin: float = 15.0 @@ -5012,11 +6979,20 @@ def __call__(self): return "tJASMY:UST" -JASMY_UST = JASMY_UST() +JASMYF0_USTF0 = JASMYF0_USTF0() @dataclass(slots=True, frozen=True) class JASMYF0_USTF0: + """ + name: tJASMYF0:USTF0 + precision: 5 + minimum_margin: 0.5 + initial_margin: 1.0 + minimum_order_size: 168.0 + maximum_order_size: 2500000.0 + margin: True + """ name: str = "tJASMYF0:USTF0" precision: int = 5 minimum_margin: float = 0.5 @@ -5035,11 +7011,20 @@ def __call__(self): return "tJASMYF0:USTF0" -JASMYF0_USTF0 = JASMYF0_USTF0() +JPYF0_USTF0 = JPYF0_USTF0() @dataclass(slots=True, frozen=True) class JPYF0_USTF0: + """ + name: tJPYF0:USTF0 + precision: 5 + minimum_margin: 0.5 + initial_margin: 1.0 + minimum_order_size: 262.0 + maximum_order_size: 100000000.0 + margin: True + """ name: str = "tJPYF0:USTF0" precision: int = 5 minimum_margin: float = 0.5 @@ -5058,11 +7043,20 @@ def __call__(self): return "tJPYF0:USTF0" -JPYF0_USTF0 = JPYF0_USTF0() +JPYUST = JPYUST() @dataclass(slots=True, frozen=True) class JPYUST: + """ + name: tJPYUST + precision: 5 + minimum_margin: 15.0 + initial_margin: 30.0 + minimum_order_size: 262.0 + maximum_order_size: 100000000.0 + margin: False + """ name: str = "tJPYUST" precision: int = 5 minimum_margin: float = 15.0 @@ -5081,11 +7075,20 @@ def __call__(self): return "tJPYUST" -JPYUST = JPYUST() +JSTBTC = JSTBTC() @dataclass(slots=True, frozen=True) class JSTBTC: + """ + name: tJSTBTC + precision: 5 + minimum_margin: 15.0 + initial_margin: 30.0 + minimum_order_size: 48.0 + maximum_order_size: 1000000.0 + margin: False + """ name: str = "tJSTBTC" precision: int = 5 minimum_margin: float = 15.0 @@ -5104,11 +7107,20 @@ def __call__(self): return "tJSTBTC" -JSTBTC = JSTBTC() +JSTUSD = JSTUSD() @dataclass(slots=True, frozen=True) class JSTUSD: + """ + name: tJSTUSD + precision: 5 + minimum_margin: 15.0 + initial_margin: 30.0 + minimum_order_size: 48.0 + maximum_order_size: 1000000.0 + margin: False + """ name: str = "tJSTUSD" precision: int = 5 minimum_margin: float = 15.0 @@ -5127,11 +7139,20 @@ def __call__(self): return "tJSTUSD" -JSTUSD = JSTUSD() +JSTUST = JSTUST() @dataclass(slots=True, frozen=True) class JSTUST: + """ + name: tJSTUST + precision: 5 + minimum_margin: 15.0 + initial_margin: 30.0 + minimum_order_size: 48.0 + maximum_order_size: 1000000.0 + margin: False + """ name: str = "tJSTUST" precision: int = 5 minimum_margin: float = 15.0 @@ -5150,11 +7171,20 @@ def __call__(self): return "tJSTUST" -JSTUST = JSTUST() +KAIUSD = KAIUSD() @dataclass(slots=True, frozen=True) class KAIUSD: + """ + name: tKAIUSD + precision: 5 + minimum_margin: 15.0 + initial_margin: 30.0 + minimum_order_size: 132.0 + maximum_order_size: 2500000.0 + margin: False + """ name: str = "tKAIUSD" precision: int = 5 minimum_margin: float = 15.0 @@ -5173,11 +7203,20 @@ def __call__(self): return "tKAIUSD" -KAIUSD = KAIUSD() +KAIUST = KAIUST() @dataclass(slots=True, frozen=True) class KAIUST: + """ + name: tKAIUST + precision: 5 + minimum_margin: 15.0 + initial_margin: 30.0 + minimum_order_size: 132.0 + maximum_order_size: 2500000.0 + margin: False + """ name: str = "tKAIUST" precision: int = 5 minimum_margin: float = 15.0 @@ -5196,11 +7235,20 @@ def __call__(self): return "tKAIUST" -KAIUST = KAIUST() +KANUSD = KANUSD() @dataclass(slots=True, frozen=True) class KANUSD: + """ + name: tKANUSD + precision: 5 + minimum_margin: 15.0 + initial_margin: 30.0 + minimum_order_size: 1542.0 + maximum_order_size: 5000000.0 + margin: False + """ name: str = "tKANUSD" precision: int = 5 minimum_margin: float = 15.0 @@ -5219,11 +7267,20 @@ def __call__(self): return "tKANUSD" -KANUSD = KANUSD() +KANUST = KANUST() @dataclass(slots=True, frozen=True) class KANUST: + """ + name: tKANUST + precision: 5 + minimum_margin: 15.0 + initial_margin: 30.0 + minimum_order_size: 1542.0 + maximum_order_size: 5000000.0 + margin: False + """ name: str = "tKANUST" precision: int = 5 minimum_margin: float = 15.0 @@ -5242,11 +7299,20 @@ def __call__(self): return "tKANUST" -KANUST = KANUST() +KNCBTC = KNCBTC() @dataclass(slots=True, frozen=True) class KNCBTC: + """ + name: tKNCBTC + precision: 5 + minimum_margin: 15.0 + initial_margin: 30.0 + minimum_order_size: 2.0 + maximum_order_size: 20000.0 + margin: False + """ name: str = "tKNCBTC" precision: int = 5 minimum_margin: float = 15.0 @@ -5265,11 +7331,20 @@ def __call__(self): return "tKNCBTC" -KNCBTC = KNCBTC() +KNCF0_USTF0 = KNCF0_USTF0() @dataclass(slots=True, frozen=True) class KNCF0_USTF0: + """ + name: tKNCF0:USTF0 + precision: 5 + minimum_margin: 0.5 + initial_margin: 1.0 + minimum_order_size: 2.0 + maximum_order_size: 100000.0 + margin: True + """ name: str = "tKNCF0:USTF0" precision: int = 5 minimum_margin: float = 0.5 @@ -5288,11 +7363,20 @@ def __call__(self): return "tKNCF0:USTF0" -KNCF0_USTF0 = KNCF0_USTF0() +KNCUSD = KNCUSD() @dataclass(slots=True, frozen=True) class KNCUSD: + """ + name: tKNCUSD + precision: 5 + minimum_margin: 15.0 + initial_margin: 30.0 + minimum_order_size: 2.0 + maximum_order_size: 100000.0 + margin: False + """ name: str = "tKNCUSD" precision: int = 5 minimum_margin: float = 15.0 @@ -5311,11 +7395,20 @@ def __call__(self): return "tKNCUSD" -KNCUSD = KNCUSD() +KSMUSD = KSMUSD() @dataclass(slots=True, frozen=True) class KSMUSD: + """ + name: tKSMUSD + precision: 5 + minimum_margin: 15.0 + initial_margin: 30.0 + minimum_order_size: 0.02 + maximum_order_size: 5000.0 + margin: False + """ name: str = "tKSMUSD" precision: int = 5 minimum_margin: float = 15.0 @@ -5334,11 +7427,20 @@ def __call__(self): return "tKSMUSD" -KSMUSD = KSMUSD() +KSMUST = KSMUST() @dataclass(slots=True, frozen=True) class KSMUST: + """ + name: tKSMUST + precision: 5 + minimum_margin: 15.0 + initial_margin: 30.0 + minimum_order_size: 0.02 + maximum_order_size: 5000.0 + margin: False + """ name: str = "tKSMUST" precision: int = 5 minimum_margin: float = 15.0 @@ -5357,11 +7459,20 @@ def __call__(self): return "tKSMUST" -KSMUST = KSMUST() +LEOBTC = LEOBTC() @dataclass(slots=True, frozen=True) class LEOBTC: + """ + name: tLEOBTC + precision: 5 + minimum_margin: 15.0 + initial_margin: 30.0 + minimum_order_size: 0.6 + maximum_order_size: 50000.0 + margin: False + """ name: str = "tLEOBTC" precision: int = 5 minimum_margin: float = 15.0 @@ -5380,11 +7491,20 @@ def __call__(self): return "tLEOBTC" -LEOBTC = LEOBTC() +LEOETH = LEOETH() @dataclass(slots=True, frozen=True) class LEOETH: + """ + name: tLEOETH + precision: 5 + minimum_margin: 15.0 + initial_margin: 30.0 + minimum_order_size: 0.6 + maximum_order_size: 50000.0 + margin: False + """ name: str = "tLEOETH" precision: int = 5 minimum_margin: float = 15.0 @@ -5403,11 +7523,20 @@ def __call__(self): return "tLEOETH" -LEOETH = LEOETH() +LEOUSD = LEOUSD() @dataclass(slots=True, frozen=True) class LEOUSD: + """ + name: tLEOUSD + precision: 5 + minimum_margin: 15.0 + initial_margin: 30.0 + minimum_order_size: 0.6 + maximum_order_size: 50000.0 + margin: True + """ name: str = "tLEOUSD" precision: int = 5 minimum_margin: float = 15.0 @@ -5426,11 +7555,20 @@ def __call__(self): return "tLEOUSD" -LEOUSD = LEOUSD() +LEOUST = LEOUST() @dataclass(slots=True, frozen=True) class LEOUST: + """ + name: tLEOUST + precision: 5 + minimum_margin: 15.0 + initial_margin: 30.0 + minimum_order_size: 0.6 + maximum_order_size: 50000.0 + margin: True + """ name: str = "tLEOUST" precision: int = 5 minimum_margin: float = 15.0 @@ -5449,11 +7587,20 @@ def __call__(self): return "tLEOUST" -LEOUST = LEOUST() +LINK_USD = LINK_USD() @dataclass(slots=True, frozen=True) class LINK_USD: + """ + name: tLINK:USD + precision: 5 + minimum_margin: 15.0 + initial_margin: 30.0 + minimum_order_size: 0.2 + maximum_order_size: 50000.0 + margin: True + """ name: str = "tLINK:USD" precision: int = 5 minimum_margin: float = 15.0 @@ -5472,11 +7619,20 @@ def __call__(self): return "tLINK:USD" -LINK_USD = LINK_USD() +LINK_UST = LINK_UST() @dataclass(slots=True, frozen=True) class LINK_UST: + """ + name: tLINK:UST + precision: 5 + minimum_margin: 15.0 + initial_margin: 30.0 + minimum_order_size: 0.2 + maximum_order_size: 50000.0 + margin: True + """ name: str = "tLINK:UST" precision: int = 5 minimum_margin: float = 15.0 @@ -5495,11 +7651,20 @@ def __call__(self): return "tLINK:UST" -LINK_UST = LINK_UST() +LINKF0_USTF0 = LINKF0_USTF0() @dataclass(slots=True, frozen=True) class LINKF0_USTF0: + """ + name: tLINKF0:USTF0 + precision: 5 + minimum_margin: 0.5 + initial_margin: 1.0 + minimum_order_size: 0.2 + maximum_order_size: 250000.0 + margin: True + """ name: str = "tLINKF0:USTF0" precision: int = 5 minimum_margin: float = 0.5 @@ -5518,11 +7683,20 @@ def __call__(self): return "tLINKF0:USTF0" -LINKF0_USTF0 = LINKF0_USTF0() +LRCUSD = LRCUSD() @dataclass(slots=True, frozen=True) class LRCUSD: + """ + name: tLRCUSD + precision: 5 + minimum_margin: 15.0 + initial_margin: 30.0 + minimum_order_size: 6.0 + maximum_order_size: 50000.0 + margin: False + """ name: str = "tLRCUSD" precision: int = 5 minimum_margin: float = 15.0 @@ -5541,11 +7715,20 @@ def __call__(self): return "tLRCUSD" -LRCUSD = LRCUSD() +LTCBTC = LTCBTC() @dataclass(slots=True, frozen=True) class LTCBTC: + """ + name: tLTCBTC + precision: 5 + minimum_margin: 15.0 + initial_margin: 30.0 + minimum_order_size: 0.04 + maximum_order_size: 5000.0 + margin: True + """ name: str = "tLTCBTC" precision: int = 5 minimum_margin: float = 15.0 @@ -5564,11 +7747,20 @@ def __call__(self): return "tLTCBTC" -LTCBTC = LTCBTC() +LTCF0_BTCF0 = LTCF0_BTCF0() @dataclass(slots=True, frozen=True) class LTCF0_BTCF0: + """ + name: tLTCF0:BTCF0 + precision: 5 + minimum_margin: 0.5 + initial_margin: 1.0 + minimum_order_size: 0.04 + maximum_order_size: 7500.0 + margin: True + """ name: str = "tLTCF0:BTCF0" precision: int = 5 minimum_margin: float = 0.5 @@ -5587,11 +7779,20 @@ def __call__(self): return "tLTCF0:BTCF0" -LTCF0_BTCF0 = LTCF0_BTCF0() +LTCF0_USTF0 = LTCF0_USTF0() @dataclass(slots=True, frozen=True) class LTCF0_USTF0: + """ + name: tLTCF0:USTF0 + precision: 5 + minimum_margin: 0.5 + initial_margin: 1.0 + minimum_order_size: 0.04 + maximum_order_size: 250000.0 + margin: True + """ name: str = "tLTCF0:USTF0" precision: int = 5 minimum_margin: float = 0.5 @@ -5610,11 +7811,20 @@ def __call__(self): return "tLTCF0:USTF0" -LTCF0_USTF0 = LTCF0_USTF0() +LTCUSD = LTCUSD() @dataclass(slots=True, frozen=True) class LTCUSD: + """ + name: tLTCUSD + precision: 5 + minimum_margin: 10.0 + initial_margin: 20.0 + minimum_order_size: 0.04 + maximum_order_size: 5000.0 + margin: True + """ name: str = "tLTCUSD" precision: int = 5 minimum_margin: float = 10.0 @@ -5633,11 +7843,20 @@ def __call__(self): return "tLTCUSD" -LTCUSD = LTCUSD() +LTCUST = LTCUST() @dataclass(slots=True, frozen=True) class LTCUST: + """ + name: tLTCUST + precision: 5 + minimum_margin: 10.0 + initial_margin: 20.0 + minimum_order_size: 0.04 + maximum_order_size: 2000.0 + margin: True + """ name: str = "tLTCUST" precision: int = 5 minimum_margin: float = 10.0 @@ -5656,11 +7875,20 @@ def __call__(self): return "tLTCUST" -LTCUST = LTCUST() +LUNA2_USD = LUNA2_USD() @dataclass(slots=True, frozen=True) class LUNA2_USD: + """ + name: tLUNA2:USD + precision: 5 + minimum_margin: 15.0 + initial_margin: 30.0 + minimum_order_size: 0.4 + maximum_order_size: 100000.0 + margin: False + """ name: str = "tLUNA2:USD" precision: int = 5 minimum_margin: float = 15.0 @@ -5679,11 +7907,20 @@ def __call__(self): return "tLUNA2:USD" -LUNA2_USD = LUNA2_USD() +LUNA2_UST = LUNA2_UST() @dataclass(slots=True, frozen=True) class LUNA2_UST: + """ + name: tLUNA2:UST + precision: 5 + minimum_margin: 15.0 + initial_margin: 30.0 + minimum_order_size: 0.4 + maximum_order_size: 100000.0 + margin: False + """ name: str = "tLUNA2:UST" precision: int = 5 minimum_margin: float = 15.0 @@ -5702,11 +7939,20 @@ def __call__(self): return "tLUNA2:UST" -LUNA2_UST = LUNA2_UST() +LUNA_USD = LUNA_USD() @dataclass(slots=True, frozen=True) class LUNA_USD: + """ + name: tLUNA:USD + precision: 5 + minimum_margin: 15.0 + initial_margin: 30.0 + minimum_order_size: 20814.0 + maximum_order_size: 100000000000.0 + margin: False + """ name: str = "tLUNA:USD" precision: int = 5 minimum_margin: float = 15.0 @@ -5725,11 +7971,20 @@ def __call__(self): return "tLUNA:USD" -LUNA_USD = LUNA_USD() +LUNA_UST = LUNA_UST() @dataclass(slots=True, frozen=True) class LUNA_UST: + """ + name: tLUNA:UST + precision: 5 + minimum_margin: 15.0 + initial_margin: 30.0 + minimum_order_size: 20814.0 + maximum_order_size: 100000000000.0 + margin: False + """ name: str = "tLUNA:UST" precision: int = 5 minimum_margin: float = 15.0 @@ -5748,11 +8003,20 @@ def __call__(self): return "tLUNA:UST" -LUNA_UST = LUNA_UST() +LUXO_USD = LUXO_USD() @dataclass(slots=True, frozen=True) class LUXO_USD: + """ + name: tLUXO:USD + precision: 5 + minimum_margin: 15.0 + initial_margin: 30.0 + minimum_order_size: 20.0 + maximum_order_size: 250000.0 + margin: False + """ name: str = "tLUXO:USD" precision: int = 5 minimum_margin: float = 15.0 @@ -5771,11 +8035,20 @@ def __call__(self): return "tLUXO:USD" -LUXO_USD = LUXO_USD() +LYMUSD = LYMUSD() @dataclass(slots=True, frozen=True) class LYMUSD: + """ + name: tLYMUSD + precision: 5 + minimum_margin: 15.0 + initial_margin: 30.0 + minimum_order_size: 740.0 + maximum_order_size: 400000.0 + margin: False + """ name: str = "tLYMUSD" precision: int = 5 minimum_margin: float = 15.0 @@ -5794,11 +8067,20 @@ def __call__(self): return "tLYMUSD" -LYMUSD = LYMUSD() +MATIC_BTC = MATIC_BTC() @dataclass(slots=True, frozen=True) class MATIC_BTC: + """ + name: tMATIC:BTC + precision: 5 + minimum_margin: 15.0 + initial_margin: 30.0 + minimum_order_size: 4.0 + maximum_order_size: 100000.0 + margin: False + """ name: str = "tMATIC:BTC" precision: int = 5 minimum_margin: float = 15.0 @@ -5817,11 +8099,20 @@ def __call__(self): return "tMATIC:BTC" -MATIC_BTC = MATIC_BTC() +MATIC_USD = MATIC_USD() @dataclass(slots=True, frozen=True) class MATIC_USD: + """ + name: tMATIC:USD + precision: 5 + minimum_margin: 15.0 + initial_margin: 30.0 + minimum_order_size: 4.0 + maximum_order_size: 100000.0 + margin: True + """ name: str = "tMATIC:USD" precision: int = 5 minimum_margin: float = 15.0 @@ -5840,11 +8131,20 @@ def __call__(self): return "tMATIC:USD" -MATIC_USD = MATIC_USD() +MATIC_UST = MATIC_UST() @dataclass(slots=True, frozen=True) class MATIC_UST: + """ + name: tMATIC:UST + precision: 5 + minimum_margin: 15.0 + initial_margin: 30.0 + minimum_order_size: 4.0 + maximum_order_size: 100000.0 + margin: True + """ name: str = "tMATIC:UST" precision: int = 5 minimum_margin: float = 15.0 @@ -5863,11 +8163,20 @@ def __call__(self): return "tMATIC:UST" -MATIC_UST = MATIC_UST() +MATICF0_USTF0 = MATICF0_USTF0() @dataclass(slots=True, frozen=True) class MATICF0_USTF0: + """ + name: tMATICF0:USTF0 + precision: 5 + minimum_margin: 0.5 + initial_margin: 1.0 + minimum_order_size: 4.0 + maximum_order_size: 100000.0 + margin: True + """ name: str = "tMATICF0:USTF0" precision: int = 5 minimum_margin: float = 0.5 @@ -5886,11 +8195,20 @@ def __call__(self): return "tMATICF0:USTF0" -MATICF0_USTF0 = MATICF0_USTF0() +MIMUSD = MIMUSD() @dataclass(slots=True, frozen=True) class MIMUSD: + """ + name: tMIMUSD + precision: 5 + minimum_margin: 15.0 + initial_margin: 30.0 + minimum_order_size: 2.0 + maximum_order_size: 100000.0 + margin: False + """ name: str = "tMIMUSD" precision: int = 5 minimum_margin: float = 15.0 @@ -5909,11 +8227,20 @@ def __call__(self): return "tMIMUSD" -MIMUSD = MIMUSD() +MIMUST = MIMUST() @dataclass(slots=True, frozen=True) class MIMUST: + """ + name: tMIMUST + precision: 5 + minimum_margin: 15.0 + initial_margin: 30.0 + minimum_order_size: 2.0 + maximum_order_size: 100000.0 + margin: False + """ name: str = "tMIMUST" precision: int = 5 minimum_margin: float = 15.0 @@ -5932,11 +8259,20 @@ def __call__(self): return "tMIMUST" -MIMUST = MIMUST() +MIRUSD = MIRUSD() @dataclass(slots=True, frozen=True) class MIRUSD: + """ + name: tMIRUSD + precision: 5 + minimum_margin: 15.0 + initial_margin: 30.0 + minimum_order_size: 8.0 + maximum_order_size: 100000.0 + margin: False + """ name: str = "tMIRUSD" precision: int = 5 minimum_margin: float = 15.0 @@ -5955,11 +8291,20 @@ def __call__(self): return "tMIRUSD" -MIRUSD = MIRUSD() +MKRF0_USTF0 = MKRF0_USTF0() @dataclass(slots=True, frozen=True) class MKRF0_USTF0: + """ + name: tMKRF0:USTF0 + precision: 5 + minimum_margin: 0.5 + initial_margin: 1.0 + minimum_order_size: 0.002 + maximum_order_size: 2500.0 + margin: True + """ name: str = "tMKRF0:USTF0" precision: int = 5 minimum_margin: float = 0.5 @@ -5978,11 +8323,20 @@ def __call__(self): return "tMKRF0:USTF0" -MKRF0_USTF0 = MKRF0_USTF0() +MKRUSD = MKRUSD() @dataclass(slots=True, frozen=True) class MKRUSD: + """ + name: tMKRUSD + precision: 5 + minimum_margin: 15.0 + initial_margin: 30.0 + minimum_order_size: 0.002 + maximum_order_size: 2500.0 + margin: True + """ name: str = "tMKRUSD" precision: int = 5 minimum_margin: float = 15.0 @@ -6001,11 +8355,20 @@ def __call__(self): return "tMKRUSD" -MKRUSD = MKRUSD() +MKRUST = MKRUST() @dataclass(slots=True, frozen=True) class MKRUST: + """ + name: tMKRUST + precision: 5 + minimum_margin: 15.0 + initial_margin: 30.0 + minimum_order_size: 0.002 + maximum_order_size: 2500.0 + margin: False + """ name: str = "tMKRUST" precision: int = 5 minimum_margin: float = 15.0 @@ -6024,11 +8387,20 @@ def __call__(self): return "tMKRUST" -MKRUST = MKRUST() +MLNUSD = MLNUSD() @dataclass(slots=True, frozen=True) class MLNUSD: + """ + name: tMLNUSD + precision: 5 + minimum_margin: 15.0 + initial_margin: 30.0 + minimum_order_size: 0.08 + maximum_order_size: 500000.0 + margin: False + """ name: str = "tMLNUSD" precision: int = 5 minimum_margin: float = 15.0 @@ -6047,11 +8419,20 @@ def __call__(self): return "tMLNUSD" -MLNUSD = MLNUSD() +MNABTC = MNABTC() @dataclass(slots=True, frozen=True) class MNABTC: + """ + name: tMNABTC + precision: 5 + minimum_margin: 15.0 + initial_margin: 30.0 + minimum_order_size: 4.0 + maximum_order_size: 200000.0 + margin: False + """ name: str = "tMNABTC" precision: int = 5 minimum_margin: float = 15.0 @@ -6070,11 +8451,20 @@ def __call__(self): return "tMNABTC" -MNABTC = MNABTC() +MNAUSD = MNAUSD() @dataclass(slots=True, frozen=True) class MNAUSD: + """ + name: tMNAUSD + precision: 5 + minimum_margin: 15.0 + initial_margin: 30.0 + minimum_order_size: 4.0 + maximum_order_size: 200000.0 + margin: False + """ name: str = "tMNAUSD" precision: int = 5 minimum_margin: float = 15.0 @@ -6093,11 +8483,20 @@ def __call__(self): return "tMNAUSD" -MNAUSD = MNAUSD() +MOBUSD = MOBUSD() @dataclass(slots=True, frozen=True) class MOBUSD: + """ + name: tMOBUSD + precision: 5 + minimum_margin: 15.0 + initial_margin: 30.0 + minimum_order_size: 2.0 + maximum_order_size: 10000.0 + margin: False + """ name: str = "tMOBUSD" precision: int = 5 minimum_margin: float = 15.0 @@ -6116,11 +8515,20 @@ def __call__(self): return "tMOBUSD" -MOBUSD = MOBUSD() +MOBUST = MOBUST() @dataclass(slots=True, frozen=True) class MOBUST: + """ + name: tMOBUST + precision: 5 + minimum_margin: 15.0 + initial_margin: 30.0 + minimum_order_size: 2.0 + maximum_order_size: 10000.0 + margin: False + """ name: str = "tMOBUST" precision: int = 5 minimum_margin: float = 15.0 @@ -6139,11 +8547,20 @@ def __call__(self): return "tMOBUST" -MOBUST = MOBUST() +MXNT_USD = MXNT_USD() @dataclass(slots=True, frozen=True) class MXNT_USD: + """ + name: tMXNT:USD + precision: 5 + minimum_margin: 15.0 + initial_margin: 30.0 + minimum_order_size: 0.001 + maximum_order_size: 10000000.0 + margin: False + """ name: str = "tMXNT:USD" precision: int = 5 minimum_margin: float = 15.0 @@ -6162,11 +8579,20 @@ def __call__(self): return "tMXNT:USD" -MXNT_USD = MXNT_USD() +NEAR_USD = NEAR_USD() @dataclass(slots=True, frozen=True) class NEAR_USD: + """ + name: tNEAR:USD + precision: 5 + minimum_margin: 15.0 + initial_margin: 30.0 + minimum_order_size: 0.4 + maximum_order_size: 25000.0 + margin: False + """ name: str = "tNEAR:USD" precision: int = 5 minimum_margin: float = 15.0 @@ -6185,11 +8611,20 @@ def __call__(self): return "tNEAR:USD" -NEAR_USD = NEAR_USD() +NEAR_UST = NEAR_UST() @dataclass(slots=True, frozen=True) class NEAR_UST: + """ + name: tNEAR:UST + precision: 5 + minimum_margin: 15.0 + initial_margin: 30.0 + minimum_order_size: 0.4 + maximum_order_size: 25000.0 + margin: False + """ name: str = "tNEAR:UST" precision: int = 5 minimum_margin: float = 15.0 @@ -6208,11 +8643,20 @@ def __call__(self): return "tNEAR:UST" -NEAR_UST = NEAR_UST() +NEARF0_USTF0 = NEARF0_USTF0() @dataclass(slots=True, frozen=True) class NEARF0_USTF0: + """ + name: tNEARF0:USTF0 + precision: 5 + minimum_margin: 0.5 + initial_margin: 1.0 + minimum_order_size: 0.4 + maximum_order_size: 25000.0 + margin: True + """ name: str = "tNEARF0:USTF0" precision: int = 5 minimum_margin: float = 0.5 @@ -6231,11 +8675,20 @@ def __call__(self): return "tNEARF0:USTF0" -NEARF0_USTF0 = NEARF0_USTF0() +NEOBTC = NEOBTC() @dataclass(slots=True, frozen=True) class NEOBTC: + """ + name: tNEOBTC + precision: 5 + minimum_margin: 15.0 + initial_margin: 30.0 + minimum_order_size: 0.2 + maximum_order_size: 10000.0 + margin: True + """ name: str = "tNEOBTC" precision: int = 5 minimum_margin: float = 15.0 @@ -6254,11 +8707,20 @@ def __call__(self): return "tNEOBTC" -NEOBTC = NEOBTC() +NEOF0_USTF0 = NEOF0_USTF0() @dataclass(slots=True, frozen=True) class NEOF0_USTF0: + """ + name: tNEOF0:USTF0 + precision: 5 + minimum_margin: 0.5 + initial_margin: 1.0 + minimum_order_size: 0.2 + maximum_order_size: 10000.0 + margin: True + """ name: str = "tNEOF0:USTF0" precision: int = 5 minimum_margin: float = 0.5 @@ -6277,11 +8739,20 @@ def __call__(self): return "tNEOF0:USTF0" -NEOF0_USTF0 = NEOF0_USTF0() +NEOUSD = NEOUSD() @dataclass(slots=True, frozen=True) class NEOUSD: + """ + name: tNEOUSD + precision: 5 + minimum_margin: 15.0 + initial_margin: 30.0 + minimum_order_size: 0.2 + maximum_order_size: 10000.0 + margin: True + """ name: str = "tNEOUSD" precision: int = 5 minimum_margin: float = 15.0 @@ -6300,11 +8771,20 @@ def __call__(self): return "tNEOUSD" -NEOUSD = NEOUSD() +NEOUST = NEOUST() @dataclass(slots=True, frozen=True) class NEOUST: + """ + name: tNEOUST + precision: 5 + minimum_margin: 15.0 + initial_margin: 30.0 + minimum_order_size: 0.2 + maximum_order_size: 10000.0 + margin: True + """ name: str = "tNEOUST" precision: int = 5 minimum_margin: float = 15.0 @@ -6323,11 +8803,20 @@ def __call__(self): return "tNEOUST" -NEOUST = NEOUST() +NEXO_BTC = NEXO_BTC() @dataclass(slots=True, frozen=True) class NEXO_BTC: + """ + name: tNEXO:BTC + precision: 5 + minimum_margin: 15.0 + initial_margin: 30.0 + minimum_order_size: 2.0 + maximum_order_size: 250000.0 + margin: False + """ name: str = "tNEXO:BTC" precision: int = 5 minimum_margin: float = 15.0 @@ -6346,11 +8835,20 @@ def __call__(self): return "tNEXO:BTC" -NEXO_BTC = NEXO_BTC() +NEXO_USD = NEXO_USD() @dataclass(slots=True, frozen=True) class NEXO_USD: + """ + name: tNEXO:USD + precision: 5 + minimum_margin: 15.0 + initial_margin: 30.0 + minimum_order_size: 2.0 + maximum_order_size: 250000.0 + margin: False + """ name: str = "tNEXO:USD" precision: int = 5 minimum_margin: float = 15.0 @@ -6369,11 +8867,20 @@ def __call__(self): return "tNEXO:USD" -NEXO_USD = NEXO_USD() +NEXO_UST = NEXO_UST() @dataclass(slots=True, frozen=True) class NEXO_UST: + """ + name: tNEXO:UST + precision: 5 + minimum_margin: 15.0 + initial_margin: 30.0 + minimum_order_size: 2.0 + maximum_order_size: 250000.0 + margin: False + """ name: str = "tNEXO:UST" precision: int = 5 minimum_margin: float = 15.0 @@ -6392,11 +8899,20 @@ def __call__(self): return "tNEXO:UST" -NEXO_UST = NEXO_UST() +OCEAN_USD = OCEAN_USD() @dataclass(slots=True, frozen=True) class OCEAN_USD: + """ + name: tOCEAN:USD + precision: 5 + minimum_margin: 15.0 + initial_margin: 30.0 + minimum_order_size: 10.0 + maximum_order_size: 250000.0 + margin: False + """ name: str = "tOCEAN:USD" precision: int = 5 minimum_margin: float = 15.0 @@ -6415,11 +8931,20 @@ def __call__(self): return "tOCEAN:USD" -OCEAN_USD = OCEAN_USD() +OCEAN_UST = OCEAN_UST() @dataclass(slots=True, frozen=True) class OCEAN_UST: + """ + name: tOCEAN:UST + precision: 5 + minimum_margin: 15.0 + initial_margin: 30.0 + minimum_order_size: 10.0 + maximum_order_size: 250000.0 + margin: False + """ name: str = "tOCEAN:UST" precision: int = 5 minimum_margin: float = 15.0 @@ -6438,11 +8963,20 @@ def __call__(self): return "tOCEAN:UST" -OCEAN_UST = OCEAN_UST() +OMGBTC = OMGBTC() @dataclass(slots=True, frozen=True) class OMGBTC: + """ + name: tOMGBTC + precision: 5 + minimum_margin: 15.0 + initial_margin: 30.0 + minimum_order_size: 0.8 + maximum_order_size: 100000.0 + margin: True + """ name: str = "tOMGBTC" precision: int = 5 minimum_margin: float = 15.0 @@ -6461,11 +8995,20 @@ def __call__(self): return "tOMGBTC" -OMGBTC = OMGBTC() +OMGETH = OMGETH() @dataclass(slots=True, frozen=True) class OMGETH: + """ + name: tOMGETH + precision: 5 + minimum_margin: 15.0 + initial_margin: 30.0 + minimum_order_size: 0.8 + maximum_order_size: 100000.0 + margin: True + """ name: str = "tOMGETH" precision: int = 5 minimum_margin: float = 15.0 @@ -6484,11 +9027,20 @@ def __call__(self): return "tOMGETH" -OMGETH = OMGETH() +OMGF0_USTF0 = OMGF0_USTF0() @dataclass(slots=True, frozen=True) class OMGF0_USTF0: + """ + name: tOMGF0:USTF0 + precision: 5 + minimum_margin: 0.5 + initial_margin: 1.0 + minimum_order_size: 0.8 + maximum_order_size: 100000.0 + margin: True + """ name: str = "tOMGF0:USTF0" precision: int = 5 minimum_margin: float = 0.5 @@ -6507,11 +9059,20 @@ def __call__(self): return "tOMGF0:USTF0" -OMGF0_USTF0 = OMGF0_USTF0() +OMGUSD = OMGUSD() @dataclass(slots=True, frozen=True) class OMGUSD: + """ + name: tOMGUSD + precision: 5 + minimum_margin: 15.0 + initial_margin: 30.0 + minimum_order_size: 0.8 + maximum_order_size: 100000.0 + margin: True + """ name: str = "tOMGUSD" precision: int = 5 minimum_margin: float = 15.0 @@ -6530,11 +9091,20 @@ def __call__(self): return "tOMGUSD" -OMGUSD = OMGUSD() +OMNUSD = OMNUSD() @dataclass(slots=True, frozen=True) class OMNUSD: + """ + name: tOMNUSD + precision: 5 + minimum_margin: 15.0 + initial_margin: 30.0 + minimum_order_size: 0.6 + maximum_order_size: 20000.0 + margin: False + """ name: str = "tOMNUSD" precision: int = 5 minimum_margin: float = 15.0 @@ -6553,11 +9123,20 @@ def __call__(self): return "tOMNUSD" -OMNUSD = OMNUSD() +ONEUSD = ONEUSD() @dataclass(slots=True, frozen=True) class ONEUSD: + """ + name: tONEUSD + precision: 5 + minimum_margin: 15.0 + initial_margin: 30.0 + minimum_order_size: 0.001 + maximum_order_size: 3500000.0 + margin: False + """ name: str = "tONEUSD" precision: int = 5 minimum_margin: float = 15.0 @@ -6576,11 +9155,20 @@ def __call__(self): return "tONEUSD" -ONEUSD = ONEUSD() +ONEUST = ONEUST() @dataclass(slots=True, frozen=True) class ONEUST: + """ + name: tONEUST + precision: 5 + minimum_margin: 15.0 + initial_margin: 30.0 + minimum_order_size: 0.001 + maximum_order_size: 3500000.0 + margin: False + """ name: str = "tONEUST" precision: int = 5 minimum_margin: float = 15.0 @@ -6599,11 +9187,20 @@ def __call__(self): return "tONEUST" -ONEUST = ONEUST() +OXYUSD = OXYUSD() @dataclass(slots=True, frozen=True) class OXYUSD: + """ + name: tOXYUSD + precision: 5 + minimum_margin: 15.0 + initial_margin: 30.0 + minimum_order_size: 22.0 + maximum_order_size: 1000000.0 + margin: False + """ name: str = "tOXYUSD" precision: int = 5 minimum_margin: float = 15.0 @@ -6622,11 +9219,20 @@ def __call__(self): return "tOXYUSD" -OXYUSD = OXYUSD() +PASUSD = PASUSD() @dataclass(slots=True, frozen=True) class PASUSD: + """ + name: tPASUSD + precision: 5 + minimum_margin: 15.0 + initial_margin: 30.0 + minimum_order_size: 1588.0 + maximum_order_size: 500000.0 + margin: False + """ name: str = "tPASUSD" precision: int = 5 minimum_margin: float = 15.0 @@ -6645,11 +9251,20 @@ def __call__(self): return "tPASUSD" -PASUSD = PASUSD() +PAXUSD = PAXUSD() @dataclass(slots=True, frozen=True) class PAXUSD: + """ + name: tPAXUSD + precision: 5 + minimum_margin: 15.0 + initial_margin: 30.0 + minimum_order_size: 2.0 + maximum_order_size: 1000000.0 + margin: False + """ name: str = "tPAXUSD" precision: int = 5 minimum_margin: float = 15.0 @@ -6668,11 +9283,20 @@ def __call__(self): return "tPAXUSD" -PAXUSD = PAXUSD() +PAXUST = PAXUST() @dataclass(slots=True, frozen=True) class PAXUST: + """ + name: tPAXUST + precision: 5 + minimum_margin: 15.0 + initial_margin: 30.0 + minimum_order_size: 2.0 + maximum_order_size: 50000.0 + margin: False + """ name: str = "tPAXUST" precision: int = 5 minimum_margin: float = 15.0 @@ -6691,11 +9315,20 @@ def __call__(self): return "tPAXUST" -PAXUST = PAXUST() +PLANETS_USD = PLANETS_USD() @dataclass(slots=True, frozen=True) class PLANETS_USD: + """ + name: tPLANETS:USD + precision: 5 + minimum_margin: 15.0 + initial_margin: 30.0 + minimum_order_size: 124.0 + maximum_order_size: 250000.0 + margin: False + """ name: str = "tPLANETS:USD" precision: int = 5 minimum_margin: float = 15.0 @@ -6714,11 +9347,20 @@ def __call__(self): return "tPLANETS:USD" -PLANETS_USD = PLANETS_USD() +PLANETS_UST = PLANETS_UST() @dataclass(slots=True, frozen=True) class PLANETS_UST: + """ + name: tPLANETS:UST + precision: 5 + minimum_margin: 15.0 + initial_margin: 30.0 + minimum_order_size: 124.0 + maximum_order_size: 250000.0 + margin: False + """ name: str = "tPLANETS:UST" precision: int = 5 minimum_margin: float = 15.0 @@ -6737,11 +9379,20 @@ def __call__(self): return "tPLANETS:UST" -PLANETS_UST = PLANETS_UST() +PLUUSD = PLUUSD() @dataclass(slots=True, frozen=True) class PLUUSD: + """ + name: tPLUUSD + precision: 5 + minimum_margin: 15.0 + initial_margin: 30.0 + minimum_order_size: 0.4 + maximum_order_size: 10000.0 + margin: False + """ name: str = "tPLUUSD" precision: int = 5 minimum_margin: float = 15.0 @@ -6760,11 +9411,20 @@ def __call__(self): return "tPLUUSD" -PLUUSD = PLUUSD() +PNKUSD = PNKUSD() @dataclass(slots=True, frozen=True) class PNKUSD: + """ + name: tPNKUSD + precision: 5 + minimum_margin: 15.0 + initial_margin: 30.0 + minimum_order_size: 52.0 + maximum_order_size: 1000000.0 + margin: False + """ name: str = "tPNKUSD" precision: int = 5 minimum_margin: float = 15.0 @@ -6783,11 +9443,20 @@ def __call__(self): return "tPNKUSD" -PNKUSD = PNKUSD() +POLC_USD = POLC_USD() @dataclass(slots=True, frozen=True) class POLC_USD: + """ + name: tPOLC:USD + precision: 5 + minimum_margin: 15.0 + initial_margin: 30.0 + minimum_order_size: 26.0 + maximum_order_size: 500000.0 + margin: False + """ name: str = "tPOLC:USD" precision: int = 5 minimum_margin: float = 15.0 @@ -6806,11 +9475,20 @@ def __call__(self): return "tPOLC:USD" -POLC_USD = POLC_USD() +POLC_UST = POLC_UST() @dataclass(slots=True, frozen=True) class POLC_UST: + """ + name: tPOLC:UST + precision: 5 + minimum_margin: 15.0 + initial_margin: 30.0 + minimum_order_size: 26.0 + maximum_order_size: 500000.0 + margin: False + """ name: str = "tPOLC:UST" precision: int = 5 minimum_margin: float = 15.0 @@ -6829,11 +9507,20 @@ def __call__(self): return "tPOLC:UST" -POLC_UST = POLC_UST() +POLIS_USD = POLIS_USD() @dataclass(slots=True, frozen=True) class POLIS_USD: + """ + name: tPOLIS:USD + precision: 5 + minimum_margin: 15.0 + initial_margin: 30.0 + minimum_order_size: 4.0 + maximum_order_size: 250000.0 + margin: False + """ name: str = "tPOLIS:USD" precision: int = 5 minimum_margin: float = 15.0 @@ -6852,11 +9539,20 @@ def __call__(self): return "tPOLIS:USD" -POLIS_USD = POLIS_USD() +POLIS_UST = POLIS_UST() @dataclass(slots=True, frozen=True) class POLIS_UST: + """ + name: tPOLIS:UST + precision: 5 + minimum_margin: 15.0 + initial_margin: 30.0 + minimum_order_size: 4.0 + maximum_order_size: 250000.0 + margin: False + """ name: str = "tPOLIS:UST" precision: int = 5 minimum_margin: float = 15.0 @@ -6875,11 +9571,20 @@ def __call__(self): return "tPOLIS:UST" -POLIS_UST = POLIS_UST() +QRDO_USD = QRDO_USD() @dataclass(slots=True, frozen=True) class QRDO_USD: + """ + name: tQRDO:USD + precision: 5 + minimum_margin: 15.0 + initial_margin: 30.0 + minimum_order_size: 4.0 + maximum_order_size: 50000.0 + margin: False + """ name: str = "tQRDO:USD" precision: int = 5 minimum_margin: float = 15.0 @@ -6898,11 +9603,20 @@ def __call__(self): return "tQRDO:USD" -QRDO_USD = QRDO_USD() +QRDO_UST = QRDO_UST() @dataclass(slots=True, frozen=True) class QRDO_UST: + """ + name: tQRDO:UST + precision: 5 + minimum_margin: 15.0 + initial_margin: 30.0 + minimum_order_size: 4.0 + maximum_order_size: 50000.0 + margin: False + """ name: str = "tQRDO:UST" precision: int = 5 minimum_margin: float = 15.0 @@ -6921,11 +9635,20 @@ def __call__(self): return "tQRDO:UST" -QRDO_UST = QRDO_UST() +QTFBTC = QTFBTC() @dataclass(slots=True, frozen=True) class QTFBTC: + """ + name: tQTFBTC + precision: 5 + minimum_margin: 15.0 + initial_margin: 30.0 + minimum_order_size: 0.2 + maximum_order_size: 50000.0 + margin: False + """ name: str = "tQTFBTC" precision: int = 5 minimum_margin: float = 15.0 @@ -6944,11 +9667,20 @@ def __call__(self): return "tQTFBTC" -QTFBTC = QTFBTC() +QTFUSD = QTFUSD() @dataclass(slots=True, frozen=True) class QTFUSD: + """ + name: tQTFUSD + precision: 5 + minimum_margin: 15.0 + initial_margin: 30.0 + minimum_order_size: 0.2 + maximum_order_size: 50000.0 + margin: False + """ name: str = "tQTFUSD" precision: int = 5 minimum_margin: float = 15.0 @@ -6967,11 +9699,20 @@ def __call__(self): return "tQTFUSD" -QTFUSD = QTFUSD() +QTMUSD = QTMUSD() @dataclass(slots=True, frozen=True) class QTMUSD: + """ + name: tQTMUSD + precision: 5 + minimum_margin: 15.0 + initial_margin: 30.0 + minimum_order_size: 0.6 + maximum_order_size: 5000.0 + margin: False + """ name: str = "tQTMUSD" precision: int = 5 minimum_margin: float = 15.0 @@ -6990,11 +9731,20 @@ def __call__(self): return "tQTMUSD" -QTMUSD = QTMUSD() +RBTBTC = RBTBTC() @dataclass(slots=True, frozen=True) class RBTBTC: + """ + name: tRBTBTC + precision: 5 + minimum_margin: 15.0 + initial_margin: 30.0 + minimum_order_size: 0.00006 + maximum_order_size: 500.0 + margin: False + """ name: str = "tRBTBTC" precision: int = 5 minimum_margin: float = 15.0 @@ -7013,11 +9763,20 @@ def __call__(self): return "tRBTBTC" -RBTBTC = RBTBTC() +RBTUSD = RBTUSD() @dataclass(slots=True, frozen=True) class RBTUSD: + """ + name: tRBTUSD + precision: 5 + minimum_margin: 15.0 + initial_margin: 30.0 + minimum_order_size: 0.00006 + maximum_order_size: 500.0 + margin: False + """ name: str = "tRBTUSD" precision: int = 5 minimum_margin: float = 15.0 @@ -7036,11 +9795,20 @@ def __call__(self): return "tRBTUSD" -RBTUSD = RBTUSD() +REEF_USD = REEF_USD() @dataclass(slots=True, frozen=True) class REEF_USD: + """ + name: tREEF:USD + precision: 5 + minimum_margin: 15.0 + initial_margin: 30.0 + minimum_order_size: 466.0 + maximum_order_size: 5000000.0 + margin: False + """ name: str = "tREEF:USD" precision: int = 5 minimum_margin: float = 15.0 @@ -7059,11 +9827,20 @@ def __call__(self): return "tREEF:USD" -REEF_USD = REEF_USD() +REEF_UST = REEF_UST() @dataclass(slots=True, frozen=True) class REEF_UST: + """ + name: tREEF:UST + precision: 5 + minimum_margin: 15.0 + initial_margin: 30.0 + minimum_order_size: 466.0 + maximum_order_size: 5000000.0 + margin: False + """ name: str = "tREEF:UST" precision: int = 5 minimum_margin: float = 15.0 @@ -7082,11 +9859,20 @@ def __call__(self): return "tREEF:UST" -REEF_UST = REEF_UST() +REPUSD = REPUSD() @dataclass(slots=True, frozen=True) class REPUSD: + """ + name: tREPUSD + precision: 5 + minimum_margin: 15.0 + initial_margin: 30.0 + minimum_order_size: 0.2 + maximum_order_size: 1000.0 + margin: False + """ name: str = "tREPUSD" precision: int = 5 minimum_margin: float = 15.0 @@ -7105,11 +9891,20 @@ def __call__(self): return "tREPUSD" -REPUSD = REPUSD() +REQUSD = REQUSD() @dataclass(slots=True, frozen=True) class REQUSD: + """ + name: tREQUSD + precision: 5 + minimum_margin: 15.0 + initial_margin: 30.0 + minimum_order_size: 16.0 + maximum_order_size: 100000.0 + margin: False + """ name: str = "tREQUSD" precision: int = 5 minimum_margin: float = 15.0 @@ -7128,11 +9923,20 @@ def __call__(self): return "tREQUSD" -REQUSD = REQUSD() +RLYUSD = RLYUSD() @dataclass(slots=True, frozen=True) class RLYUSD: + """ + name: tRLYUSD + precision: 5 + minimum_margin: 15.0 + initial_margin: 30.0 + minimum_order_size: 0.001 + maximum_order_size: 1000000.0 + margin: False + """ name: str = "tRLYUSD" precision: int = 5 minimum_margin: float = 15.0 @@ -7151,11 +9955,20 @@ def __call__(self): return "tRLYUSD" -RLYUSD = RLYUSD() +RLYUST = RLYUST() @dataclass(slots=True, frozen=True) class RLYUST: + """ + name: tRLYUST + precision: 5 + minimum_margin: 15.0 + initial_margin: 30.0 + minimum_order_size: 0.001 + maximum_order_size: 1000000.0 + margin: False + """ name: str = "tRLYUST" precision: int = 5 minimum_margin: float = 15.0 @@ -7174,11 +9987,20 @@ def __call__(self): return "tRLYUST" -RLYUST = RLYUST() +ROSE_USD = ROSE_USD() @dataclass(slots=True, frozen=True) class ROSE_USD: + """ + name: tROSE:USD + precision: 5 + minimum_margin: 15.0 + initial_margin: 30.0 + minimum_order_size: 32.0 + maximum_order_size: 100000.0 + margin: False + """ name: str = "tROSE:USD" precision: int = 5 minimum_margin: float = 15.0 @@ -7197,11 +10019,20 @@ def __call__(self): return "tROSE:USD" -ROSE_USD = ROSE_USD() +RRTUSD = RRTUSD() @dataclass(slots=True, frozen=True) class RRTUSD: + """ + name: tRRTUSD + precision: 5 + minimum_margin: 15.0 + initial_margin: 30.0 + minimum_order_size: 4.0 + maximum_order_size: 100000.0 + margin: False + """ name: str = "tRRTUSD" precision: int = 5 minimum_margin: float = 15.0 @@ -7220,11 +10051,20 @@ def __call__(self): return "tRRTUSD" -RRTUSD = RRTUSD() +SAND_USD = SAND_USD() @dataclass(slots=True, frozen=True) class SAND_USD: + """ + name: tSAND:USD + precision: 5 + minimum_margin: 15.0 + initial_margin: 30.0 + minimum_order_size: 2.0 + maximum_order_size: 250000.0 + margin: False + """ name: str = "tSAND:USD" precision: int = 5 minimum_margin: float = 15.0 @@ -7243,11 +10083,20 @@ def __call__(self): return "tSAND:USD" -SAND_USD = SAND_USD() +SAND_UST = SAND_UST() @dataclass(slots=True, frozen=True) class SAND_UST: + """ + name: tSAND:UST + precision: 5 + minimum_margin: 15.0 + initial_margin: 30.0 + minimum_order_size: 2.0 + maximum_order_size: 250000.0 + margin: False + """ name: str = "tSAND:UST" precision: int = 5 minimum_margin: float = 15.0 @@ -7266,11 +10115,20 @@ def __call__(self): return "tSAND:UST" -SAND_UST = SAND_UST() +SANDF0_USTF0 = SANDF0_USTF0() @dataclass(slots=True, frozen=True) class SANDF0_USTF0: + """ + name: tSANDF0:USTF0 + precision: 5 + minimum_margin: 0.5 + initial_margin: 1.0 + minimum_order_size: 2.0 + maximum_order_size: 250000.0 + margin: True + """ name: str = "tSANDF0:USTF0" precision: int = 5 minimum_margin: float = 0.5 @@ -7289,11 +10147,20 @@ def __call__(self): return "tSANDF0:USTF0" -SANDF0_USTF0 = SANDF0_USTF0() +SENATE_USD = SENATE_USD() @dataclass(slots=True, frozen=True) class SENATE_USD: + """ + name: tSENATE:USD + precision: 5 + minimum_margin: 15.0 + initial_margin: 30.0 + minimum_order_size: 20.0 + maximum_order_size: 500000.0 + margin: False + """ name: str = "tSENATE:USD" precision: int = 5 minimum_margin: float = 15.0 @@ -7312,11 +10179,20 @@ def __call__(self): return "tSENATE:USD" -SENATE_USD = SENATE_USD() +SENATE_UST = SENATE_UST() @dataclass(slots=True, frozen=True) class SENATE_UST: + """ + name: tSENATE:UST + precision: 5 + minimum_margin: 15.0 + initial_margin: 30.0 + minimum_order_size: 20.0 + maximum_order_size: 500000.0 + margin: False + """ name: str = "tSENATE:UST" precision: int = 5 minimum_margin: float = 15.0 @@ -7335,11 +10211,20 @@ def __call__(self): return "tSENATE:UST" -SENATE_UST = SENATE_UST() +SGBUSD = SGBUSD() @dataclass(slots=True, frozen=True) class SGBUSD: + """ + name: tSGBUSD + precision: 5 + minimum_margin: 15.0 + initial_margin: 30.0 + minimum_order_size: 52.0 + maximum_order_size: 5000000.0 + margin: False + """ name: str = "tSGBUSD" precision: int = 5 minimum_margin: float = 15.0 @@ -7358,11 +10243,20 @@ def __call__(self): return "tSGBUSD" -SGBUSD = SGBUSD() +SGBUST = SGBUST() @dataclass(slots=True, frozen=True) class SGBUST: + """ + name: tSGBUST + precision: 5 + minimum_margin: 15.0 + initial_margin: 30.0 + minimum_order_size: 52.0 + maximum_order_size: 5000000.0 + margin: False + """ name: str = "tSGBUST" precision: int = 5 minimum_margin: float = 15.0 @@ -7381,11 +10275,20 @@ def __call__(self): return "tSGBUST" -SGBUST = SGBUST() +SHFT_USD = SHFT_USD() @dataclass(slots=True, frozen=True) class SHFT_USD: + """ + name: tSHFT:USD + precision: 5 + minimum_margin: 15.0 + initial_margin: 30.0 + minimum_order_size: 52.0 + maximum_order_size: 500000.0 + margin: False + """ name: str = "tSHFT:USD" precision: int = 5 minimum_margin: float = 15.0 @@ -7404,11 +10307,20 @@ def __call__(self): return "tSHFT:USD" -SHFT_USD = SHFT_USD() +SHFT_UST = SHFT_UST() @dataclass(slots=True, frozen=True) class SHFT_UST: + """ + name: tSHFT:UST + precision: 5 + minimum_margin: 15.0 + initial_margin: 30.0 + minimum_order_size: 52.0 + maximum_order_size: 500000.0 + margin: False + """ name: str = "tSHFT:UST" precision: int = 5 minimum_margin: float = 15.0 @@ -7427,11 +10339,20 @@ def __call__(self): return "tSHFT:UST" -SHFT_UST = SHFT_UST() +SHIB_USD = SHIB_USD() @dataclass(slots=True, frozen=True) class SHIB_USD: + """ + name: tSHIB:USD + precision: 5 + minimum_margin: 15.0 + initial_margin: 30.0 + minimum_order_size: 187004.0 + maximum_order_size: 5000000000.0 + margin: True + """ name: str = "tSHIB:USD" precision: int = 5 minimum_margin: float = 15.0 @@ -7450,11 +10371,20 @@ def __call__(self): return "tSHIB:USD" -SHIB_USD = SHIB_USD() +SHIB_UST = SHIB_UST() @dataclass(slots=True, frozen=True) class SHIB_UST: + """ + name: tSHIB:UST + precision: 5 + minimum_margin: 15.0 + initial_margin: 30.0 + minimum_order_size: 187004.0 + maximum_order_size: 5000000000.0 + margin: True + """ name: str = "tSHIB:UST" precision: int = 5 minimum_margin: float = 15.0 @@ -7473,11 +10403,20 @@ def __call__(self): return "tSHIB:UST" -SHIB_UST = SHIB_UST() +SHIBF0_USTF0 = SHIBF0_USTF0() @dataclass(slots=True, frozen=True) class SHIBF0_USTF0: + """ + name: tSHIBF0:USTF0 + precision: 5 + minimum_margin: 0.5 + initial_margin: 1.0 + minimum_order_size: 187004.0 + maximum_order_size: 5000000000.0 + margin: True + """ name: str = "tSHIBF0:USTF0" precision: int = 5 minimum_margin: float = 0.5 @@ -7496,11 +10435,20 @@ def __call__(self): return "tSHIBF0:USTF0" -SHIBF0_USTF0 = SHIBF0_USTF0() +SIDUS_USD = SIDUS_USD() @dataclass(slots=True, frozen=True) class SIDUS_USD: + """ + name: tSIDUS:USD + precision: 5 + minimum_margin: 15.0 + initial_margin: 30.0 + minimum_order_size: 664.0 + maximum_order_size: 5000000.0 + margin: False + """ name: str = "tSIDUS:USD" precision: int = 5 minimum_margin: float = 15.0 @@ -7519,11 +10467,20 @@ def __call__(self): return "tSIDUS:USD" -SIDUS_USD = SIDUS_USD() +SMRUSD = SMRUSD() @dataclass(slots=True, frozen=True) class SMRUSD: + """ + name: tSMRUSD + precision: 5 + minimum_margin: 15.0 + initial_margin: 30.0 + minimum_order_size: 0.001 + maximum_order_size: 700000.0 + margin: False + """ name: str = "tSMRUSD" precision: int = 5 minimum_margin: float = 15.0 @@ -7542,11 +10499,20 @@ def __call__(self): return "tSMRUSD" -SMRUSD = SMRUSD() +SMRUST = SMRUST() @dataclass(slots=True, frozen=True) class SMRUST: + """ + name: tSMRUST + precision: 5 + minimum_margin: 15.0 + initial_margin: 30.0 + minimum_order_size: 0.001 + maximum_order_size: 700000.0 + margin: False + """ name: str = "tSMRUST" precision: int = 5 minimum_margin: float = 15.0 @@ -7565,11 +10531,20 @@ def __call__(self): return "tSMRUST" -SMRUST = SMRUST() +SNTUSD = SNTUSD() @dataclass(slots=True, frozen=True) class SNTUSD: + """ + name: tSNTUSD + precision: 5 + minimum_margin: 15.0 + initial_margin: 30.0 + minimum_order_size: 48.0 + maximum_order_size: 500000.0 + margin: False + """ name: str = "tSNTUSD" precision: int = 5 minimum_margin: float = 15.0 @@ -7588,11 +10563,20 @@ def __call__(self): return "tSNTUSD" -SNTUSD = SNTUSD() +SNXUSD = SNXUSD() @dataclass(slots=True, frozen=True) class SNXUSD: + """ + name: tSNXUSD + precision: 5 + minimum_margin: 15.0 + initial_margin: 30.0 + minimum_order_size: 0.8 + maximum_order_size: 50000.0 + margin: False + """ name: str = "tSNXUSD" precision: int = 5 minimum_margin: float = 15.0 @@ -7611,11 +10595,20 @@ def __call__(self): return "tSNXUSD" -SNXUSD = SNXUSD() +SNXUST = SNXUST() @dataclass(slots=True, frozen=True) class SNXUST: + """ + name: tSNXUST + precision: 5 + minimum_margin: 15.0 + initial_margin: 30.0 + minimum_order_size: 0.8 + maximum_order_size: 50000.0 + margin: False + """ name: str = "tSNXUST" precision: int = 5 minimum_margin: float = 15.0 @@ -7634,11 +10627,20 @@ def __call__(self): return "tSNXUST" -SNXUST = SNXUST() +SOLBTC = SOLBTC() @dataclass(slots=True, frozen=True) class SOLBTC: + """ + name: tSOLBTC + precision: 5 + minimum_margin: 15.0 + initial_margin: 30.0 + minimum_order_size: 0.06 + maximum_order_size: 50000.0 + margin: True + """ name: str = "tSOLBTC" precision: int = 5 minimum_margin: float = 15.0 @@ -7657,11 +10659,20 @@ def __call__(self): return "tSOLBTC" -SOLBTC = SOLBTC() +SOLF0_BTCF0 = SOLF0_BTCF0() @dataclass(slots=True, frozen=True) class SOLF0_BTCF0: + """ + name: tSOLF0:BTCF0 + precision: 5 + minimum_margin: 2.5 + initial_margin: 5.0 + minimum_order_size: 0.06 + maximum_order_size: 50000.0 + margin: True + """ name: str = "tSOLF0:BTCF0" precision: int = 5 minimum_margin: float = 2.5 @@ -7680,11 +10691,20 @@ def __call__(self): return "tSOLF0:BTCF0" -SOLF0_BTCF0 = SOLF0_BTCF0() +SOLF0_USTF0 = SOLF0_USTF0() @dataclass(slots=True, frozen=True) class SOLF0_USTF0: + """ + name: tSOLF0:USTF0 + precision: 5 + minimum_margin: 2.5 + initial_margin: 5.0 + minimum_order_size: 0.06 + maximum_order_size: 10000.0 + margin: True + """ name: str = "tSOLF0:USTF0" precision: int = 5 minimum_margin: float = 2.5 @@ -7703,11 +10723,20 @@ def __call__(self): return "tSOLF0:USTF0" -SOLF0_USTF0 = SOLF0_USTF0() +SOLUSD = SOLUSD() @dataclass(slots=True, frozen=True) class SOLUSD: + """ + name: tSOLUSD + precision: 5 + minimum_margin: 15.0 + initial_margin: 30.0 + minimum_order_size: 0.06 + maximum_order_size: 50000.0 + margin: True + """ name: str = "tSOLUSD" precision: int = 5 minimum_margin: float = 15.0 @@ -7726,11 +10755,20 @@ def __call__(self): return "tSOLUSD" -SOLUSD = SOLUSD() +SOLUST = SOLUST() @dataclass(slots=True, frozen=True) class SOLUST: + """ + name: tSOLUST + precision: 5 + minimum_margin: 15.0 + initial_margin: 30.0 + minimum_order_size: 0.06 + maximum_order_size: 50000.0 + margin: True + """ name: str = "tSOLUST" precision: int = 5 minimum_margin: float = 15.0 @@ -7749,11 +10787,20 @@ def __call__(self): return "tSOLUST" -SOLUST = SOLUST() +SPELL_USD = SPELL_USD() @dataclass(slots=True, frozen=True) class SPELL_USD: + """ + name: tSPELL:USD + precision: 5 + minimum_margin: 15.0 + initial_margin: 30.0 + minimum_order_size: 1640.0 + maximum_order_size: 2500000.0 + margin: False + """ name: str = "tSPELL:USD" precision: int = 5 minimum_margin: float = 15.0 @@ -7772,11 +10819,20 @@ def __call__(self): return "tSPELL:USD" -SPELL_USD = SPELL_USD() +SPELL_UST = SPELL_UST() @dataclass(slots=True, frozen=True) class SPELL_UST: + """ + name: tSPELL:UST + precision: 5 + minimum_margin: 15.0 + initial_margin: 30.0 + minimum_order_size: 1640.0 + maximum_order_size: 2500000.0 + margin: False + """ name: str = "tSPELL:UST" precision: int = 5 minimum_margin: float = 15.0 @@ -7795,11 +10851,20 @@ def __call__(self): return "tSPELL:UST" -SPELL_UST = SPELL_UST() +STGF0_USTF0 = STGF0_USTF0() @dataclass(slots=True, frozen=True) class STGF0_USTF0: + """ + name: tSTGF0:USTF0 + precision: 5 + minimum_margin: 0.5 + initial_margin: 1.0 + minimum_order_size: 4.0 + maximum_order_size: 250000.0 + margin: True + """ name: str = "tSTGF0:USTF0" precision: int = 5 minimum_margin: float = 0.5 @@ -7818,11 +10883,20 @@ def __call__(self): return "tSTGF0:USTF0" -STGF0_USTF0 = STGF0_USTF0() +STGUSD = STGUSD() @dataclass(slots=True, frozen=True) class STGUSD: + """ + name: tSTGUSD + precision: 5 + minimum_margin: 15.0 + initial_margin: 30.0 + minimum_order_size: 4.0 + maximum_order_size: 250000.0 + margin: False + """ name: str = "tSTGUSD" precision: int = 5 minimum_margin: float = 15.0 @@ -7841,11 +10915,20 @@ def __call__(self): return "tSTGUSD" -STGUSD = STGUSD() +STGUST = STGUST() @dataclass(slots=True, frozen=True) class STGUST: + """ + name: tSTGUST + precision: 5 + minimum_margin: 15.0 + initial_margin: 30.0 + minimum_order_size: 4.0 + maximum_order_size: 250000.0 + margin: False + """ name: str = "tSTGUST" precision: int = 5 minimum_margin: float = 15.0 @@ -7864,11 +10947,20 @@ def __call__(self): return "tSTGUST" -STGUST = STGUST() +STJUSD = STJUSD() @dataclass(slots=True, frozen=True) class STJUSD: + """ + name: tSTJUSD + precision: 5 + minimum_margin: 15.0 + initial_margin: 30.0 + minimum_order_size: 4.0 + maximum_order_size: 30000.0 + margin: False + """ name: str = "tSTJUSD" precision: int = 5 minimum_margin: float = 15.0 @@ -7887,11 +10979,20 @@ def __call__(self): return "tSTJUSD" -STJUSD = STJUSD() +SUKU_USD = SUKU_USD() @dataclass(slots=True, frozen=True) class SUKU_USD: + """ + name: tSUKU:USD + precision: 5 + minimum_margin: 15.0 + initial_margin: 30.0 + minimum_order_size: 18.0 + maximum_order_size: 250000.0 + margin: False + """ name: str = "tSUKU:USD" precision: int = 5 minimum_margin: float = 15.0 @@ -7910,11 +11011,20 @@ def __call__(self): return "tSUKU:USD" -SUKU_USD = SUKU_USD() +SUKU_UST = SUKU_UST() @dataclass(slots=True, frozen=True) class SUKU_UST: + """ + name: tSUKU:UST + precision: 5 + minimum_margin: 15.0 + initial_margin: 30.0 + minimum_order_size: 18.0 + maximum_order_size: 250000.0 + margin: False + """ name: str = "tSUKU:UST" precision: int = 5 minimum_margin: float = 15.0 @@ -7933,11 +11043,20 @@ def __call__(self): return "tSUKU:UST" -SUKU_UST = SUKU_UST() +SUNUSD = SUNUSD() @dataclass(slots=True, frozen=True) class SUNUSD: + """ + name: tSUNUSD + precision: 5 + minimum_margin: 15.0 + initial_margin: 30.0 + minimum_order_size: 216.0 + maximum_order_size: 10000000.0 + margin: False + """ name: str = "tSUNUSD" precision: int = 5 minimum_margin: float = 15.0 @@ -7956,11 +11075,20 @@ def __call__(self): return "tSUNUSD" -SUNUSD = SUNUSD() +SUNUST = SUNUST() @dataclass(slots=True, frozen=True) class SUNUST: + """ + name: tSUNUST + precision: 5 + minimum_margin: 15.0 + initial_margin: 30.0 + minimum_order_size: 216.0 + maximum_order_size: 10000000.0 + margin: False + """ name: str = "tSUNUST" precision: int = 5 minimum_margin: float = 15.0 @@ -7979,11 +11107,20 @@ def __call__(self): return "tSUNUST" -SUNUST = SUNUST() +SUSHI_USD = SUSHI_USD() @dataclass(slots=True, frozen=True) class SUSHI_USD: + """ + name: tSUSHI:USD + precision: 5 + minimum_margin: 15.0 + initial_margin: 30.0 + minimum_order_size: 2.0 + maximum_order_size: 50000.0 + margin: True + """ name: str = "tSUSHI:USD" precision: int = 5 minimum_margin: float = 15.0 @@ -8002,11 +11139,20 @@ def __call__(self): return "tSUSHI:USD" -SUSHI_USD = SUSHI_USD() +SUSHI_UST = SUSHI_UST() @dataclass(slots=True, frozen=True) class SUSHI_UST: + """ + name: tSUSHI:UST + precision: 5 + minimum_margin: 15.0 + initial_margin: 30.0 + minimum_order_size: 2.0 + maximum_order_size: 50000.0 + margin: True + """ name: str = "tSUSHI:UST" precision: int = 5 minimum_margin: float = 15.0 @@ -8025,11 +11171,20 @@ def __call__(self): return "tSUSHI:UST" -SUSHI_UST = SUSHI_UST() +SUSHIF0_USTF0 = SUSHIF0_USTF0() @dataclass(slots=True, frozen=True) class SUSHIF0_USTF0: + """ + name: tSUSHIF0:USTF0 + precision: 5 + minimum_margin: 0.5 + initial_margin: 1.0 + minimum_order_size: 2.0 + maximum_order_size: 10000.0 + margin: True + """ name: str = "tSUSHIF0:USTF0" precision: int = 5 minimum_margin: float = 0.5 @@ -8048,11 +11203,20 @@ def __call__(self): return "tSUSHIF0:USTF0" -SUSHIF0_USTF0 = SUSHIF0_USTF0() +SWEAT_USD = SWEAT_USD() @dataclass(slots=True, frozen=True) class SWEAT_USD: + """ + name: tSWEAT:USD + precision: 5 + minimum_margin: 15.0 + initial_margin: 30.0 + minimum_order_size: 0.001 + maximum_order_size: 7000000.0 + margin: False + """ name: str = "tSWEAT:USD" precision: int = 5 minimum_margin: float = 15.0 @@ -8071,11 +11235,20 @@ def __call__(self): return "tSWEAT:USD" -SWEAT_USD = SWEAT_USD() +SWEAT_UST = SWEAT_UST() @dataclass(slots=True, frozen=True) class SWEAT_UST: + """ + name: tSWEAT:UST + precision: 5 + minimum_margin: 15.0 + initial_margin: 30.0 + minimum_order_size: 0.001 + maximum_order_size: 7000000.0 + margin: False + """ name: str = "tSWEAT:UST" precision: int = 5 minimum_margin: float = 15.0 @@ -8094,11 +11267,20 @@ def __call__(self): return "tSWEAT:UST" -SWEAT_UST = SWEAT_UST() +SXXUSD = SXXUSD() @dataclass(slots=True, frozen=True) class SXXUSD: + """ + name: tSXXUSD + precision: 5 + minimum_margin: 15.0 + initial_margin: 30.0 + minimum_order_size: 8.0 + maximum_order_size: 2500000.0 + margin: False + """ name: str = "tSXXUSD" precision: int = 5 minimum_margin: float = 15.0 @@ -8117,11 +11299,20 @@ def __call__(self): return "tSXXUSD" -SXXUSD = SXXUSD() +SXXUST = SXXUST() @dataclass(slots=True, frozen=True) class SXXUST: + """ + name: tSXXUST + precision: 5 + minimum_margin: 15.0 + initial_margin: 30.0 + minimum_order_size: 8.0 + maximum_order_size: 2500000.0 + margin: False + """ name: str = "tSXXUST" precision: int = 5 minimum_margin: float = 15.0 @@ -8140,11 +11331,20 @@ def __call__(self): return "tSXXUST" -SXXUST = SXXUST() +TERRAUST_USD = TERRAUST_USD() @dataclass(slots=True, frozen=True) class TERRAUST_USD: + """ + name: tTERRAUST:USD + precision: 5 + minimum_margin: 15.0 + initial_margin: 30.0 + minimum_order_size: 100.0 + maximum_order_size: 250000.0 + margin: False + """ name: str = "tTERRAUST:USD" precision: int = 5 minimum_margin: float = 15.0 @@ -8163,11 +11363,20 @@ def __call__(self): return "tTERRAUST:USD" -TERRAUST_USD = TERRAUST_USD() +TESTBTC_TESTUSD = TESTBTC_TESTUSD() @dataclass(slots=True, frozen=True) class TESTBTC_TESTUSD: + """ + name: tTESTBTC:TESTUSD + precision: 5 + minimum_margin: 15.0 + initial_margin: 30.0 + minimum_order_size: 0.00006 + maximum_order_size: 100.0 + margin: True + """ name: str = "tTESTBTC:TESTUSD" precision: int = 5 minimum_margin: float = 15.0 @@ -8186,11 +11395,20 @@ def __call__(self): return "tTESTBTC:TESTUSD" -TESTBTC_TESTUSD = TESTBTC_TESTUSD() +TESTBTC_TESTUSDT = TESTBTC_TESTUSDT() @dataclass(slots=True, frozen=True) class TESTBTC_TESTUSDT: + """ + name: tTESTBTC:TESTUSDT + precision: 5 + minimum_margin: 15.0 + initial_margin: 30.0 + minimum_order_size: 0.00006 + maximum_order_size: 100.0 + margin: True + """ name: str = "tTESTBTC:TESTUSDT" precision: int = 5 minimum_margin: float = 15.0 @@ -8209,11 +11427,20 @@ def __call__(self): return "tTESTBTC:TESTUSDT" -TESTBTC_TESTUSDT = TESTBTC_TESTUSDT() +TESTBTCF0_TESTUSDTF0 = TESTBTCF0_TESTUSDTF0() @dataclass(slots=True, frozen=True) class TESTBTCF0_TESTUSDTF0: + """ + name: tTESTBTCF0:TESTUSDTF0 + precision: 5 + minimum_margin: 0.5 + initial_margin: 1.0 + minimum_order_size: 0.00006 + maximum_order_size: 1000.0 + margin: True + """ name: str = "tTESTBTCF0:TESTUSDTF0" precision: int = 5 minimum_margin: float = 0.5 @@ -8232,11 +11459,20 @@ def __call__(self): return "tTESTBTCF0:TESTUSDTF0" -TESTBTCF0_TESTUSDTF0 = TESTBTCF0_TESTUSDTF0() +THETA_USD = THETA_USD() @dataclass(slots=True, frozen=True) class THETA_USD: + """ + name: tTHETA:USD + precision: 5 + minimum_margin: 15.0 + initial_margin: 30.0 + minimum_order_size: 2.0 + maximum_order_size: 50000.0 + margin: False + """ name: str = "tTHETA:USD" precision: int = 5 minimum_margin: float = 15.0 @@ -8255,11 +11491,20 @@ def __call__(self): return "tTHETA:USD" -THETA_USD = THETA_USD() +THETA_UST = THETA_UST() @dataclass(slots=True, frozen=True) class THETA_UST: + """ + name: tTHETA:UST + precision: 5 + minimum_margin: 15.0 + initial_margin: 30.0 + minimum_order_size: 2.0 + maximum_order_size: 50000.0 + margin: False + """ name: str = "tTHETA:UST" precision: int = 5 minimum_margin: float = 15.0 @@ -8278,11 +11523,20 @@ def __call__(self): return "tTHETA:UST" -THETA_UST = THETA_UST() +TLOS_USD = TLOS_USD() @dataclass(slots=True, frozen=True) class TLOS_USD: + """ + name: tTLOS:USD + precision: 5 + minimum_margin: 15.0 + initial_margin: 30.0 + minimum_order_size: 8.0 + maximum_order_size: 50000.0 + margin: False + """ name: str = "tTLOS:USD" precision: int = 5 minimum_margin: float = 15.0 @@ -8301,11 +11555,20 @@ def __call__(self): return "tTLOS:USD" -TLOS_USD = TLOS_USD() +TRADE_USD = TRADE_USD() @dataclass(slots=True, frozen=True) class TRADE_USD: + """ + name: tTRADE:USD + precision: 5 + minimum_margin: 15.0 + initial_margin: 30.0 + minimum_order_size: 28.0 + maximum_order_size: 2500000.0 + margin: False + """ name: str = "tTRADE:USD" precision: int = 5 minimum_margin: float = 15.0 @@ -8324,11 +11587,20 @@ def __call__(self): return "tTRADE:USD" -TRADE_USD = TRADE_USD() +TRADE_UST = TRADE_UST() @dataclass(slots=True, frozen=True) class TRADE_UST: + """ + name: tTRADE:UST + precision: 5 + minimum_margin: 15.0 + initial_margin: 30.0 + minimum_order_size: 28.0 + maximum_order_size: 2500000.0 + margin: False + """ name: str = "tTRADE:UST" precision: int = 5 minimum_margin: float = 15.0 @@ -8347,11 +11619,20 @@ def __call__(self): return "tTRADE:UST" -TRADE_UST = TRADE_UST() +TREEB_USD = TREEB_USD() @dataclass(slots=True, frozen=True) class TREEB_USD: + """ + name: tTREEB:USD + precision: 5 + minimum_margin: 15.0 + initial_margin: 30.0 + minimum_order_size: 0.001 + maximum_order_size: 3000000.0 + margin: False + """ name: str = "tTREEB:USD" precision: int = 5 minimum_margin: float = 15.0 @@ -8370,11 +11651,20 @@ def __call__(self): return "tTREEB:USD" -TREEB_USD = TREEB_USD() +TREEB_UST = TREEB_UST() @dataclass(slots=True, frozen=True) class TREEB_UST: + """ + name: tTREEB:UST + precision: 5 + minimum_margin: 15.0 + initial_margin: 30.0 + minimum_order_size: 0.001 + maximum_order_size: 3000000.0 + margin: False + """ name: str = "tTREEB:UST" precision: int = 5 minimum_margin: float = 15.0 @@ -8393,11 +11683,20 @@ def __call__(self): return "tTREEB:UST" -TREEB_UST = TREEB_UST() +TRXBTC = TRXBTC() @dataclass(slots=True, frozen=True) class TRXBTC: + """ + name: tTRXBTC + precision: 5 + minimum_margin: 15.0 + initial_margin: 30.0 + minimum_order_size: 34.0 + maximum_order_size: 1000000.0 + margin: False + """ name: str = "tTRXBTC" precision: int = 5 minimum_margin: float = 15.0 @@ -8416,11 +11715,20 @@ def __call__(self): return "tTRXBTC" -TRXBTC = TRXBTC() +TRXETH = TRXETH() @dataclass(slots=True, frozen=True) class TRXETH: + """ + name: tTRXETH + precision: 5 + minimum_margin: 15.0 + initial_margin: 30.0 + minimum_order_size: 34.0 + maximum_order_size: 1000000.0 + margin: False + """ name: str = "tTRXETH" precision: int = 5 minimum_margin: float = 15.0 @@ -8439,11 +11747,20 @@ def __call__(self): return "tTRXETH" -TRXETH = TRXETH() +TRXEUR = TRXEUR() @dataclass(slots=True, frozen=True) class TRXEUR: + """ + name: tTRXEUR + precision: 5 + minimum_margin: 15.0 + initial_margin: 30.0 + minimum_order_size: 34.0 + maximum_order_size: 1000000.0 + margin: False + """ name: str = "tTRXEUR" precision: int = 5 minimum_margin: float = 15.0 @@ -8462,11 +11779,20 @@ def __call__(self): return "tTRXEUR" -TRXEUR = TRXEUR() +TRXF0_USTF0 = TRXF0_USTF0() @dataclass(slots=True, frozen=True) class TRXF0_USTF0: + """ + name: tTRXF0:USTF0 + precision: 5 + minimum_margin: 0.5 + initial_margin: 1.0 + minimum_order_size: 24.0 + maximum_order_size: 1000000.0 + margin: True + """ name: str = "tTRXF0:USTF0" precision: int = 5 minimum_margin: float = 0.5 @@ -8485,11 +11811,20 @@ def __call__(self): return "tTRXF0:USTF0" -TRXF0_USTF0 = TRXF0_USTF0() +TRXUSD = TRXUSD() @dataclass(slots=True, frozen=True) class TRXUSD: + """ + name: tTRXUSD + precision: 5 + minimum_margin: 15.0 + initial_margin: 30.0 + minimum_order_size: 34.0 + maximum_order_size: 1000000.0 + margin: True + """ name: str = "tTRXUSD" precision: int = 5 minimum_margin: float = 15.0 @@ -8508,11 +11843,20 @@ def __call__(self): return "tTRXUSD" -TRXUSD = TRXUSD() +TRXUST = TRXUST() @dataclass(slots=True, frozen=True) class TRXUST: + """ + name: tTRXUST + precision: 5 + minimum_margin: 15.0 + initial_margin: 30.0 + minimum_order_size: 24.0 + maximum_order_size: 1000000.0 + margin: True + """ name: str = "tTRXUST" precision: int = 5 minimum_margin: float = 15.0 @@ -8531,11 +11875,20 @@ def __call__(self): return "tTRXUST" -TRXUST = TRXUST() +TRYUST = TRYUST() @dataclass(slots=True, frozen=True) class TRYUST: + """ + name: tTRYUST + precision: 5 + minimum_margin: 15.0 + initial_margin: 30.0 + minimum_order_size: 0.001 + maximum_order_size: 5000000.0 + margin: False + """ name: str = "tTRYUST" precision: int = 5 minimum_margin: float = 15.0 @@ -8554,11 +11907,20 @@ def __call__(self): return "tTRYUST" -TRYUST = TRYUST() +TSDUSD = TSDUSD() @dataclass(slots=True, frozen=True) class TSDUSD: + """ + name: tTSDUSD + precision: 5 + minimum_margin: 15.0 + initial_margin: 30.0 + minimum_order_size: 2.0 + maximum_order_size: 1000000.0 + margin: False + """ name: str = "tTSDUSD" precision: int = 5 minimum_margin: float = 15.0 @@ -8577,11 +11939,20 @@ def __call__(self): return "tTSDUSD" -TSDUSD = TSDUSD() +TSDUST = TSDUST() @dataclass(slots=True, frozen=True) class TSDUST: + """ + name: tTSDUST + precision: 5 + minimum_margin: 15.0 + initial_margin: 30.0 + minimum_order_size: 2.0 + maximum_order_size: 50000.0 + margin: False + """ name: str = "tTSDUST" precision: int = 5 minimum_margin: float = 15.0 @@ -8600,11 +11971,20 @@ def __call__(self): return "tTSDUST" -TSDUST = TSDUST() +UDCUSD = UDCUSD() @dataclass(slots=True, frozen=True) class UDCUSD: + """ + name: tUDCUSD + precision: 5 + minimum_margin: 15.0 + initial_margin: 30.0 + minimum_order_size: 2.0 + maximum_order_size: 1000000.0 + margin: False + """ name: str = "tUDCUSD" precision: int = 5 minimum_margin: float = 15.0 @@ -8623,11 +12003,20 @@ def __call__(self): return "tUDCUSD" -UDCUSD = UDCUSD() +UDCUST = UDCUST() @dataclass(slots=True, frozen=True) class UDCUST: + """ + name: tUDCUST + precision: 5 + minimum_margin: 15.0 + initial_margin: 30.0 + minimum_order_size: 2.0 + maximum_order_size: 500000.0 + margin: False + """ name: str = "tUDCUST" precision: int = 5 minimum_margin: float = 15.0 @@ -8646,11 +12035,20 @@ def __call__(self): return "tUDCUST" -UDCUST = UDCUST() +UNIF0_USTF0 = UNIF0_USTF0() @dataclass(slots=True, frozen=True) class UNIF0_USTF0: + """ + name: tUNIF0:USTF0 + precision: 5 + minimum_margin: 0.5 + initial_margin: 1.0 + minimum_order_size: 0.4 + maximum_order_size: 250000.0 + margin: True + """ name: str = "tUNIF0:USTF0" precision: int = 5 minimum_margin: float = 0.5 @@ -8669,11 +12067,20 @@ def __call__(self): return "tUNIF0:USTF0" -UNIF0_USTF0 = UNIF0_USTF0() +UNIUSD = UNIUSD() @dataclass(slots=True, frozen=True) class UNIUSD: + """ + name: tUNIUSD + precision: 5 + minimum_margin: 15.0 + initial_margin: 30.0 + minimum_order_size: 0.4 + maximum_order_size: 50000.0 + margin: True + """ name: str = "tUNIUSD" precision: int = 5 minimum_margin: float = 15.0 @@ -8692,11 +12099,20 @@ def __call__(self): return "tUNIUSD" -UNIUSD = UNIUSD() +UNIUST = UNIUST() @dataclass(slots=True, frozen=True) class UNIUST: + """ + name: tUNIUST + precision: 5 + minimum_margin: 15.0 + initial_margin: 30.0 + minimum_order_size: 0.4 + maximum_order_size: 50000.0 + margin: True + """ name: str = "tUNIUST" precision: int = 5 minimum_margin: float = 15.0 @@ -8715,11 +12131,20 @@ def __call__(self): return "tUNIUST" -UNIUST = UNIUST() +UOSBTC = UOSBTC() @dataclass(slots=True, frozen=True) class UOSBTC: + """ + name: tUOSBTC + precision: 5 + minimum_margin: 15.0 + initial_margin: 30.0 + minimum_order_size: 4.0 + maximum_order_size: 400000.0 + margin: False + """ name: str = "tUOSBTC" precision: int = 5 minimum_margin: float = 15.0 @@ -8738,11 +12163,20 @@ def __call__(self): return "tUOSBTC" -UOSBTC = UOSBTC() +UOSUSD = UOSUSD() @dataclass(slots=True, frozen=True) class UOSUSD: + """ + name: tUOSUSD + precision: 5 + minimum_margin: 15.0 + initial_margin: 30.0 + minimum_order_size: 4.0 + maximum_order_size: 400000.0 + margin: False + """ name: str = "tUOSUSD" precision: int = 5 minimum_margin: float = 15.0 @@ -8761,11 +12195,20 @@ def __call__(self): return "tUOSUSD" -UOSUSD = UOSUSD() +UST_CNHT = UST_CNHT() @dataclass(slots=True, frozen=True) class UST_CNHT: + """ + name: tUST:CNHT + precision: 5 + minimum_margin: 15.0 + initial_margin: 30.0 + minimum_order_size: 2.0 + maximum_order_size: 50000.0 + margin: False + """ name: str = "tUST:CNHT" precision: int = 5 minimum_margin: float = 15.0 @@ -8784,11 +12227,20 @@ def __call__(self): return "tUST:CNHT" -UST_CNHT = UST_CNHT() +UST_MXNT = UST_MXNT() @dataclass(slots=True, frozen=True) class UST_MXNT: + """ + name: tUST:MXNT + precision: 5 + minimum_margin: 15.0 + initial_margin: 30.0 + minimum_order_size: 0.001 + maximum_order_size: 10000000.0 + margin: False + """ name: str = "tUST:MXNT" precision: int = 5 minimum_margin: float = 15.0 @@ -8807,11 +12259,20 @@ def __call__(self): return "tUST:MXNT" -UST_MXNT = UST_MXNT() +USTUSD = USTUSD() @dataclass(slots=True, frozen=True) class USTUSD: + """ + name: tUSTUSD + precision: 5 + minimum_margin: 5.0 + initial_margin: 10.0 + minimum_order_size: 2.0 + maximum_order_size: 5000000.0 + margin: True + """ name: str = "tUSTUSD" precision: int = 5 minimum_margin: float = 5.0 @@ -8830,11 +12291,20 @@ def __call__(self): return "tUSTUSD" -USTUSD = USTUSD() +UTKUSD = UTKUSD() @dataclass(slots=True, frozen=True) class UTKUSD: + """ + name: tUTKUSD + precision: 5 + minimum_margin: 15.0 + initial_margin: 30.0 + minimum_order_size: 10.0 + maximum_order_size: 300000.0 + margin: False + """ name: str = "tUTKUSD" precision: int = 5 minimum_margin: float = 15.0 @@ -8853,11 +12323,20 @@ def __call__(self): return "tUTKUSD" -UTKUSD = UTKUSD() +VEEUSD = VEEUSD() @dataclass(slots=True, frozen=True) class VEEUSD: + """ + name: tVEEUSD + precision: 5 + minimum_margin: 15.0 + initial_margin: 30.0 + minimum_order_size: 1258.0 + maximum_order_size: 15000000.0 + margin: False + """ name: str = "tVEEUSD" precision: int = 5 minimum_margin: float = 15.0 @@ -8876,11 +12355,20 @@ def __call__(self): return "tVEEUSD" -VEEUSD = VEEUSD() +VELO_USD = VELO_USD() @dataclass(slots=True, frozen=True) class VELO_USD: + """ + name: tVELO:USD + precision: 5 + minimum_margin: 15.0 + initial_margin: 30.0 + minimum_order_size: 66.0 + maximum_order_size: 75000.0 + margin: False + """ name: str = "tVELO:USD" precision: int = 5 minimum_margin: float = 15.0 @@ -8899,11 +12387,20 @@ def __call__(self): return "tVELO:USD" -VELO_USD = VELO_USD() +VELO_UST = VELO_UST() @dataclass(slots=True, frozen=True) class VELO_UST: + """ + name: tVELO:UST + precision: 5 + minimum_margin: 15.0 + initial_margin: 30.0 + minimum_order_size: 66.0 + maximum_order_size: 75000.0 + margin: False + """ name: str = "tVELO:UST" precision: int = 5 minimum_margin: float = 15.0 @@ -8922,11 +12419,20 @@ def __call__(self): return "tVELO:UST" -VELO_UST = VELO_UST() +VETBTC = VETBTC() @dataclass(slots=True, frozen=True) class VETBTC: + """ + name: tVETBTC + precision: 5 + minimum_margin: 15.0 + initial_margin: 30.0 + minimum_order_size: 66.0 + maximum_order_size: 5000000.0 + margin: False + """ name: str = "tVETBTC" precision: int = 5 minimum_margin: float = 15.0 @@ -8945,11 +12451,20 @@ def __call__(self): return "tVETBTC" -VETBTC = VETBTC() +VETUSD = VETUSD() @dataclass(slots=True, frozen=True) class VETUSD: + """ + name: tVETUSD + precision: 5 + minimum_margin: 15.0 + initial_margin: 30.0 + minimum_order_size: 66.0 + maximum_order_size: 5000000.0 + margin: False + """ name: str = "tVETUSD" precision: int = 5 minimum_margin: float = 15.0 @@ -8968,11 +12483,20 @@ def __call__(self): return "tVETUSD" -VETUSD = VETUSD() +VETUST = VETUST() @dataclass(slots=True, frozen=True) class VETUST: + """ + name: tVETUST + precision: 5 + minimum_margin: 15.0 + initial_margin: 30.0 + minimum_order_size: 66.0 + maximum_order_size: 5000000.0 + margin: False + """ name: str = "tVETUST" precision: int = 5 minimum_margin: float = 15.0 @@ -8991,11 +12515,20 @@ def __call__(self): return "tVETUST" -VETUST = VETUST() +VRAUSD = VRAUSD() @dataclass(slots=True, frozen=True) class VRAUSD: + """ + name: tVRAUSD + precision: 5 + minimum_margin: 15.0 + initial_margin: 30.0 + minimum_order_size: 286.0 + maximum_order_size: 1000000.0 + margin: False + """ name: str = "tVRAUSD" precision: int = 5 minimum_margin: float = 15.0 @@ -9014,11 +12547,20 @@ def __call__(self): return "tVRAUSD" -VRAUSD = VRAUSD() +VRAUST = VRAUST() @dataclass(slots=True, frozen=True) class VRAUST: + """ + name: tVRAUST + precision: 5 + minimum_margin: 15.0 + initial_margin: 30.0 + minimum_order_size: 286.0 + maximum_order_size: 1000000.0 + margin: False + """ name: str = "tVRAUST" precision: int = 5 minimum_margin: float = 15.0 @@ -9037,11 +12579,20 @@ def __call__(self): return "tVRAUST" -VRAUST = VRAUST() +VSYUSD = VSYUSD() @dataclass(slots=True, frozen=True) class VSYUSD: + """ + name: tVSYUSD + precision: 5 + minimum_margin: 15.0 + initial_margin: 30.0 + minimum_order_size: 432.0 + maximum_order_size: 250000.0 + margin: False + """ name: str = "tVSYUSD" precision: int = 5 minimum_margin: float = 15.0 @@ -9060,11 +12611,20 @@ def __call__(self): return "tVSYUSD" -VSYUSD = VSYUSD() +WAVES_USD = WAVES_USD() @dataclass(slots=True, frozen=True) class WAVES_USD: + """ + name: tWAVES:USD + precision: 5 + minimum_margin: 15.0 + initial_margin: 30.0 + minimum_order_size: 0.2 + maximum_order_size: 50000.0 + margin: False + """ name: str = "tWAVES:USD" precision: int = 5 minimum_margin: float = 15.0 @@ -9083,11 +12643,20 @@ def __call__(self): return "tWAVES:USD" -WAVES_USD = WAVES_USD() +WAVES_UST = WAVES_UST() @dataclass(slots=True, frozen=True) class WAVES_UST: + """ + name: tWAVES:UST + precision: 5 + minimum_margin: 15.0 + initial_margin: 30.0 + minimum_order_size: 0.2 + maximum_order_size: 50000.0 + margin: False + """ name: str = "tWAVES:UST" precision: int = 5 minimum_margin: float = 15.0 @@ -9106,11 +12675,20 @@ def __call__(self): return "tWAVES:UST" -WAVES_UST = WAVES_UST() +WAVESF0_USTF0 = WAVESF0_USTF0() @dataclass(slots=True, frozen=True) class WAVESF0_USTF0: + """ + name: tWAVESF0:USTF0 + precision: 5 + minimum_margin: 0.5 + initial_margin: 1.0 + minimum_order_size: 0.2 + maximum_order_size: 50000.0 + margin: True + """ name: str = "tWAVESF0:USTF0" precision: int = 5 minimum_margin: float = 0.5 @@ -9129,11 +12707,20 @@ def __call__(self): return "tWAVESF0:USTF0" -WAVESF0_USTF0 = WAVESF0_USTF0() +WAXUSD = WAXUSD() @dataclass(slots=True, frozen=True) class WAXUSD: + """ + name: tWAXUSD + precision: 5 + minimum_margin: 15.0 + initial_margin: 30.0 + minimum_order_size: 16.0 + maximum_order_size: 50000.0 + margin: False + """ name: str = "tWAXUSD" precision: int = 5 minimum_margin: float = 15.0 @@ -9152,11 +12739,20 @@ def __call__(self): return "tWAXUSD" -WAXUSD = WAXUSD() +WBTBTC = WBTBTC() @dataclass(slots=True, frozen=True) class WBTBTC: + """ + name: tWBTBTC + precision: 5 + minimum_margin: 15.0 + initial_margin: 30.0 + minimum_order_size: 0.001 + maximum_order_size: 10.0 + margin: False + """ name: str = "tWBTBTC" precision: int = 5 minimum_margin: float = 15.0 @@ -9175,11 +12771,20 @@ def __call__(self): return "tWBTBTC" -WBTBTC = WBTBTC() +WBTUSD = WBTUSD() @dataclass(slots=True, frozen=True) class WBTUSD: + """ + name: tWBTUSD + precision: 5 + minimum_margin: 15.0 + initial_margin: 30.0 + minimum_order_size: 0.00006 + maximum_order_size: 10.0 + margin: False + """ name: str = "tWBTUSD" precision: int = 5 minimum_margin: float = 15.0 @@ -9198,11 +12803,20 @@ def __call__(self): return "tWBTUSD" -WBTUSD = WBTUSD() +WILD_USD = WILD_USD() @dataclass(slots=True, frozen=True) class WILD_USD: + """ + name: tWILD:USD + precision: 5 + minimum_margin: 15.0 + initial_margin: 30.0 + minimum_order_size: 6.0 + maximum_order_size: 50000.0 + margin: False + """ name: str = "tWILD:USD" precision: int = 5 minimum_margin: float = 15.0 @@ -9221,11 +12835,20 @@ def __call__(self): return "tWILD:USD" -WILD_USD = WILD_USD() +WILD_UST = WILD_UST() @dataclass(slots=True, frozen=True) class WILD_UST: + """ + name: tWILD:UST + precision: 5 + minimum_margin: 15.0 + initial_margin: 30.0 + minimum_order_size: 6.0 + maximum_order_size: 50000.0 + margin: False + """ name: str = "tWILD:UST" precision: int = 5 minimum_margin: float = 15.0 @@ -9244,11 +12867,20 @@ def __call__(self): return "tWILD:UST" -WILD_UST = WILD_UST() +WNCG_USD = WNCG_USD() @dataclass(slots=True, frozen=True) class WNCG_USD: + """ + name: tWNCG:USD + precision: 5 + minimum_margin: 15.0 + initial_margin: 30.0 + minimum_order_size: 12.0 + maximum_order_size: 50000.0 + margin: False + """ name: str = "tWNCG:USD" precision: int = 5 minimum_margin: float = 15.0 @@ -9267,11 +12899,20 @@ def __call__(self): return "tWNCG:USD" -WNCG_USD = WNCG_USD() +WOOUSD = WOOUSD() @dataclass(slots=True, frozen=True) class WOOUSD: + """ + name: tWOOUSD + precision: 5 + minimum_margin: 15.0 + initial_margin: 30.0 + minimum_order_size: 10.0 + maximum_order_size: 2500000.0 + margin: False + """ name: str = "tWOOUSD" precision: int = 5 minimum_margin: float = 15.0 @@ -9290,11 +12931,20 @@ def __call__(self): return "tWOOUSD" -WOOUSD = WOOUSD() +WOOUST = WOOUST() @dataclass(slots=True, frozen=True) class WOOUST: + """ + name: tWOOUST + precision: 5 + minimum_margin: 15.0 + initial_margin: 30.0 + minimum_order_size: 10.0 + maximum_order_size: 2500000.0 + margin: False + """ name: str = "tWOOUST" precision: int = 5 minimum_margin: float = 15.0 @@ -9313,11 +12963,20 @@ def __call__(self): return "tWOOUST" -WOOUST = WOOUST() +XAGF0_USTF0 = XAGF0_USTF0() @dataclass(slots=True, frozen=True) class XAGF0_USTF0: + """ + name: tXAGF0:USTF0 + precision: 5 + minimum_margin: 0.5 + initial_margin: 1.0 + minimum_order_size: 0.1 + maximum_order_size: 10000.0 + margin: True + """ name: str = "tXAGF0:USTF0" precision: int = 5 minimum_margin: float = 0.5 @@ -9336,11 +12995,20 @@ def __call__(self): return "tXAGF0:USTF0" -XAGF0_USTF0 = XAGF0_USTF0() +XAUT_BTC = XAUT_BTC() @dataclass(slots=True, frozen=True) class XAUT_BTC: + """ + name: tXAUT:BTC + precision: 5 + minimum_margin: 10.0 + initial_margin: 20.0 + minimum_order_size: 0.002 + maximum_order_size: 400.0 + margin: True + """ name: str = "tXAUT:BTC" precision: int = 5 minimum_margin: float = 10.0 @@ -9359,11 +13027,20 @@ def __call__(self): return "tXAUT:BTC" -XAUT_BTC = XAUT_BTC() +XAUT_USD = XAUT_USD() @dataclass(slots=True, frozen=True) class XAUT_USD: + """ + name: tXAUT:USD + precision: 5 + minimum_margin: 10.0 + initial_margin: 20.0 + minimum_order_size: 0.002 + maximum_order_size: 400.0 + margin: True + """ name: str = "tXAUT:USD" precision: int = 5 minimum_margin: float = 10.0 @@ -9382,11 +13059,20 @@ def __call__(self): return "tXAUT:USD" -XAUT_USD = XAUT_USD() +XAUT_UST = XAUT_UST() @dataclass(slots=True, frozen=True) class XAUT_UST: + """ + name: tXAUT:UST + precision: 5 + minimum_margin: 10.0 + initial_margin: 20.0 + minimum_order_size: 0.002 + maximum_order_size: 400.0 + margin: True + """ name: str = "tXAUT:UST" precision: int = 5 minimum_margin: float = 10.0 @@ -9405,11 +13091,20 @@ def __call__(self): return "tXAUT:UST" -XAUT_UST = XAUT_UST() +XAUTF0_BTCF0 = XAUTF0_BTCF0() @dataclass(slots=True, frozen=True) class XAUTF0_BTCF0: + """ + name: tXAUTF0:BTCF0 + precision: 5 + minimum_margin: 0.5 + initial_margin: 1.0 + minimum_order_size: 0.002 + maximum_order_size: 500.0 + margin: True + """ name: str = "tXAUTF0:BTCF0" precision: int = 5 minimum_margin: float = 0.5 @@ -9428,11 +13123,20 @@ def __call__(self): return "tXAUTF0:BTCF0" -XAUTF0_BTCF0 = XAUTF0_BTCF0() +XAUTF0_USTF0 = XAUTF0_USTF0() @dataclass(slots=True, frozen=True) class XAUTF0_USTF0: + """ + name: tXAUTF0:USTF0 + precision: 5 + minimum_margin: 0.5 + initial_margin: 1.0 + minimum_order_size: 0.002 + maximum_order_size: 400.0 + margin: True + """ name: str = "tXAUTF0:USTF0" precision: int = 5 minimum_margin: float = 0.5 @@ -9451,11 +13155,20 @@ def __call__(self): return "tXAUTF0:USTF0" -XAUTF0_USTF0 = XAUTF0_USTF0() +XCAD_USD = XCAD_USD() @dataclass(slots=True, frozen=True) class XCAD_USD: + """ + name: tXCAD:USD + precision: 5 + minimum_margin: 15.0 + initial_margin: 30.0 + minimum_order_size: 0.001 + maximum_order_size: 15000.0 + margin: False + """ name: str = "tXCAD:USD" precision: int = 5 minimum_margin: float = 15.0 @@ -9474,11 +13187,20 @@ def __call__(self): return "tXCAD:USD" -XCAD_USD = XCAD_USD() +XCNUSD = XCNUSD() @dataclass(slots=True, frozen=True) class XCNUSD: + """ + name: tXCNUSD + precision: 5 + minimum_margin: 15.0 + initial_margin: 30.0 + minimum_order_size: 0.001 + maximum_order_size: 1000000.0 + margin: False + """ name: str = "tXCNUSD" precision: int = 5 minimum_margin: float = 15.0 @@ -9497,11 +13219,20 @@ def __call__(self): return "tXCNUSD" -XCNUSD = XCNUSD() +XCNUST = XCNUST() @dataclass(slots=True, frozen=True) class XCNUST: + """ + name: tXCNUST + precision: 5 + minimum_margin: 15.0 + initial_margin: 30.0 + minimum_order_size: 0.001 + maximum_order_size: 1000000.0 + margin: False + """ name: str = "tXCNUST" precision: int = 5 minimum_margin: float = 15.0 @@ -9520,11 +13251,20 @@ def __call__(self): return "tXCNUST" -XCNUST = XCNUST() +XDCUSD = XDCUSD() @dataclass(slots=True, frozen=True) class XDCUSD: + """ + name: tXDCUSD + precision: 5 + minimum_margin: 15.0 + initial_margin: 30.0 + minimum_order_size: 54.0 + maximum_order_size: 1000000.0 + margin: False + """ name: str = "tXDCUSD" precision: int = 5 minimum_margin: float = 15.0 @@ -9543,11 +13283,20 @@ def __call__(self): return "tXDCUSD" -XDCUSD = XDCUSD() +XDCUST = XDCUST() @dataclass(slots=True, frozen=True) class XDCUST: + """ + name: tXDCUST + precision: 5 + minimum_margin: 15.0 + initial_margin: 30.0 + minimum_order_size: 54.0 + maximum_order_size: 1000000.0 + margin: False + """ name: str = "tXDCUST" precision: int = 5 minimum_margin: float = 15.0 @@ -9566,11 +13315,20 @@ def __call__(self): return "tXDCUST" -XDCUST = XDCUST() +XLMBTC = XLMBTC() @dataclass(slots=True, frozen=True) class XLMBTC: + """ + name: tXLMBTC + precision: 5 + minimum_margin: 25.0 + initial_margin: 50.0 + minimum_order_size: 14.0 + maximum_order_size: 1000000.0 + margin: True + """ name: str = "tXLMBTC" precision: int = 5 minimum_margin: float = 25.0 @@ -9589,11 +13347,20 @@ def __call__(self): return "tXLMBTC" -XLMBTC = XLMBTC() +XLMF0_USTF0 = XLMF0_USTF0() @dataclass(slots=True, frozen=True) class XLMF0_USTF0: + """ + name: tXLMF0:USTF0 + precision: 5 + minimum_margin: 0.5 + initial_margin: 1.0 + minimum_order_size: 14.0 + maximum_order_size: 250000.0 + margin: True + """ name: str = "tXLMF0:USTF0" precision: int = 5 minimum_margin: float = 0.5 @@ -9612,11 +13379,20 @@ def __call__(self): return "tXLMF0:USTF0" -XLMF0_USTF0 = XLMF0_USTF0() +XLMUSD = XLMUSD() @dataclass(slots=True, frozen=True) class XLMUSD: + """ + name: tXLMUSD + precision: 5 + minimum_margin: 25.0 + initial_margin: 50.0 + minimum_order_size: 14.0 + maximum_order_size: 1000000.0 + margin: True + """ name: str = "tXLMUSD" precision: int = 5 minimum_margin: float = 25.0 @@ -9635,11 +13411,20 @@ def __call__(self): return "tXLMUSD" -XLMUSD = XLMUSD() +XLMUST = XLMUST() @dataclass(slots=True, frozen=True) class XLMUST: + """ + name: tXLMUST + precision: 5 + minimum_margin: 15.0 + initial_margin: 30.0 + minimum_order_size: 14.0 + maximum_order_size: 1000000.0 + margin: False + """ name: str = "tXLMUST" precision: int = 5 minimum_margin: float = 15.0 @@ -9658,11 +13443,20 @@ def __call__(self): return "tXLMUST" -XLMUST = XLMUST() +XMRBTC = XMRBTC() @dataclass(slots=True, frozen=True) class XMRBTC: + """ + name: tXMRBTC + precision: 5 + minimum_margin: 15.0 + initial_margin: 30.0 + minimum_order_size: 0.02 + maximum_order_size: 5000.0 + margin: True + """ name: str = "tXMRBTC" precision: int = 5 minimum_margin: float = 15.0 @@ -9681,11 +13475,20 @@ def __call__(self): return "tXMRBTC" -XMRBTC = XMRBTC() +XMRF0_USTF0 = XMRF0_USTF0() @dataclass(slots=True, frozen=True) class XMRF0_USTF0: + """ + name: tXMRF0:USTF0 + precision: 5 + minimum_margin: 0.5 + initial_margin: 1.0 + minimum_order_size: 0.02 + maximum_order_size: 10000.0 + margin: True + """ name: str = "tXMRF0:USTF0" precision: int = 5 minimum_margin: float = 0.5 @@ -9704,11 +13507,20 @@ def __call__(self): return "tXMRF0:USTF0" -XMRF0_USTF0 = XMRF0_USTF0() +XMRUSD = XMRUSD() @dataclass(slots=True, frozen=True) class XMRUSD: + """ + name: tXMRUSD + precision: 5 + minimum_margin: 15.0 + initial_margin: 30.0 + minimum_order_size: 0.02 + maximum_order_size: 5000.0 + margin: True + """ name: str = "tXMRUSD" precision: int = 5 minimum_margin: float = 15.0 @@ -9727,11 +13539,20 @@ def __call__(self): return "tXMRUSD" -XMRUSD = XMRUSD() +XMRUST = XMRUST() @dataclass(slots=True, frozen=True) class XMRUST: + """ + name: tXMRUST + precision: 5 + minimum_margin: 15.0 + initial_margin: 30.0 + minimum_order_size: 0.02 + maximum_order_size: 5000.0 + margin: True + """ name: str = "tXMRUST" precision: int = 5 minimum_margin: float = 15.0 @@ -9750,11 +13571,20 @@ def __call__(self): return "tXMRUST" -XMRUST = XMRUST() +XRAUSD = XRAUSD() @dataclass(slots=True, frozen=True) class XRAUSD: + """ + name: tXRAUSD + precision: 5 + minimum_margin: 15.0 + initial_margin: 30.0 + minimum_order_size: 196.0 + maximum_order_size: 500000.0 + margin: False + """ name: str = "tXRAUSD" precision: int = 5 minimum_margin: float = 15.0 @@ -9773,11 +13603,20 @@ def __call__(self): return "tXRAUSD" -XRAUSD = XRAUSD() +XRDBTC = XRDBTC() @dataclass(slots=True, frozen=True) class XRDBTC: + """ + name: tXRDBTC + precision: 5 + minimum_margin: 15.0 + initial_margin: 30.0 + minimum_order_size: 24.0 + maximum_order_size: 1000000.0 + margin: False + """ name: str = "tXRDBTC" precision: int = 5 minimum_margin: float = 15.0 @@ -9796,11 +13635,20 @@ def __call__(self): return "tXRDBTC" -XRDBTC = XRDBTC() +XRDUSD = XRDUSD() @dataclass(slots=True, frozen=True) class XRDUSD: + """ + name: tXRDUSD + precision: 5 + minimum_margin: 15.0 + initial_margin: 30.0 + minimum_order_size: 24.0 + maximum_order_size: 1000000.0 + margin: False + """ name: str = "tXRDUSD" precision: int = 5 minimum_margin: float = 15.0 @@ -9819,11 +13667,20 @@ def __call__(self): return "tXRDUSD" -XRDUSD = XRDUSD() +XRPBTC = XRPBTC() @dataclass(slots=True, frozen=True) class XRPBTC: + """ + name: tXRPBTC + precision: 5 + minimum_margin: 10.0 + initial_margin: 20.0 + minimum_order_size: 6.0 + maximum_order_size: 2000000.0 + margin: True + """ name: str = "tXRPBTC" precision: int = 5 minimum_margin: float = 10.0 @@ -9842,11 +13699,20 @@ def __call__(self): return "tXRPBTC" -XRPBTC = XRPBTC() +XRPF0_BTCF0 = XRPF0_BTCF0() @dataclass(slots=True, frozen=True) class XRPF0_BTCF0: + """ + name: tXRPF0:BTCF0 + precision: 5 + minimum_margin: 0.5 + initial_margin: 1.0 + minimum_order_size: 6.0 + maximum_order_size: 250000.0 + margin: True + """ name: str = "tXRPF0:BTCF0" precision: int = 5 minimum_margin: float = 0.5 @@ -9865,11 +13731,20 @@ def __call__(self): return "tXRPF0:BTCF0" -XRPF0_BTCF0 = XRPF0_BTCF0() +XRPF0_USTF0 = XRPF0_USTF0() @dataclass(slots=True, frozen=True) class XRPF0_USTF0: + """ + name: tXRPF0:USTF0 + precision: 5 + minimum_margin: 0.5 + initial_margin: 1.0 + minimum_order_size: 6.0 + maximum_order_size: 500000.0 + margin: True + """ name: str = "tXRPF0:USTF0" precision: int = 5 minimum_margin: float = 0.5 @@ -9888,11 +13763,20 @@ def __call__(self): return "tXRPF0:USTF0" -XRPF0_USTF0 = XRPF0_USTF0() +XRPUSD = XRPUSD() @dataclass(slots=True, frozen=True) class XRPUSD: + """ + name: tXRPUSD + precision: 5 + minimum_margin: 10.0 + initial_margin: 20.0 + minimum_order_size: 6.0 + maximum_order_size: 2000000.0 + margin: True + """ name: str = "tXRPUSD" precision: int = 5 minimum_margin: float = 10.0 @@ -9911,11 +13795,20 @@ def __call__(self): return "tXRPUSD" -XRPUSD = XRPUSD() +XRPUST = XRPUST() @dataclass(slots=True, frozen=True) class XRPUST: + """ + name: tXRPUST + precision: 5 + minimum_margin: 15.0 + initial_margin: 30.0 + minimum_order_size: 6.0 + maximum_order_size: 2000000.0 + margin: True + """ name: str = "tXRPUST" precision: int = 5 minimum_margin: float = 15.0 @@ -9934,11 +13827,20 @@ def __call__(self): return "tXRPUST" -XRPUST = XRPUST() +XTZBTC = XTZBTC() @dataclass(slots=True, frozen=True) class XTZBTC: + """ + name: tXTZBTC + precision: 5 + minimum_margin: 15.0 + initial_margin: 30.0 + minimum_order_size: 2.0 + maximum_order_size: 100000.0 + margin: True + """ name: str = "tXTZBTC" precision: int = 5 minimum_margin: float = 15.0 @@ -9957,11 +13859,20 @@ def __call__(self): return "tXTZBTC" -XTZBTC = XTZBTC() +XTZF0_USTF0 = XTZF0_USTF0() @dataclass(slots=True, frozen=True) class XTZF0_USTF0: + """ + name: tXTZF0:USTF0 + precision: 5 + minimum_margin: 0.5 + initial_margin: 1.0 + minimum_order_size: 2.0 + maximum_order_size: 100000.0 + margin: True + """ name: str = "tXTZF0:USTF0" precision: int = 5 minimum_margin: float = 0.5 @@ -9980,11 +13891,20 @@ def __call__(self): return "tXTZF0:USTF0" -XTZF0_USTF0 = XTZF0_USTF0() +XTZUSD = XTZUSD() @dataclass(slots=True, frozen=True) class XTZUSD: + """ + name: tXTZUSD + precision: 5 + minimum_margin: 15.0 + initial_margin: 30.0 + minimum_order_size: 2.0 + maximum_order_size: 100000.0 + margin: True + """ name: str = "tXTZUSD" precision: int = 5 minimum_margin: float = 15.0 @@ -10003,11 +13923,20 @@ def __call__(self): return "tXTZUSD" -XTZUSD = XTZUSD() +XTZUST = XTZUST() @dataclass(slots=True, frozen=True) class XTZUST: + """ + name: tXTZUST + precision: 5 + minimum_margin: 15.0 + initial_margin: 30.0 + minimum_order_size: 2.0 + maximum_order_size: 100000.0 + margin: True + """ name: str = "tXTZUST" precision: int = 5 minimum_margin: float = 15.0 @@ -10026,11 +13955,20 @@ def __call__(self): return "tXTZUST" -XTZUST = XTZUST() +XVGUSD = XVGUSD() @dataclass(slots=True, frozen=True) class XVGUSD: + """ + name: tXVGUSD + precision: 5 + minimum_margin: 15.0 + initial_margin: 30.0 + minimum_order_size: 432.0 + maximum_order_size: 1500000.0 + margin: False + """ name: str = "tXVGUSD" precision: int = 5 minimum_margin: float = 15.0 @@ -10049,11 +13987,20 @@ def __call__(self): return "tXVGUSD" -XVGUSD = XVGUSD() +YFIUSD = YFIUSD() @dataclass(slots=True, frozen=True) class YFIUSD: + """ + name: tYFIUSD + precision: 5 + minimum_margin: 15.0 + initial_margin: 30.0 + minimum_order_size: 0.0002 + maximum_order_size: 100.0 + margin: True + """ name: str = "tYFIUSD" precision: int = 5 minimum_margin: float = 15.0 @@ -10072,11 +14019,20 @@ def __call__(self): return "tYFIUSD" -YFIUSD = YFIUSD() +YFIUST = YFIUST() @dataclass(slots=True, frozen=True) class YFIUST: + """ + name: tYFIUST + precision: 5 + minimum_margin: 15.0 + initial_margin: 30.0 + minimum_order_size: 0.0002 + maximum_order_size: 100.0 + margin: True + """ name: str = "tYFIUST" precision: int = 5 minimum_margin: float = 15.0 @@ -10095,11 +14051,20 @@ def __call__(self): return "tYFIUST" -YFIUST = YFIUST() +ZCNUSD = ZCNUSD() @dataclass(slots=True, frozen=True) class ZCNUSD: + """ + name: tZCNUSD + precision: 5 + minimum_margin: 15.0 + initial_margin: 30.0 + minimum_order_size: 10.0 + maximum_order_size: 50000.0 + margin: False + """ name: str = "tZCNUSD" precision: int = 5 minimum_margin: float = 15.0 @@ -10118,11 +14083,20 @@ def __call__(self): return "tZCNUSD" -ZCNUSD = ZCNUSD() +ZECBTC = ZECBTC() @dataclass(slots=True, frozen=True) class ZECBTC: + """ + name: tZECBTC + precision: 5 + minimum_margin: 15.0 + initial_margin: 30.0 + minimum_order_size: 0.02 + maximum_order_size: 20000.0 + margin: True + """ name: str = "tZECBTC" precision: int = 5 minimum_margin: float = 15.0 @@ -10141,11 +14115,20 @@ def __call__(self): return "tZECBTC" -ZECBTC = ZECBTC() +ZECF0_USTF0 = ZECF0_USTF0() @dataclass(slots=True, frozen=True) class ZECF0_USTF0: + """ + name: tZECF0:USTF0 + precision: 5 + minimum_margin: 0.5 + initial_margin: 1.0 + minimum_order_size: 0.02 + maximum_order_size: 20000.0 + margin: True + """ name: str = "tZECF0:USTF0" precision: int = 5 minimum_margin: float = 0.5 @@ -10164,11 +14147,20 @@ def __call__(self): return "tZECF0:USTF0" -ZECF0_USTF0 = ZECF0_USTF0() +ZECUSD = ZECUSD() @dataclass(slots=True, frozen=True) class ZECUSD: + """ + name: tZECUSD + precision: 5 + minimum_margin: 15.0 + initial_margin: 30.0 + minimum_order_size: 0.02 + maximum_order_size: 20000.0 + margin: True + """ name: str = "tZECUSD" precision: int = 5 minimum_margin: float = 15.0 @@ -10187,11 +14179,20 @@ def __call__(self): return "tZECUSD" -ZECUSD = ZECUSD() +ZILBTC = ZILBTC() @dataclass(slots=True, frozen=True) class ZILBTC: + """ + name: tZILBTC + precision: 5 + minimum_margin: 15.0 + initial_margin: 30.0 + minimum_order_size: 40.0 + maximum_order_size: 1500000.0 + margin: False + """ name: str = "tZILBTC" precision: int = 5 minimum_margin: float = 15.0 @@ -10210,11 +14211,20 @@ def __call__(self): return "tZILBTC" -ZILBTC = ZILBTC() +ZILUSD = ZILUSD() @dataclass(slots=True, frozen=True) class ZILUSD: + """ + name: tZILUSD + precision: 5 + minimum_margin: 15.0 + initial_margin: 30.0 + minimum_order_size: 40.0 + maximum_order_size: 1500000.0 + margin: False + """ name: str = "tZILUSD" precision: int = 5 minimum_margin: float = 15.0 @@ -10233,11 +14243,20 @@ def __call__(self): return "tZILUSD" -ZILUSD = ZILUSD() +ZMTUSD = ZMTUSD() @dataclass(slots=True, frozen=True) class ZMTUSD: + """ + name: tZMTUSD + precision: 5 + minimum_margin: 15.0 + initial_margin: 30.0 + minimum_order_size: 2.0 + maximum_order_size: 50000.0 + margin: False + """ name: str = "tZMTUSD" precision: int = 5 minimum_margin: float = 15.0 @@ -10256,11 +14275,20 @@ def __call__(self): return "tZMTUSD" -ZMTUSD = ZMTUSD() +ZMTUST = ZMTUST() @dataclass(slots=True, frozen=True) class ZMTUST: + """ + name: tZMTUST + precision: 5 + minimum_margin: 15.0 + initial_margin: 30.0 + minimum_order_size: 2.0 + maximum_order_size: 50000.0 + margin: False + """ name: str = "tZMTUST" precision: int = 5 minimum_margin: float = 15.0 @@ -10279,11 +14307,20 @@ def __call__(self): return "tZMTUST" -ZMTUST = ZMTUST() +ZRXBTC = ZRXBTC() @dataclass(slots=True, frozen=True) class ZRXBTC: + """ + name: tZRXBTC + precision: 5 + minimum_margin: 15.0 + initial_margin: 30.0 + minimum_order_size: 6.0 + maximum_order_size: 200000.0 + margin: False + """ name: str = "tZRXBTC" precision: int = 5 minimum_margin: float = 15.0 @@ -10302,11 +14339,20 @@ def __call__(self): return "tZRXBTC" -ZRXBTC = ZRXBTC() +ZRXETH = ZRXETH() @dataclass(slots=True, frozen=True) class ZRXETH: + """ + name: tZRXETH + precision: 5 + minimum_margin: 15.0 + initial_margin: 30.0 + minimum_order_size: 6.0 + maximum_order_size: 200000.0 + margin: True + """ name: str = "tZRXETH" precision: int = 5 minimum_margin: float = 15.0 @@ -10325,11 +14371,20 @@ def __call__(self): return "tZRXETH" -ZRXETH = ZRXETH() +ZRXUSD = ZRXUSD() @dataclass(slots=True, frozen=True) class ZRXUSD: + """ + name: tZRXUSD + precision: 5 + minimum_margin: 15.0 + initial_margin: 30.0 + minimum_order_size: 6.0 + maximum_order_size: 200000.0 + margin: True + """ name: str = "tZRXUSD" precision: int = 5 minimum_margin: float = 15.0 @@ -10346,8 +14401,3 @@ def __str__(self): def __call__(self): return "tZRXUSD" - - -ZRXUSD = ZRXUSD() - - diff --git a/symbols/coinbase.py b/symbols/coinbase.py index 2ee3477..d314521 100644 --- a/symbols/coinbase.py +++ b/symbols/coinbase.py @@ -1,8 +1,22 @@ from dataclasses import dataclass + + +ZERO0_USD = ZERO0_USD() + + @dataclass(slots=True, frozen=True) class ZERO0_USD: + """ + name: 00-USD + precision: 0.0001 + minimum_margin: None + initial_margin: None + minimum_order_size: 1 + maximum_order_size: None + margin: False + """ name: str = "00-USD" precision: int = 0.0001 minimum_margin: float = None @@ -21,11 +35,20 @@ def __call__(self): return "00-USD" -ZERO0_USD = ZERO0_USD() +ONEINCH_BTC = ONEINCH_BTC() @dataclass(slots=True, frozen=True) class ONEINCH_BTC: + """ + name: 1INCH-BTC + precision: 0.0000001 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.000016 + maximum_order_size: None + margin: False + """ name: str = "1INCH-BTC" precision: int = 0.0000001 minimum_margin: float = None @@ -44,11 +67,20 @@ def __call__(self): return "1INCH-BTC" -ONEINCH_BTC = ONEINCH_BTC() +ONEINCH_EUR = ONEINCH_EUR() @dataclass(slots=True, frozen=True) class ONEINCH_EUR: + """ + name: 1INCH-EUR + precision: 0.001 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.84 + maximum_order_size: None + margin: False + """ name: str = "1INCH-EUR" precision: int = 0.001 minimum_margin: float = None @@ -67,11 +99,20 @@ def __call__(self): return "1INCH-EUR" -ONEINCH_EUR = ONEINCH_EUR() +ONEINCH_GBP = ONEINCH_GBP() @dataclass(slots=True, frozen=True) class ONEINCH_GBP: + """ + name: 1INCH-GBP + precision: 0.001 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.72 + maximum_order_size: None + margin: False + """ name: str = "1INCH-GBP" precision: int = 0.001 minimum_margin: float = None @@ -90,11 +131,20 @@ def __call__(self): return "1INCH-GBP" -ONEINCH_GBP = ONEINCH_GBP() +ONEINCH_USD = ONEINCH_USD() @dataclass(slots=True, frozen=True) class ONEINCH_USD: + """ + name: 1INCH-USD + precision: 0.001 + minimum_margin: None + initial_margin: None + minimum_order_size: 1 + maximum_order_size: None + margin: False + """ name: str = "1INCH-USD" precision: int = 0.001 minimum_margin: float = None @@ -113,11 +163,20 @@ def __call__(self): return "1INCH-USD" -ONEINCH_USD = ONEINCH_USD() +AAVE_BTC = AAVE_BTC() @dataclass(slots=True, frozen=True) class AAVE_BTC: + """ + name: AAVE-BTC + precision: 0.000001 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.000016 + maximum_order_size: None + margin: False + """ name: str = "AAVE-BTC" precision: int = 0.000001 minimum_margin: float = None @@ -136,11 +195,20 @@ def __call__(self): return "AAVE-BTC" -AAVE_BTC = AAVE_BTC() +AAVE_EUR = AAVE_EUR() @dataclass(slots=True, frozen=True) class AAVE_EUR: + """ + name: AAVE-EUR + precision: 0.01 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.84 + maximum_order_size: None + margin: False + """ name: str = "AAVE-EUR" precision: int = 0.01 minimum_margin: float = None @@ -159,11 +227,20 @@ def __call__(self): return "AAVE-EUR" -AAVE_EUR = AAVE_EUR() +AAVE_GBP = AAVE_GBP() @dataclass(slots=True, frozen=True) class AAVE_GBP: + """ + name: AAVE-GBP + precision: 0.01 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.72 + maximum_order_size: None + margin: False + """ name: str = "AAVE-GBP" precision: int = 0.01 minimum_margin: float = None @@ -182,11 +259,20 @@ def __call__(self): return "AAVE-GBP" -AAVE_GBP = AAVE_GBP() +AAVE_USD = AAVE_USD() @dataclass(slots=True, frozen=True) class AAVE_USD: + """ + name: AAVE-USD + precision: 0.01 + minimum_margin: None + initial_margin: None + minimum_order_size: 1 + maximum_order_size: None + margin: False + """ name: str = "AAVE-USD" precision: int = 0.01 minimum_margin: float = None @@ -205,11 +291,20 @@ def __call__(self): return "AAVE-USD" -AAVE_USD = AAVE_USD() +ABT_USD = ABT_USD() @dataclass(slots=True, frozen=True) class ABT_USD: + """ + name: ABT-USD + precision: 0.0001 + minimum_margin: None + initial_margin: None + minimum_order_size: 1 + maximum_order_size: None + margin: False + """ name: str = "ABT-USD" precision: int = 0.0001 minimum_margin: float = None @@ -228,11 +323,20 @@ def __call__(self): return "ABT-USD" -ABT_USD = ABT_USD() +ACH_USD = ACH_USD() @dataclass(slots=True, frozen=True) class ACH_USD: + """ + name: ACH-USD + precision: 0.000001 + minimum_margin: None + initial_margin: None + minimum_order_size: 1 + maximum_order_size: None + margin: False + """ name: str = "ACH-USD" precision: int = 0.000001 minimum_margin: float = None @@ -251,11 +355,20 @@ def __call__(self): return "ACH-USD" -ACH_USD = ACH_USD() +ACH_USDT = ACH_USDT() @dataclass(slots=True, frozen=True) class ACH_USDT: + """ + name: ACH-USDT + precision: 0.000001 + minimum_margin: None + initial_margin: None + minimum_order_size: 1 + maximum_order_size: None + margin: False + """ name: str = "ACH-USDT" precision: int = 0.000001 minimum_margin: float = None @@ -274,11 +387,20 @@ def __call__(self): return "ACH-USDT" -ACH_USDT = ACH_USDT() +ADA_BTC = ADA_BTC() @dataclass(slots=True, frozen=True) class ADA_BTC: + """ + name: ADA-BTC + precision: 0.00000001 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.000016 + maximum_order_size: None + margin: False + """ name: str = "ADA-BTC" precision: int = 0.00000001 minimum_margin: float = None @@ -297,11 +419,20 @@ def __call__(self): return "ADA-BTC" -ADA_BTC = ADA_BTC() +ADA_ETH = ADA_ETH() @dataclass(slots=True, frozen=True) class ADA_ETH: + """ + name: ADA-ETH + precision: 0.000001 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.00022 + maximum_order_size: None + margin: False + """ name: str = "ADA-ETH" precision: int = 0.000001 minimum_margin: float = None @@ -320,11 +451,20 @@ def __call__(self): return "ADA-ETH" -ADA_ETH = ADA_ETH() +ADA_EUR = ADA_EUR() @dataclass(slots=True, frozen=True) class ADA_EUR: + """ + name: ADA-EUR + precision: 0.0001 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.84 + maximum_order_size: None + margin: False + """ name: str = "ADA-EUR" precision: int = 0.0001 minimum_margin: float = None @@ -343,11 +483,20 @@ def __call__(self): return "ADA-EUR" -ADA_EUR = ADA_EUR() +ADA_GBP = ADA_GBP() @dataclass(slots=True, frozen=True) class ADA_GBP: + """ + name: ADA-GBP + precision: 0.0001 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.72 + maximum_order_size: None + margin: False + """ name: str = "ADA-GBP" precision: int = 0.0001 minimum_margin: float = None @@ -366,11 +515,20 @@ def __call__(self): return "ADA-GBP" -ADA_GBP = ADA_GBP() +ADA_USD = ADA_USD() @dataclass(slots=True, frozen=True) class ADA_USD: + """ + name: ADA-USD + precision: 0.0001 + minimum_margin: None + initial_margin: None + minimum_order_size: 1 + maximum_order_size: None + margin: False + """ name: str = "ADA-USD" precision: int = 0.0001 minimum_margin: float = None @@ -389,11 +547,20 @@ def __call__(self): return "ADA-USD" -ADA_USD = ADA_USD() +ADA_USDC = ADA_USDC() @dataclass(slots=True, frozen=True) class ADA_USDC: + """ + name: ADA-USDC + precision: 0.001 + minimum_margin: None + initial_margin: None + minimum_order_size: 1 + maximum_order_size: None + margin: False + """ name: str = "ADA-USDC" precision: int = 0.001 minimum_margin: float = None @@ -412,11 +579,20 @@ def __call__(self): return "ADA-USDC" -ADA_USDC = ADA_USDC() +ADA_USDT = ADA_USDT() @dataclass(slots=True, frozen=True) class ADA_USDT: + """ + name: ADA-USDT + precision: 0.001 + minimum_margin: None + initial_margin: None + minimum_order_size: 1 + maximum_order_size: None + margin: False + """ name: str = "ADA-USDT" precision: int = 0.001 minimum_margin: float = None @@ -435,11 +611,20 @@ def __call__(self): return "ADA-USDT" -ADA_USDT = ADA_USDT() +AERGO_USD = AERGO_USD() @dataclass(slots=True, frozen=True) class AERGO_USD: + """ + name: AERGO-USD + precision: 0.0001 + minimum_margin: None + initial_margin: None + minimum_order_size: 1 + maximum_order_size: None + margin: False + """ name: str = "AERGO-USD" precision: int = 0.0001 minimum_margin: float = None @@ -458,11 +643,20 @@ def __call__(self): return "AERGO-USD" -AERGO_USD = AERGO_USD() +AGLD_USD = AGLD_USD() @dataclass(slots=True, frozen=True) class AGLD_USD: + """ + name: AGLD-USD + precision: 0.0001 + minimum_margin: None + initial_margin: None + minimum_order_size: 1 + maximum_order_size: None + margin: False + """ name: str = "AGLD-USD" precision: int = 0.0001 minimum_margin: float = None @@ -481,11 +675,20 @@ def __call__(self): return "AGLD-USD" -AGLD_USD = AGLD_USD() +AGLD_USDT = AGLD_USDT() @dataclass(slots=True, frozen=True) class AGLD_USDT: + """ + name: AGLD-USDT + precision: 0.0001 + minimum_margin: None + initial_margin: None + minimum_order_size: 1 + maximum_order_size: None + margin: False + """ name: str = "AGLD-USDT" precision: int = 0.0001 minimum_margin: float = None @@ -504,11 +707,20 @@ def __call__(self): return "AGLD-USDT" -AGLD_USDT = AGLD_USDT() +AIOZ_USD = AIOZ_USD() @dataclass(slots=True, frozen=True) class AIOZ_USD: + """ + name: AIOZ-USD + precision: 0.0001 + minimum_margin: None + initial_margin: None + minimum_order_size: 1 + maximum_order_size: None + margin: False + """ name: str = "AIOZ-USD" precision: int = 0.0001 minimum_margin: float = None @@ -527,11 +739,20 @@ def __call__(self): return "AIOZ-USD" -AIOZ_USD = AIOZ_USD() +AIOZ_USDT = AIOZ_USDT() @dataclass(slots=True, frozen=True) class AIOZ_USDT: + """ + name: AIOZ-USDT + precision: 0.0001 + minimum_margin: None + initial_margin: None + minimum_order_size: 1 + maximum_order_size: None + margin: False + """ name: str = "AIOZ-USDT" precision: int = 0.0001 minimum_margin: float = None @@ -550,11 +771,20 @@ def __call__(self): return "AIOZ-USDT" -AIOZ_USDT = AIOZ_USDT() +ALCX_EUR = ALCX_EUR() @dataclass(slots=True, frozen=True) class ALCX_EUR: + """ + name: ALCX-EUR + precision: 0.01 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.84 + maximum_order_size: None + margin: False + """ name: str = "ALCX-EUR" precision: int = 0.01 minimum_margin: float = None @@ -573,11 +803,20 @@ def __call__(self): return "ALCX-EUR" -ALCX_EUR = ALCX_EUR() +ALCX_USD = ALCX_USD() @dataclass(slots=True, frozen=True) class ALCX_USD: + """ + name: ALCX-USD + precision: 0.01 + minimum_margin: None + initial_margin: None + minimum_order_size: 1 + maximum_order_size: None + margin: False + """ name: str = "ALCX-USD" precision: int = 0.01 minimum_margin: float = None @@ -596,11 +835,20 @@ def __call__(self): return "ALCX-USD" -ALCX_USD = ALCX_USD() +ALCX_USDT = ALCX_USDT() @dataclass(slots=True, frozen=True) class ALCX_USDT: + """ + name: ALCX-USDT + precision: 0.01 + minimum_margin: None + initial_margin: None + minimum_order_size: 1 + maximum_order_size: None + margin: False + """ name: str = "ALCX-USDT" precision: int = 0.01 minimum_margin: float = None @@ -619,11 +867,20 @@ def __call__(self): return "ALCX-USDT" -ALCX_USDT = ALCX_USDT() +ALEPH_USD = ALEPH_USD() @dataclass(slots=True, frozen=True) class ALEPH_USD: + """ + name: ALEPH-USD + precision: 0.0001 + minimum_margin: None + initial_margin: None + minimum_order_size: 1 + maximum_order_size: None + margin: False + """ name: str = "ALEPH-USD" precision: int = 0.0001 minimum_margin: float = None @@ -642,11 +899,20 @@ def __call__(self): return "ALEPH-USD" -ALEPH_USD = ALEPH_USD() +ALGO_BTC = ALGO_BTC() @dataclass(slots=True, frozen=True) class ALGO_BTC: + """ + name: ALGO-BTC + precision: 0.00000001 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.000016 + maximum_order_size: None + margin: False + """ name: str = "ALGO-BTC" precision: int = 0.00000001 minimum_margin: float = None @@ -665,11 +931,20 @@ def __call__(self): return "ALGO-BTC" -ALGO_BTC = ALGO_BTC() +ALGO_EUR = ALGO_EUR() @dataclass(slots=True, frozen=True) class ALGO_EUR: + """ + name: ALGO-EUR + precision: 0.0001 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.84 + maximum_order_size: None + margin: False + """ name: str = "ALGO-EUR" precision: int = 0.0001 minimum_margin: float = None @@ -688,11 +963,20 @@ def __call__(self): return "ALGO-EUR" -ALGO_EUR = ALGO_EUR() +ALGO_GBP = ALGO_GBP() @dataclass(slots=True, frozen=True) class ALGO_GBP: + """ + name: ALGO-GBP + precision: 0.0001 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.72 + maximum_order_size: None + margin: False + """ name: str = "ALGO-GBP" precision: int = 0.0001 minimum_margin: float = None @@ -711,11 +995,20 @@ def __call__(self): return "ALGO-GBP" -ALGO_GBP = ALGO_GBP() +ALGO_USD = ALGO_USD() @dataclass(slots=True, frozen=True) class ALGO_USD: + """ + name: ALGO-USD + precision: 0.0001 + minimum_margin: None + initial_margin: None + minimum_order_size: 1 + maximum_order_size: None + margin: False + """ name: str = "ALGO-USD" precision: int = 0.0001 minimum_margin: float = None @@ -734,11 +1027,20 @@ def __call__(self): return "ALGO-USD" -ALGO_USD = ALGO_USD() +ALICE_USD = ALICE_USD() @dataclass(slots=True, frozen=True) class ALICE_USD: + """ + name: ALICE-USD + precision: 0.001 + minimum_margin: None + initial_margin: None + minimum_order_size: 1 + maximum_order_size: None + margin: False + """ name: str = "ALICE-USD" precision: int = 0.001 minimum_margin: float = None @@ -757,11 +1059,20 @@ def __call__(self): return "ALICE-USD" -ALICE_USD = ALICE_USD() +AMP_USD = AMP_USD() @dataclass(slots=True, frozen=True) class AMP_USD: + """ + name: AMP-USD + precision: 0.00001 + minimum_margin: None + initial_margin: None + minimum_order_size: 1 + maximum_order_size: None + margin: False + """ name: str = "AMP-USD" precision: int = 0.00001 minimum_margin: float = None @@ -780,11 +1091,20 @@ def __call__(self): return "AMP-USD" -AMP_USD = AMP_USD() +ANKR_BTC = ANKR_BTC() @dataclass(slots=True, frozen=True) class ANKR_BTC: + """ + name: ANKR-BTC + precision: 0.00000001 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.000016 + maximum_order_size: None + margin: False + """ name: str = "ANKR-BTC" precision: int = 0.00000001 minimum_margin: float = None @@ -803,11 +1123,20 @@ def __call__(self): return "ANKR-BTC" -ANKR_BTC = ANKR_BTC() +ANKR_EUR = ANKR_EUR() @dataclass(slots=True, frozen=True) class ANKR_EUR: + """ + name: ANKR-EUR + precision: 0.00001 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.84 + maximum_order_size: None + margin: False + """ name: str = "ANKR-EUR" precision: int = 0.00001 minimum_margin: float = None @@ -826,11 +1155,20 @@ def __call__(self): return "ANKR-EUR" -ANKR_EUR = ANKR_EUR() +ANKR_GBP = ANKR_GBP() @dataclass(slots=True, frozen=True) class ANKR_GBP: + """ + name: ANKR-GBP + precision: 0.00001 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.72 + maximum_order_size: None + margin: False + """ name: str = "ANKR-GBP" precision: int = 0.00001 minimum_margin: float = None @@ -849,11 +1187,20 @@ def __call__(self): return "ANKR-GBP" -ANKR_GBP = ANKR_GBP() +ANKR_USD = ANKR_USD() @dataclass(slots=True, frozen=True) class ANKR_USD: + """ + name: ANKR-USD + precision: 0.00001 + minimum_margin: None + initial_margin: None + minimum_order_size: 1 + maximum_order_size: None + margin: False + """ name: str = "ANKR-USD" precision: int = 0.00001 minimum_margin: float = None @@ -872,11 +1219,20 @@ def __call__(self): return "ANKR-USD" -ANKR_USD = ANKR_USD() +ANT_USD = ANT_USD() @dataclass(slots=True, frozen=True) class ANT_USD: + """ + name: ANT-USD + precision: 0.01 + minimum_margin: None + initial_margin: None + minimum_order_size: 5.0 + maximum_order_size: None + margin: False + """ name: str = "ANT-USD" precision: int = 0.01 minimum_margin: float = None @@ -895,11 +1251,20 @@ def __call__(self): return "ANT-USD" -ANT_USD = ANT_USD() +APE_EUR = APE_EUR() @dataclass(slots=True, frozen=True) class APE_EUR: + """ + name: APE-EUR + precision: 0.001 + minimum_margin: None + initial_margin: None + minimum_order_size: 1 + maximum_order_size: None + margin: False + """ name: str = "APE-EUR" precision: int = 0.001 minimum_margin: float = None @@ -918,11 +1283,20 @@ def __call__(self): return "APE-EUR" -APE_EUR = APE_EUR() +APE_USD = APE_USD() @dataclass(slots=True, frozen=True) class APE_USD: + """ + name: APE-USD + precision: 0.001 + minimum_margin: None + initial_margin: None + minimum_order_size: 1 + maximum_order_size: None + margin: False + """ name: str = "APE-USD" precision: int = 0.001 minimum_margin: float = None @@ -941,11 +1315,20 @@ def __call__(self): return "APE-USD" -APE_USD = APE_USD() +APE_USDT = APE_USDT() @dataclass(slots=True, frozen=True) class APE_USDT: + """ + name: APE-USDT + precision: 0.001 + minimum_margin: None + initial_margin: None + minimum_order_size: 1 + maximum_order_size: None + margin: False + """ name: str = "APE-USDT" precision: int = 0.001 minimum_margin: float = None @@ -964,11 +1347,20 @@ def __call__(self): return "APE-USDT" -APE_USDT = APE_USDT() +API3_USD = API3_USD() @dataclass(slots=True, frozen=True) class API3_USD: + """ + name: API3-USD + precision: 0.001 + minimum_margin: None + initial_margin: None + minimum_order_size: 5 + maximum_order_size: None + margin: False + """ name: str = "API3-USD" precision: int = 0.001 minimum_margin: float = None @@ -987,11 +1379,20 @@ def __call__(self): return "API3-USD" -API3_USD = API3_USD() +API3_USDT = API3_USDT() @dataclass(slots=True, frozen=True) class API3_USDT: + """ + name: API3-USDT + precision: 0.001 + minimum_margin: None + initial_margin: None + minimum_order_size: 5 + maximum_order_size: None + margin: False + """ name: str = "API3-USDT" precision: int = 0.001 minimum_margin: float = None @@ -1010,11 +1411,20 @@ def __call__(self): return "API3-USDT" -API3_USDT = API3_USDT() +APT_USD = APT_USD() @dataclass(slots=True, frozen=True) class APT_USD: + """ + name: APT-USD + precision: 0.01 + minimum_margin: None + initial_margin: None + minimum_order_size: 1 + maximum_order_size: None + margin: False + """ name: str = "APT-USD" precision: int = 0.01 minimum_margin: float = None @@ -1033,11 +1443,20 @@ def __call__(self): return "APT-USD" -APT_USD = APT_USD() +APT_USDT = APT_USDT() @dataclass(slots=True, frozen=True) class APT_USDT: + """ + name: APT-USDT + precision: 0.01 + minimum_margin: None + initial_margin: None + minimum_order_size: 1 + maximum_order_size: None + margin: False + """ name: str = "APT-USDT" precision: int = 0.01 minimum_margin: float = None @@ -1056,11 +1475,20 @@ def __call__(self): return "APT-USDT" -APT_USDT = APT_USDT() +ARPA_EUR = ARPA_EUR() @dataclass(slots=True, frozen=True) class ARPA_EUR: + """ + name: ARPA-EUR + precision: 0.00001 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.84 + maximum_order_size: None + margin: False + """ name: str = "ARPA-EUR" precision: int = 0.00001 minimum_margin: float = None @@ -1079,11 +1507,20 @@ def __call__(self): return "ARPA-EUR" -ARPA_EUR = ARPA_EUR() +ARPA_USD = ARPA_USD() @dataclass(slots=True, frozen=True) class ARPA_USD: + """ + name: ARPA-USD + precision: 0.0001 + minimum_margin: None + initial_margin: None + minimum_order_size: 1 + maximum_order_size: None + margin: False + """ name: str = "ARPA-USD" precision: int = 0.0001 minimum_margin: float = None @@ -1102,11 +1539,20 @@ def __call__(self): return "ARPA-USD" -ARPA_USD = ARPA_USD() +ARPA_USDT = ARPA_USDT() @dataclass(slots=True, frozen=True) class ARPA_USDT: + """ + name: ARPA-USDT + precision: 0.0001 + minimum_margin: None + initial_margin: None + minimum_order_size: 1 + maximum_order_size: None + margin: False + """ name: str = "ARPA-USDT" precision: int = 0.0001 minimum_margin: float = None @@ -1125,11 +1571,20 @@ def __call__(self): return "ARPA-USDT" -ARPA_USDT = ARPA_USDT() +ASM_USD = ASM_USD() @dataclass(slots=True, frozen=True) class ASM_USD: + """ + name: ASM-USD + precision: 0.00001 + minimum_margin: None + initial_margin: None + minimum_order_size: 1 + maximum_order_size: None + margin: False + """ name: str = "ASM-USD" precision: int = 0.00001 minimum_margin: float = None @@ -1148,11 +1603,20 @@ def __call__(self): return "ASM-USD" -ASM_USD = ASM_USD() +ASM_USDT = ASM_USDT() @dataclass(slots=True, frozen=True) class ASM_USDT: + """ + name: ASM-USDT + precision: 0.00001 + minimum_margin: None + initial_margin: None + minimum_order_size: 1 + maximum_order_size: None + margin: False + """ name: str = "ASM-USDT" precision: int = 0.00001 minimum_margin: float = None @@ -1171,11 +1635,20 @@ def __call__(self): return "ASM-USDT" -ASM_USDT = ASM_USDT() +AST_USD = AST_USD() @dataclass(slots=True, frozen=True) class AST_USD: + """ + name: AST-USD + precision: 0.0001 + minimum_margin: None + initial_margin: None + minimum_order_size: 1 + maximum_order_size: None + margin: False + """ name: str = "AST-USD" precision: int = 0.0001 minimum_margin: float = None @@ -1194,11 +1667,20 @@ def __call__(self): return "AST-USD" -AST_USD = AST_USD() +ATA_USD = ATA_USD() @dataclass(slots=True, frozen=True) class ATA_USD: + """ + name: ATA-USD + precision: 0.0001 + minimum_margin: None + initial_margin: None + minimum_order_size: 1 + maximum_order_size: None + margin: False + """ name: str = "ATA-USD" precision: int = 0.0001 minimum_margin: float = None @@ -1217,11 +1699,20 @@ def __call__(self): return "ATA-USD" -ATA_USD = ATA_USD() +ATA_USDT = ATA_USDT() @dataclass(slots=True, frozen=True) class ATA_USDT: + """ + name: ATA-USDT + precision: 0.0001 + minimum_margin: None + initial_margin: None + minimum_order_size: 1 + maximum_order_size: None + margin: False + """ name: str = "ATA-USDT" precision: int = 0.0001 minimum_margin: float = None @@ -1240,11 +1731,20 @@ def __call__(self): return "ATA-USDT" -ATA_USDT = ATA_USDT() +ATOM_BTC = ATOM_BTC() @dataclass(slots=True, frozen=True) class ATOM_BTC: + """ + name: ATOM-BTC + precision: 0.0000001 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.000016 + maximum_order_size: None + margin: False + """ name: str = "ATOM-BTC" precision: int = 0.0000001 minimum_margin: float = None @@ -1263,11 +1763,20 @@ def __call__(self): return "ATOM-BTC" -ATOM_BTC = ATOM_BTC() +ATOM_EUR = ATOM_EUR() @dataclass(slots=True, frozen=True) class ATOM_EUR: + """ + name: ATOM-EUR + precision: 0.01 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.84 + maximum_order_size: None + margin: False + """ name: str = "ATOM-EUR" precision: int = 0.01 minimum_margin: float = None @@ -1286,11 +1795,20 @@ def __call__(self): return "ATOM-EUR" -ATOM_EUR = ATOM_EUR() +ATOM_GBP = ATOM_GBP() @dataclass(slots=True, frozen=True) class ATOM_GBP: + """ + name: ATOM-GBP + precision: 0.01 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.72 + maximum_order_size: None + margin: False + """ name: str = "ATOM-GBP" precision: int = 0.01 minimum_margin: float = None @@ -1309,11 +1827,20 @@ def __call__(self): return "ATOM-GBP" -ATOM_GBP = ATOM_GBP() +ATOM_USD = ATOM_USD() @dataclass(slots=True, frozen=True) class ATOM_USD: + """ + name: ATOM-USD + precision: 0.001 + minimum_margin: None + initial_margin: None + minimum_order_size: 1 + maximum_order_size: None + margin: False + """ name: str = "ATOM-USD" precision: int = 0.001 minimum_margin: float = None @@ -1332,11 +1859,20 @@ def __call__(self): return "ATOM-USD" -ATOM_USD = ATOM_USD() +ATOM_USDT = ATOM_USDT() @dataclass(slots=True, frozen=True) class ATOM_USDT: + """ + name: ATOM-USDT + precision: 0.01 + minimum_margin: None + initial_margin: None + minimum_order_size: 1 + maximum_order_size: None + margin: False + """ name: str = "ATOM-USDT" precision: int = 0.01 minimum_margin: float = None @@ -1355,11 +1891,20 @@ def __call__(self): return "ATOM-USDT" -ATOM_USDT = ATOM_USDT() +AUCTION_EUR = AUCTION_EUR() @dataclass(slots=True, frozen=True) class AUCTION_EUR: + """ + name: AUCTION-EUR + precision: 0.01 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.84 + maximum_order_size: None + margin: False + """ name: str = "AUCTION-EUR" precision: int = 0.01 minimum_margin: float = None @@ -1378,11 +1923,20 @@ def __call__(self): return "AUCTION-EUR" -AUCTION_EUR = AUCTION_EUR() +AUCTION_USD = AUCTION_USD() @dataclass(slots=True, frozen=True) class AUCTION_USD: + """ + name: AUCTION-USD + precision: 0.01 + minimum_margin: None + initial_margin: None + minimum_order_size: 1 + maximum_order_size: None + margin: False + """ name: str = "AUCTION-USD" precision: int = 0.01 minimum_margin: float = None @@ -1401,11 +1955,20 @@ def __call__(self): return "AUCTION-USD" -AUCTION_USD = AUCTION_USD() +AUCTION_USDT = AUCTION_USDT() @dataclass(slots=True, frozen=True) class AUCTION_USDT: + """ + name: AUCTION-USDT + precision: 0.01 + minimum_margin: None + initial_margin: None + minimum_order_size: 1 + maximum_order_size: None + margin: False + """ name: str = "AUCTION-USDT" precision: int = 0.01 minimum_margin: float = None @@ -1424,11 +1987,20 @@ def __call__(self): return "AUCTION-USDT" -AUCTION_USDT = AUCTION_USDT() +AURORA_USD = AURORA_USD() @dataclass(slots=True, frozen=True) class AURORA_USD: + """ + name: AURORA-USD + precision: 0.001 + minimum_margin: None + initial_margin: None + minimum_order_size: 1 + maximum_order_size: None + margin: False + """ name: str = "AURORA-USD" precision: int = 0.001 minimum_margin: float = None @@ -1447,11 +2019,20 @@ def __call__(self): return "AURORA-USD" -AURORA_USD = AURORA_USD() +AVAX_BTC = AVAX_BTC() @dataclass(slots=True, frozen=True) class AVAX_BTC: + """ + name: AVAX-BTC + precision: 0.00000001 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.000016 + maximum_order_size: None + margin: False + """ name: str = "AVAX-BTC" precision: int = 0.00000001 minimum_margin: float = None @@ -1470,11 +2051,20 @@ def __call__(self): return "AVAX-BTC" -AVAX_BTC = AVAX_BTC() +AVAX_EUR = AVAX_EUR() @dataclass(slots=True, frozen=True) class AVAX_EUR: + """ + name: AVAX-EUR + precision: 0.01 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.84 + maximum_order_size: None + margin: False + """ name: str = "AVAX-EUR" precision: int = 0.01 minimum_margin: float = None @@ -1493,11 +2083,20 @@ def __call__(self): return "AVAX-EUR" -AVAX_EUR = AVAX_EUR() +AVAX_USD = AVAX_USD() @dataclass(slots=True, frozen=True) class AVAX_USD: + """ + name: AVAX-USD + precision: 0.01 + minimum_margin: None + initial_margin: None + minimum_order_size: 1 + maximum_order_size: None + margin: False + """ name: str = "AVAX-USD" precision: int = 0.01 minimum_margin: float = None @@ -1516,11 +2115,20 @@ def __call__(self): return "AVAX-USD" -AVAX_USD = AVAX_USD() +AVAX_USDT = AVAX_USDT() @dataclass(slots=True, frozen=True) class AVAX_USDT: + """ + name: AVAX-USDT + precision: 0.01 + minimum_margin: None + initial_margin: None + minimum_order_size: 1 + maximum_order_size: None + margin: False + """ name: str = "AVAX-USDT" precision: int = 0.01 minimum_margin: float = None @@ -1539,11 +2147,20 @@ def __call__(self): return "AVAX-USDT" -AVAX_USDT = AVAX_USDT() +AVT_USD = AVT_USD() @dataclass(slots=True, frozen=True) class AVT_USD: + """ + name: AVT-USD + precision: 0.01 + minimum_margin: None + initial_margin: None + minimum_order_size: 1 + maximum_order_size: None + margin: False + """ name: str = "AVT-USD" precision: int = 0.01 minimum_margin: float = None @@ -1562,11 +2179,20 @@ def __call__(self): return "AVT-USD" -AVT_USD = AVT_USD() +AXS_BTC = AXS_BTC() @dataclass(slots=True, frozen=True) class AXS_BTC: + """ + name: AXS-BTC + precision: 0.0000001 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.000016 + maximum_order_size: None + margin: False + """ name: str = "AXS-BTC" precision: int = 0.0000001 minimum_margin: float = None @@ -1585,11 +2211,20 @@ def __call__(self): return "AXS-BTC" -AXS_BTC = AXS_BTC() +AXS_EUR = AXS_EUR() @dataclass(slots=True, frozen=True) class AXS_EUR: + """ + name: AXS-EUR + precision: 0.01 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.84 + maximum_order_size: None + margin: False + """ name: str = "AXS-EUR" precision: int = 0.01 minimum_margin: float = None @@ -1608,11 +2243,20 @@ def __call__(self): return "AXS-EUR" -AXS_EUR = AXS_EUR() +AXS_USD = AXS_USD() @dataclass(slots=True, frozen=True) class AXS_USD: + """ + name: AXS-USD + precision: 0.01 + minimum_margin: None + initial_margin: None + minimum_order_size: 1 + maximum_order_size: None + margin: False + """ name: str = "AXS-USD" precision: int = 0.01 minimum_margin: float = None @@ -1631,11 +2275,20 @@ def __call__(self): return "AXS-USD" -AXS_USD = AXS_USD() +AXS_USDT = AXS_USDT() @dataclass(slots=True, frozen=True) class AXS_USDT: + """ + name: AXS-USDT + precision: 0.01 + minimum_margin: None + initial_margin: None + minimum_order_size: 1 + maximum_order_size: None + margin: False + """ name: str = "AXS-USDT" precision: int = 0.01 minimum_margin: float = None @@ -1654,11 +2307,20 @@ def __call__(self): return "AXS-USDT" -AXS_USDT = AXS_USDT() +BADGER_EUR = BADGER_EUR() @dataclass(slots=True, frozen=True) class BADGER_EUR: + """ + name: BADGER-EUR + precision: 0.01 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.84 + maximum_order_size: None + margin: False + """ name: str = "BADGER-EUR" precision: int = 0.01 minimum_margin: float = None @@ -1677,11 +2339,20 @@ def __call__(self): return "BADGER-EUR" -BADGER_EUR = BADGER_EUR() +BADGER_USD = BADGER_USD() @dataclass(slots=True, frozen=True) class BADGER_USD: + """ + name: BADGER-USD + precision: 0.01 + minimum_margin: None + initial_margin: None + minimum_order_size: 1 + maximum_order_size: None + margin: False + """ name: str = "BADGER-USD" precision: int = 0.01 minimum_margin: float = None @@ -1700,11 +2371,20 @@ def __call__(self): return "BADGER-USD" -BADGER_USD = BADGER_USD() +BADGER_USDT = BADGER_USDT() @dataclass(slots=True, frozen=True) class BADGER_USDT: + """ + name: BADGER-USDT + precision: 0.01 + minimum_margin: None + initial_margin: None + minimum_order_size: 1 + maximum_order_size: None + margin: False + """ name: str = "BADGER-USDT" precision: int = 0.01 minimum_margin: float = None @@ -1723,11 +2403,20 @@ def __call__(self): return "BADGER-USDT" -BADGER_USDT = BADGER_USDT() +BAL_BTC = BAL_BTC() @dataclass(slots=True, frozen=True) class BAL_BTC: + """ + name: BAL-BTC + precision: 0.00000001 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.000016 + maximum_order_size: None + margin: False + """ name: str = "BAL-BTC" precision: int = 0.00000001 minimum_margin: float = None @@ -1746,11 +2435,20 @@ def __call__(self): return "BAL-BTC" -BAL_BTC = BAL_BTC() +BAL_USD = BAL_USD() @dataclass(slots=True, frozen=True) class BAL_USD: + """ + name: BAL-USD + precision: 0.01 + minimum_margin: None + initial_margin: None + minimum_order_size: 1 + maximum_order_size: None + margin: False + """ name: str = "BAL-USD" precision: int = 0.01 minimum_margin: float = None @@ -1769,11 +2467,20 @@ def __call__(self): return "BAL-USD" -BAL_USD = BAL_USD() +BAND_BTC = BAND_BTC() @dataclass(slots=True, frozen=True) class BAND_BTC: + """ + name: BAND-BTC + precision: 0.00000001 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.000016 + maximum_order_size: None + margin: False + """ name: str = "BAND-BTC" precision: int = 0.00000001 minimum_margin: float = None @@ -1792,11 +2499,20 @@ def __call__(self): return "BAND-BTC" -BAND_BTC = BAND_BTC() +BAND_EUR = BAND_EUR() @dataclass(slots=True, frozen=True) class BAND_EUR: + """ + name: BAND-EUR + precision: 0.01 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.84 + maximum_order_size: None + margin: False + """ name: str = "BAND-EUR" precision: int = 0.01 minimum_margin: float = None @@ -1815,11 +2531,20 @@ def __call__(self): return "BAND-EUR" -BAND_EUR = BAND_EUR() +BAND_GBP = BAND_GBP() @dataclass(slots=True, frozen=True) class BAND_GBP: + """ + name: BAND-GBP + precision: 0.001 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.72 + maximum_order_size: None + margin: False + """ name: str = "BAND-GBP" precision: int = 0.001 minimum_margin: float = None @@ -1838,11 +2563,20 @@ def __call__(self): return "BAND-GBP" -BAND_GBP = BAND_GBP() +BAND_USD = BAND_USD() @dataclass(slots=True, frozen=True) class BAND_USD: + """ + name: BAND-USD + precision: 0.001 + minimum_margin: None + initial_margin: None + minimum_order_size: 1 + maximum_order_size: None + margin: False + """ name: str = "BAND-USD" precision: int = 0.001 minimum_margin: float = None @@ -1861,11 +2595,20 @@ def __call__(self): return "BAND-USD" -BAND_USD = BAND_USD() +BAT_BTC = BAT_BTC() @dataclass(slots=True, frozen=True) class BAT_BTC: + """ + name: BAT-BTC + precision: 0.00000001 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.000016 + maximum_order_size: None + margin: False + """ name: str = "BAT-BTC" precision: int = 0.00000001 minimum_margin: float = None @@ -1884,11 +2627,20 @@ def __call__(self): return "BAT-BTC" -BAT_BTC = BAT_BTC() +BAT_ETH = BAT_ETH() @dataclass(slots=True, frozen=True) class BAT_ETH: + """ + name: BAT-ETH + precision: 0.00000001 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.00022 + maximum_order_size: None + margin: False + """ name: str = "BAT-ETH" precision: int = 0.00000001 minimum_margin: float = None @@ -1907,11 +2659,20 @@ def __call__(self): return "BAT-ETH" -BAT_ETH = BAT_ETH() +BAT_EUR = BAT_EUR() @dataclass(slots=True, frozen=True) class BAT_EUR: + """ + name: BAT-EUR + precision: 0.00001 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.84 + maximum_order_size: None + margin: False + """ name: str = "BAT-EUR" precision: int = 0.00001 minimum_margin: float = None @@ -1930,11 +2691,20 @@ def __call__(self): return "BAT-EUR" -BAT_EUR = BAT_EUR() +BAT_USD = BAT_USD() @dataclass(slots=True, frozen=True) class BAT_USD: + """ + name: BAT-USD + precision: 0.00001 + minimum_margin: None + initial_margin: None + minimum_order_size: 1 + maximum_order_size: None + margin: False + """ name: str = "BAT-USD" precision: int = 0.00001 minimum_margin: float = None @@ -1953,11 +2723,20 @@ def __call__(self): return "BAT-USD" -BAT_USD = BAT_USD() +BAT_USDC = BAT_USDC() @dataclass(slots=True, frozen=True) class BAT_USDC: + """ + name: BAT-USDC + precision: 0.000001 + minimum_margin: None + initial_margin: None + minimum_order_size: 1 + maximum_order_size: None + margin: False + """ name: str = "BAT-USDC" precision: int = 0.000001 minimum_margin: float = None @@ -1976,11 +2755,20 @@ def __call__(self): return "BAT-USDC" -BAT_USDC = BAT_USDC() +BCH_BTC = BCH_BTC() @dataclass(slots=True, frozen=True) class BCH_BTC: + """ + name: BCH-BTC + precision: 0.000001 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.00001 + maximum_order_size: None + margin: False + """ name: str = "BCH-BTC" precision: int = 0.000001 minimum_margin: float = None @@ -1999,11 +2787,20 @@ def __call__(self): return "BCH-BTC" -BCH_BTC = BCH_BTC() +BCH_EUR = BCH_EUR() @dataclass(slots=True, frozen=True) class BCH_EUR: + """ + name: BCH-EUR + precision: 0.01 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.84 + maximum_order_size: None + margin: False + """ name: str = "BCH-EUR" precision: int = 0.01 minimum_margin: float = None @@ -2022,11 +2819,20 @@ def __call__(self): return "BCH-EUR" -BCH_EUR = BCH_EUR() +BCH_GBP = BCH_GBP() @dataclass(slots=True, frozen=True) class BCH_GBP: + """ + name: BCH-GBP + precision: 0.01 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.72 + maximum_order_size: None + margin: False + """ name: str = "BCH-GBP" precision: int = 0.01 minimum_margin: float = None @@ -2045,11 +2851,20 @@ def __call__(self): return "BCH-GBP" -BCH_GBP = BCH_GBP() +BCH_USD = BCH_USD() @dataclass(slots=True, frozen=True) class BCH_USD: + """ + name: BCH-USD + precision: 0.01 + minimum_margin: None + initial_margin: None + minimum_order_size: 1 + maximum_order_size: None + margin: False + """ name: str = "BCH-USD" precision: int = 0.01 minimum_margin: float = None @@ -2068,11 +2883,20 @@ def __call__(self): return "BCH-USD" -BCH_USD = BCH_USD() +BICO_EUR = BICO_EUR() @dataclass(slots=True, frozen=True) class BICO_EUR: + """ + name: BICO-EUR + precision: 0.0001 + minimum_margin: None + initial_margin: None + minimum_order_size: 1 + maximum_order_size: None + margin: False + """ name: str = "BICO-EUR" precision: int = 0.0001 minimum_margin: float = None @@ -2091,11 +2915,20 @@ def __call__(self): return "BICO-EUR" -BICO_EUR = BICO_EUR() +BICO_USD = BICO_USD() @dataclass(slots=True, frozen=True) class BICO_USD: + """ + name: BICO-USD + precision: 0.0001 + minimum_margin: None + initial_margin: None + minimum_order_size: 1 + maximum_order_size: None + margin: False + """ name: str = "BICO-USD" precision: int = 0.0001 minimum_margin: float = None @@ -2114,11 +2947,20 @@ def __call__(self): return "BICO-USD" -BICO_USD = BICO_USD() +BICO_USDT = BICO_USDT() @dataclass(slots=True, frozen=True) class BICO_USDT: + """ + name: BICO-USDT + precision: 0.0001 + minimum_margin: None + initial_margin: None + minimum_order_size: 1 + maximum_order_size: None + margin: False + """ name: str = "BICO-USDT" precision: int = 0.0001 minimum_margin: float = None @@ -2137,11 +2979,20 @@ def __call__(self): return "BICO-USDT" -BICO_USDT = BICO_USDT() +BIT_USD = BIT_USD() @dataclass(slots=True, frozen=True) class BIT_USD: + """ + name: BIT-USD + precision: 0.0001 + minimum_margin: None + initial_margin: None + minimum_order_size: 1 + maximum_order_size: None + margin: False + """ name: str = "BIT-USD" precision: int = 0.0001 minimum_margin: float = None @@ -2160,11 +3011,20 @@ def __call__(self): return "BIT-USD" -BIT_USD = BIT_USD() +BIT_USDT = BIT_USDT() @dataclass(slots=True, frozen=True) class BIT_USDT: + """ + name: BIT-USDT + precision: 0.0001 + minimum_margin: None + initial_margin: None + minimum_order_size: 1 + maximum_order_size: None + margin: False + """ name: str = "BIT-USDT" precision: int = 0.0001 minimum_margin: float = None @@ -2183,11 +3043,20 @@ def __call__(self): return "BIT-USDT" -BIT_USDT = BIT_USDT() +BLZ_USD = BLZ_USD() @dataclass(slots=True, frozen=True) class BLZ_USD: + """ + name: BLZ-USD + precision: 0.0001 + minimum_margin: None + initial_margin: None + minimum_order_size: 1 + maximum_order_size: None + margin: False + """ name: str = "BLZ-USD" precision: int = 0.0001 minimum_margin: float = None @@ -2206,11 +3075,20 @@ def __call__(self): return "BLZ-USD" -BLZ_USD = BLZ_USD() +BNT_BTC = BNT_BTC() @dataclass(slots=True, frozen=True) class BNT_BTC: + """ + name: BNT-BTC + precision: 0.00000001 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.000016 + maximum_order_size: None + margin: False + """ name: str = "BNT-BTC" precision: int = 0.00000001 minimum_margin: float = None @@ -2229,11 +3107,20 @@ def __call__(self): return "BNT-BTC" -BNT_BTC = BNT_BTC() +BNT_EUR = BNT_EUR() @dataclass(slots=True, frozen=True) class BNT_EUR: + """ + name: BNT-EUR + precision: 0.001 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.84 + maximum_order_size: None + margin: False + """ name: str = "BNT-EUR" precision: int = 0.001 minimum_margin: float = None @@ -2252,11 +3139,20 @@ def __call__(self): return "BNT-EUR" -BNT_EUR = BNT_EUR() +BNT_GBP = BNT_GBP() @dataclass(slots=True, frozen=True) class BNT_GBP: + """ + name: BNT-GBP + precision: 0.0001 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.72 + maximum_order_size: None + margin: False + """ name: str = "BNT-GBP" precision: int = 0.0001 minimum_margin: float = None @@ -2275,11 +3171,20 @@ def __call__(self): return "BNT-GBP" -BNT_GBP = BNT_GBP() +BNT_USD = BNT_USD() @dataclass(slots=True, frozen=True) class BNT_USD: + """ + name: BNT-USD + precision: 0.0001 + minimum_margin: None + initial_margin: None + minimum_order_size: 1 + maximum_order_size: None + margin: False + """ name: str = "BNT-USD" precision: int = 0.0001 minimum_margin: float = None @@ -2298,11 +3203,20 @@ def __call__(self): return "BNT-USD" -BNT_USD = BNT_USD() +BOBA_USD = BOBA_USD() @dataclass(slots=True, frozen=True) class BOBA_USD: + """ + name: BOBA-USD + precision: 0.0001 + minimum_margin: None + initial_margin: None + minimum_order_size: 1 + maximum_order_size: None + margin: False + """ name: str = "BOBA-USD" precision: int = 0.0001 minimum_margin: float = None @@ -2321,11 +3235,20 @@ def __call__(self): return "BOBA-USD" -BOBA_USD = BOBA_USD() +BOBA_USDT = BOBA_USDT() @dataclass(slots=True, frozen=True) class BOBA_USDT: + """ + name: BOBA-USDT + precision: 0.0001 + minimum_margin: None + initial_margin: None + minimum_order_size: 1 + maximum_order_size: None + margin: False + """ name: str = "BOBA-USDT" precision: int = 0.0001 minimum_margin: float = None @@ -2344,11 +3267,20 @@ def __call__(self): return "BOBA-USDT" -BOBA_USDT = BOBA_USDT() +BOND_USD = BOND_USD() @dataclass(slots=True, frozen=True) class BOND_USD: + """ + name: BOND-USD + precision: 0.01 + minimum_margin: None + initial_margin: None + minimum_order_size: 1 + maximum_order_size: None + margin: False + """ name: str = "BOND-USD" precision: int = 0.01 minimum_margin: float = None @@ -2367,11 +3299,20 @@ def __call__(self): return "BOND-USD" -BOND_USD = BOND_USD() +BOND_USDT = BOND_USDT() @dataclass(slots=True, frozen=True) class BOND_USDT: + """ + name: BOND-USDT + precision: 0.001 + minimum_margin: None + initial_margin: None + minimum_order_size: 1 + maximum_order_size: None + margin: False + """ name: str = "BOND-USDT" precision: int = 0.001 minimum_margin: float = None @@ -2390,11 +3331,20 @@ def __call__(self): return "BOND-USDT" -BOND_USDT = BOND_USDT() +BTC_EUR = BTC_EUR() @dataclass(slots=True, frozen=True) class BTC_EUR: + """ + name: BTC-EUR + precision: 0.01 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.84 + maximum_order_size: None + margin: False + """ name: str = "BTC-EUR" precision: int = 0.01 minimum_margin: float = None @@ -2413,11 +3363,20 @@ def __call__(self): return "BTC-EUR" -BTC_EUR = BTC_EUR() +BTC_GBP = BTC_GBP() @dataclass(slots=True, frozen=True) class BTC_GBP: + """ + name: BTC-GBP + precision: 0.01 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.72 + maximum_order_size: None + margin: False + """ name: str = "BTC-GBP" precision: int = 0.01 minimum_margin: float = None @@ -2436,11 +3395,20 @@ def __call__(self): return "BTC-GBP" -BTC_GBP = BTC_GBP() +BTC_USD = BTC_USD() @dataclass(slots=True, frozen=True) class BTC_USD: + """ + name: BTC-USD + precision: 0.01 + minimum_margin: None + initial_margin: None + minimum_order_size: 1 + maximum_order_size: None + margin: False + """ name: str = "BTC-USD" precision: int = 0.01 minimum_margin: float = None @@ -2459,11 +3427,20 @@ def __call__(self): return "BTC-USD" -BTC_USD = BTC_USD() +BTC_USDC = BTC_USDC() @dataclass(slots=True, frozen=True) class BTC_USDC: + """ + name: BTC-USDC + precision: 1 + minimum_margin: None + initial_margin: None + minimum_order_size: 1 + maximum_order_size: None + margin: False + """ name: str = "BTC-USDC" precision: int = 1 minimum_margin: float = None @@ -2482,11 +3459,20 @@ def __call__(self): return "BTC-USDC" -BTC_USDC = BTC_USDC() +BTC_USDT = BTC_USDT() @dataclass(slots=True, frozen=True) class BTC_USDT: + """ + name: BTC-USDT + precision: 0.01 + minimum_margin: None + initial_margin: None + minimum_order_size: 1 + maximum_order_size: None + margin: False + """ name: str = "BTC-USDT" precision: int = 0.01 minimum_margin: float = None @@ -2505,11 +3491,20 @@ def __call__(self): return "BTC-USDT" -BTC_USDT = BTC_USDT() +BTRST_BTC = BTRST_BTC() @dataclass(slots=True, frozen=True) class BTRST_BTC: + """ + name: BTRST-BTC + precision: 0.00000001 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.000016 + maximum_order_size: None + margin: False + """ name: str = "BTRST-BTC" precision: int = 0.00000001 minimum_margin: float = None @@ -2528,11 +3523,20 @@ def __call__(self): return "BTRST-BTC" -BTRST_BTC = BTRST_BTC() +BTRST_EUR = BTRST_EUR() @dataclass(slots=True, frozen=True) class BTRST_EUR: + """ + name: BTRST-EUR + precision: 0.01 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.84 + maximum_order_size: None + margin: False + """ name: str = "BTRST-EUR" precision: int = 0.01 minimum_margin: float = None @@ -2551,11 +3555,20 @@ def __call__(self): return "BTRST-EUR" -BTRST_EUR = BTRST_EUR() +BTRST_GBP = BTRST_GBP() @dataclass(slots=True, frozen=True) class BTRST_GBP: + """ + name: BTRST-GBP + precision: 0.001 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.72 + maximum_order_size: None + margin: False + """ name: str = "BTRST-GBP" precision: int = 0.001 minimum_margin: float = None @@ -2574,11 +3587,20 @@ def __call__(self): return "BTRST-GBP" -BTRST_GBP = BTRST_GBP() +BTRST_USD = BTRST_USD() @dataclass(slots=True, frozen=True) class BTRST_USD: + """ + name: BTRST-USD + precision: 0.001 + minimum_margin: None + initial_margin: None + minimum_order_size: 1 + maximum_order_size: None + margin: False + """ name: str = "BTRST-USD" precision: int = 0.001 minimum_margin: float = None @@ -2597,11 +3619,20 @@ def __call__(self): return "BTRST-USD" -BTRST_USD = BTRST_USD() +BTRST_USDT = BTRST_USDT() @dataclass(slots=True, frozen=True) class BTRST_USDT: + """ + name: BTRST-USDT + precision: 0.001 + minimum_margin: None + initial_margin: None + minimum_order_size: 1 + maximum_order_size: None + margin: False + """ name: str = "BTRST-USDT" precision: int = 0.001 minimum_margin: float = None @@ -2620,11 +3651,20 @@ def __call__(self): return "BTRST-USDT" -BTRST_USDT = BTRST_USDT() +BUSD_USD = BUSD_USD() @dataclass(slots=True, frozen=True) class BUSD_USD: + """ + name: BUSD-USD + precision: 0.001 + minimum_margin: None + initial_margin: None + minimum_order_size: 1 + maximum_order_size: None + margin: False + """ name: str = "BUSD-USD" precision: int = 0.001 minimum_margin: float = None @@ -2643,11 +3683,20 @@ def __call__(self): return "BUSD-USD" -BUSD_USD = BUSD_USD() +C98_USD = C98_USD() @dataclass(slots=True, frozen=True) class C98_USD: + """ + name: C98-USD + precision: 0.0001 + minimum_margin: None + initial_margin: None + minimum_order_size: 1 + maximum_order_size: None + margin: False + """ name: str = "C98-USD" precision: int = 0.0001 minimum_margin: float = None @@ -2666,11 +3715,20 @@ def __call__(self): return "C98-USD" -C98_USD = C98_USD() +C98_USDT = C98_USDT() @dataclass(slots=True, frozen=True) class C98_USDT: + """ + name: C98-USDT + precision: 0.0001 + minimum_margin: None + initial_margin: None + minimum_order_size: 1 + maximum_order_size: None + margin: False + """ name: str = "C98-USDT" precision: int = 0.0001 minimum_margin: float = None @@ -2689,11 +3747,20 @@ def __call__(self): return "C98-USDT" -C98_USDT = C98_USDT() +CBETH_ETH = CBETH_ETH() @dataclass(slots=True, frozen=True) class CBETH_ETH: + """ + name: CBETH-ETH + precision: 0.00001 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.002 + maximum_order_size: None + margin: False + """ name: str = "CBETH-ETH" precision: int = 0.00001 minimum_margin: float = None @@ -2712,11 +3779,20 @@ def __call__(self): return "CBETH-ETH" -CBETH_ETH = CBETH_ETH() +CBETH_USD = CBETH_USD() @dataclass(slots=True, frozen=True) class CBETH_USD: + """ + name: CBETH-USD + precision: 0.01 + minimum_margin: None + initial_margin: None + minimum_order_size: 1 + maximum_order_size: None + margin: False + """ name: str = "CBETH-USD" precision: int = 0.01 minimum_margin: float = None @@ -2735,11 +3811,20 @@ def __call__(self): return "CBETH-USD" -CBETH_USD = CBETH_USD() +CELR_USD = CELR_USD() @dataclass(slots=True, frozen=True) class CELR_USD: + """ + name: CELR-USD + precision: 0.00001 + minimum_margin: None + initial_margin: None + minimum_order_size: 1 + maximum_order_size: None + margin: False + """ name: str = "CELR-USD" precision: int = 0.00001 minimum_margin: float = None @@ -2758,11 +3843,20 @@ def __call__(self): return "CELR-USD" -CELR_USD = CELR_USD() +CGLD_BTC = CGLD_BTC() @dataclass(slots=True, frozen=True) class CGLD_BTC: + """ + name: CGLD-BTC + precision: 0.00000001 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.000016 + maximum_order_size: None + margin: False + """ name: str = "CGLD-BTC" precision: int = 0.00000001 minimum_margin: float = None @@ -2781,11 +3875,20 @@ def __call__(self): return "CGLD-BTC" -CGLD_BTC = CGLD_BTC() +CGLD_EUR = CGLD_EUR() @dataclass(slots=True, frozen=True) class CGLD_EUR: + """ + name: CGLD-EUR + precision: 0.01 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.84 + maximum_order_size: None + margin: False + """ name: str = "CGLD-EUR" precision: int = 0.01 minimum_margin: float = None @@ -2804,11 +3907,20 @@ def __call__(self): return "CGLD-EUR" -CGLD_EUR = CGLD_EUR() +CGLD_GBP = CGLD_GBP() @dataclass(slots=True, frozen=True) class CGLD_GBP: + """ + name: CGLD-GBP + precision: 0.001 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.72 + maximum_order_size: None + margin: False + """ name: str = "CGLD-GBP" precision: int = 0.001 minimum_margin: float = None @@ -2827,11 +3939,20 @@ def __call__(self): return "CGLD-GBP" -CGLD_GBP = CGLD_GBP() +CGLD_USD = CGLD_USD() @dataclass(slots=True, frozen=True) class CGLD_USD: + """ + name: CGLD-USD + precision: 0.001 + minimum_margin: None + initial_margin: None + minimum_order_size: 1 + maximum_order_size: None + margin: False + """ name: str = "CGLD-USD" precision: int = 0.001 minimum_margin: float = None @@ -2850,11 +3971,20 @@ def __call__(self): return "CGLD-USD" -CGLD_USD = CGLD_USD() +CHZ_EUR = CHZ_EUR() @dataclass(slots=True, frozen=True) class CHZ_EUR: + """ + name: CHZ-EUR + precision: 0.0001 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.84 + maximum_order_size: None + margin: False + """ name: str = "CHZ-EUR" precision: int = 0.0001 minimum_margin: float = None @@ -2873,11 +4003,20 @@ def __call__(self): return "CHZ-EUR" -CHZ_EUR = CHZ_EUR() +CHZ_GBP = CHZ_GBP() @dataclass(slots=True, frozen=True) class CHZ_GBP: + """ + name: CHZ-GBP + precision: 0.0001 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.72 + maximum_order_size: None + margin: False + """ name: str = "CHZ-GBP" precision: int = 0.0001 minimum_margin: float = None @@ -2896,11 +4035,20 @@ def __call__(self): return "CHZ-GBP" -CHZ_GBP = CHZ_GBP() +CHZ_USD = CHZ_USD() @dataclass(slots=True, frozen=True) class CHZ_USD: + """ + name: CHZ-USD + precision: 0.0001 + minimum_margin: None + initial_margin: None + minimum_order_size: 1 + maximum_order_size: None + margin: False + """ name: str = "CHZ-USD" precision: int = 0.0001 minimum_margin: float = None @@ -2919,11 +4067,20 @@ def __call__(self): return "CHZ-USD" -CHZ_USD = CHZ_USD() +CHZ_USDT = CHZ_USDT() @dataclass(slots=True, frozen=True) class CHZ_USDT: + """ + name: CHZ-USDT + precision: 0.0001 + minimum_margin: None + initial_margin: None + minimum_order_size: 1 + maximum_order_size: None + margin: False + """ name: str = "CHZ-USDT" precision: int = 0.0001 minimum_margin: float = None @@ -2942,11 +4099,20 @@ def __call__(self): return "CHZ-USDT" -CHZ_USDT = CHZ_USDT() +CLV_EUR = CLV_EUR() @dataclass(slots=True, frozen=True) class CLV_EUR: + """ + name: CLV-EUR + precision: 0.00001 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.84 + maximum_order_size: None + margin: False + """ name: str = "CLV-EUR" precision: int = 0.00001 minimum_margin: float = None @@ -2965,11 +4131,20 @@ def __call__(self): return "CLV-EUR" -CLV_EUR = CLV_EUR() +CLV_GBP = CLV_GBP() @dataclass(slots=True, frozen=True) class CLV_GBP: + """ + name: CLV-GBP + precision: 0.0001 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.72 + maximum_order_size: None + margin: False + """ name: str = "CLV-GBP" precision: int = 0.0001 minimum_margin: float = None @@ -2988,11 +4163,20 @@ def __call__(self): return "CLV-GBP" -CLV_GBP = CLV_GBP() +CLV_USD = CLV_USD() @dataclass(slots=True, frozen=True) class CLV_USD: + """ + name: CLV-USD + precision: 0.0001 + minimum_margin: None + initial_margin: None + minimum_order_size: 1 + maximum_order_size: None + margin: False + """ name: str = "CLV-USD" precision: int = 0.0001 minimum_margin: float = None @@ -3011,11 +4195,20 @@ def __call__(self): return "CLV-USD" -CLV_USD = CLV_USD() +CLV_USDT = CLV_USDT() @dataclass(slots=True, frozen=True) class CLV_USDT: + """ + name: CLV-USDT + precision: 0.0001 + minimum_margin: None + initial_margin: None + minimum_order_size: 1 + maximum_order_size: None + margin: False + """ name: str = "CLV-USDT" precision: int = 0.0001 minimum_margin: float = None @@ -3034,11 +4227,20 @@ def __call__(self): return "CLV-USDT" -CLV_USDT = CLV_USDT() +COMP_BTC = COMP_BTC() @dataclass(slots=True, frozen=True) class COMP_BTC: + """ + name: COMP-BTC + precision: 0.000001 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.000016 + maximum_order_size: None + margin: False + """ name: str = "COMP-BTC" precision: int = 0.000001 minimum_margin: float = None @@ -3057,11 +4259,20 @@ def __call__(self): return "COMP-BTC" -COMP_BTC = COMP_BTC() +COMP_USD = COMP_USD() @dataclass(slots=True, frozen=True) class COMP_USD: + """ + name: COMP-USD + precision: 0.01 + minimum_margin: None + initial_margin: None + minimum_order_size: 1 + maximum_order_size: None + margin: False + """ name: str = "COMP-USD" precision: int = 0.01 minimum_margin: float = None @@ -3080,11 +4291,20 @@ def __call__(self): return "COMP-USD" -COMP_USD = COMP_USD() +COTI_USD = COTI_USD() @dataclass(slots=True, frozen=True) class COTI_USD: + """ + name: COTI-USD + precision: 0.0001 + minimum_margin: None + initial_margin: None + minimum_order_size: 1 + maximum_order_size: None + margin: False + """ name: str = "COTI-USD" precision: int = 0.0001 minimum_margin: float = None @@ -3103,11 +4323,20 @@ def __call__(self): return "COTI-USD" -COTI_USD = COTI_USD() +COVAL_USD = COVAL_USD() @dataclass(slots=True, frozen=True) class COVAL_USD: + """ + name: COVAL-USD + precision: 0.00001 + minimum_margin: None + initial_margin: None + minimum_order_size: 1 + maximum_order_size: None + margin: False + """ name: str = "COVAL-USD" precision: int = 0.00001 minimum_margin: float = None @@ -3126,11 +4355,20 @@ def __call__(self): return "COVAL-USD" -COVAL_USD = COVAL_USD() +COVAL_USDT = COVAL_USDT() @dataclass(slots=True, frozen=True) class COVAL_USDT: + """ + name: COVAL-USDT + precision: 0.00001 + minimum_margin: None + initial_margin: None + minimum_order_size: 1 + maximum_order_size: None + margin: False + """ name: str = "COVAL-USDT" precision: int = 0.00001 minimum_margin: float = None @@ -3149,11 +4387,20 @@ def __call__(self): return "COVAL-USDT" -COVAL_USDT = COVAL_USDT() +CRO_EUR = CRO_EUR() @dataclass(slots=True, frozen=True) class CRO_EUR: + """ + name: CRO-EUR + precision: 0.0001 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.84 + maximum_order_size: None + margin: False + """ name: str = "CRO-EUR" precision: int = 0.0001 minimum_margin: float = None @@ -3172,11 +4419,20 @@ def __call__(self): return "CRO-EUR" -CRO_EUR = CRO_EUR() +CRO_USD = CRO_USD() @dataclass(slots=True, frozen=True) class CRO_USD: + """ + name: CRO-USD + precision: 0.0001 + minimum_margin: None + initial_margin: None + minimum_order_size: 1 + maximum_order_size: None + margin: False + """ name: str = "CRO-USD" precision: int = 0.0001 minimum_margin: float = None @@ -3195,11 +4451,20 @@ def __call__(self): return "CRO-USD" -CRO_USD = CRO_USD() +CRO_USDT = CRO_USDT() @dataclass(slots=True, frozen=True) class CRO_USDT: + """ + name: CRO-USDT + precision: 0.0001 + minimum_margin: None + initial_margin: None + minimum_order_size: 1 + maximum_order_size: None + margin: False + """ name: str = "CRO-USDT" precision: int = 0.0001 minimum_margin: float = None @@ -3218,11 +4483,20 @@ def __call__(self): return "CRO-USDT" -CRO_USDT = CRO_USDT() +CRPT_USD = CRPT_USD() @dataclass(slots=True, frozen=True) class CRPT_USD: + """ + name: CRPT-USD + precision: 0.0001 + minimum_margin: None + initial_margin: None + minimum_order_size: 1 + maximum_order_size: None + margin: False + """ name: str = "CRPT-USD" precision: int = 0.0001 minimum_margin: float = None @@ -3241,11 +4515,20 @@ def __call__(self): return "CRPT-USD" -CRPT_USD = CRPT_USD() +CRV_BTC = CRV_BTC() @dataclass(slots=True, frozen=True) class CRV_BTC: + """ + name: CRV-BTC + precision: 0.0000001 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.000016 + maximum_order_size: None + margin: False + """ name: str = "CRV-BTC" precision: int = 0.0000001 minimum_margin: float = None @@ -3264,11 +4547,20 @@ def __call__(self): return "CRV-BTC" -CRV_BTC = CRV_BTC() +CRV_EUR = CRV_EUR() @dataclass(slots=True, frozen=True) class CRV_EUR: + """ + name: CRV-EUR + precision: 0.0001 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.84 + maximum_order_size: None + margin: False + """ name: str = "CRV-EUR" precision: int = 0.0001 minimum_margin: float = None @@ -3287,11 +4579,20 @@ def __call__(self): return "CRV-EUR" -CRV_EUR = CRV_EUR() +CRV_GBP = CRV_GBP() @dataclass(slots=True, frozen=True) class CRV_GBP: + """ + name: CRV-GBP + precision: 0.0001 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.72 + maximum_order_size: None + margin: False + """ name: str = "CRV-GBP" precision: int = 0.0001 minimum_margin: float = None @@ -3310,11 +4611,20 @@ def __call__(self): return "CRV-GBP" -CRV_GBP = CRV_GBP() +CRV_USD = CRV_USD() @dataclass(slots=True, frozen=True) class CRV_USD: + """ + name: CRV-USD + precision: 0.0001 + minimum_margin: None + initial_margin: None + minimum_order_size: 1 + maximum_order_size: None + margin: False + """ name: str = "CRV-USD" precision: int = 0.0001 minimum_margin: float = None @@ -3333,11 +4643,20 @@ def __call__(self): return "CRV-USD" -CRV_USD = CRV_USD() +CTSI_BTC = CTSI_BTC() @dataclass(slots=True, frozen=True) class CTSI_BTC: + """ + name: CTSI-BTC + precision: 0.0000001 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.000016 + maximum_order_size: None + margin: False + """ name: str = "CTSI-BTC" precision: int = 0.0000001 minimum_margin: float = None @@ -3356,11 +4675,20 @@ def __call__(self): return "CTSI-BTC" -CTSI_BTC = CTSI_BTC() +CTSI_USD = CTSI_USD() @dataclass(slots=True, frozen=True) class CTSI_USD: + """ + name: CTSI-USD + precision: 0.0001 + minimum_margin: None + initial_margin: None + minimum_order_size: 1 + maximum_order_size: None + margin: False + """ name: str = "CTSI-USD" precision: int = 0.0001 minimum_margin: float = None @@ -3379,11 +4707,20 @@ def __call__(self): return "CTSI-USD" -CTSI_USD = CTSI_USD() +CTX_EUR = CTX_EUR() @dataclass(slots=True, frozen=True) class CTX_EUR: + """ + name: CTX-EUR + precision: 0.01 + minimum_margin: None + initial_margin: None + minimum_order_size: 1 + maximum_order_size: None + margin: False + """ name: str = "CTX-EUR" precision: int = 0.01 minimum_margin: float = None @@ -3402,11 +4739,20 @@ def __call__(self): return "CTX-EUR" -CTX_EUR = CTX_EUR() +CTX_USD = CTX_USD() @dataclass(slots=True, frozen=True) class CTX_USD: + """ + name: CTX-USD + precision: 0.01 + minimum_margin: None + initial_margin: None + minimum_order_size: 5 + maximum_order_size: None + margin: False + """ name: str = "CTX-USD" precision: int = 0.01 minimum_margin: float = None @@ -3425,11 +4771,20 @@ def __call__(self): return "CTX-USD" -CTX_USD = CTX_USD() +CTX_USDT = CTX_USDT() @dataclass(slots=True, frozen=True) class CTX_USDT: + """ + name: CTX-USDT + precision: 0.01 + minimum_margin: None + initial_margin: None + minimum_order_size: 5 + maximum_order_size: None + margin: False + """ name: str = "CTX-USDT" precision: int = 0.01 minimum_margin: float = None @@ -3448,11 +4803,20 @@ def __call__(self): return "CTX-USDT" -CTX_USDT = CTX_USDT() +CVC_USD = CVC_USD() @dataclass(slots=True, frozen=True) class CVC_USD: + """ + name: CVC-USD + precision: 0.0001 + minimum_margin: None + initial_margin: None + minimum_order_size: 1 + maximum_order_size: None + margin: False + """ name: str = "CVC-USD" precision: int = 0.0001 minimum_margin: float = None @@ -3471,11 +4835,20 @@ def __call__(self): return "CVC-USD" -CVC_USD = CVC_USD() +CVC_USDC = CVC_USDC() @dataclass(slots=True, frozen=True) class CVC_USDC: + """ + name: CVC-USDC + precision: 0.000001 + minimum_margin: None + initial_margin: None + minimum_order_size: 1 + maximum_order_size: None + margin: False + """ name: str = "CVC-USDC" precision: int = 0.000001 minimum_margin: float = None @@ -3494,11 +4867,20 @@ def __call__(self): return "CVC-USDC" -CVC_USDC = CVC_USDC() +CVX_USD = CVX_USD() @dataclass(slots=True, frozen=True) class CVX_USD: + """ + name: CVX-USD + precision: 0.001 + minimum_margin: None + initial_margin: None + minimum_order_size: 1 + maximum_order_size: None + margin: False + """ name: str = "CVX-USD" precision: int = 0.001 minimum_margin: float = None @@ -3517,11 +4899,20 @@ def __call__(self): return "CVX-USD" -CVX_USD = CVX_USD() +DAI_USD = DAI_USD() @dataclass(slots=True, frozen=True) class DAI_USD: + """ + name: DAI-USD + precision: 0.0001 + minimum_margin: None + initial_margin: None + minimum_order_size: 1 + maximum_order_size: None + margin: False + """ name: str = "DAI-USD" precision: int = 0.0001 minimum_margin: float = None @@ -3540,11 +4931,20 @@ def __call__(self): return "DAI-USD" -DAI_USD = DAI_USD() +DAI_USDC = DAI_USDC() @dataclass(slots=True, frozen=True) class DAI_USDC: + """ + name: DAI-USDC + precision: 0.0001 + minimum_margin: None + initial_margin: None + minimum_order_size: 1 + maximum_order_size: None + margin: False + """ name: str = "DAI-USDC" precision: int = 0.0001 minimum_margin: float = None @@ -3563,11 +4963,20 @@ def __call__(self): return "DAI-USDC" -DAI_USDC = DAI_USDC() +DAR_USD = DAR_USD() @dataclass(slots=True, frozen=True) class DAR_USD: + """ + name: DAR-USD + precision: 0.001 + minimum_margin: None + initial_margin: None + minimum_order_size: 1 + maximum_order_size: None + margin: False + """ name: str = "DAR-USD" precision: int = 0.001 minimum_margin: float = None @@ -3586,11 +4995,20 @@ def __call__(self): return "DAR-USD" -DAR_USD = DAR_USD() +DASH_BTC = DASH_BTC() @dataclass(slots=True, frozen=True) class DASH_BTC: + """ + name: DASH-BTC + precision: 0.000001 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.000016 + maximum_order_size: None + margin: False + """ name: str = "DASH-BTC" precision: int = 0.000001 minimum_margin: float = None @@ -3609,11 +5027,20 @@ def __call__(self): return "DASH-BTC" -DASH_BTC = DASH_BTC() +DASH_USD = DASH_USD() @dataclass(slots=True, frozen=True) class DASH_USD: + """ + name: DASH-USD + precision: 0.01 + minimum_margin: None + initial_margin: None + minimum_order_size: 1 + maximum_order_size: None + margin: False + """ name: str = "DASH-USD" precision: int = 0.01 minimum_margin: float = None @@ -3632,11 +5059,20 @@ def __call__(self): return "DASH-USD" -DASH_USD = DASH_USD() +DDX_EUR = DDX_EUR() @dataclass(slots=True, frozen=True) class DDX_EUR: + """ + name: DDX-EUR + precision: 0.0001 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.84 + maximum_order_size: None + margin: False + """ name: str = "DDX-EUR" precision: int = 0.0001 minimum_margin: float = None @@ -3655,11 +5091,20 @@ def __call__(self): return "DDX-EUR" -DDX_EUR = DDX_EUR() +DDX_USD = DDX_USD() @dataclass(slots=True, frozen=True) class DDX_USD: + """ + name: DDX-USD + precision: 0.0001 + minimum_margin: None + initial_margin: None + minimum_order_size: 1 + maximum_order_size: None + margin: False + """ name: str = "DDX-USD" precision: int = 0.0001 minimum_margin: float = None @@ -3678,11 +5123,20 @@ def __call__(self): return "DDX-USD" -DDX_USD = DDX_USD() +DDX_USDT = DDX_USDT() @dataclass(slots=True, frozen=True) class DDX_USDT: + """ + name: DDX-USDT + precision: 0.0001 + minimum_margin: None + initial_margin: None + minimum_order_size: 1 + maximum_order_size: None + margin: False + """ name: str = "DDX-USDT" precision: int = 0.0001 minimum_margin: float = None @@ -3701,11 +5155,20 @@ def __call__(self): return "DDX-USDT" -DDX_USDT = DDX_USDT() +DESO_EUR = DESO_EUR() @dataclass(slots=True, frozen=True) class DESO_EUR: + """ + name: DESO-EUR + precision: 0.01 + minimum_margin: None + initial_margin: None + minimum_order_size: 1 + maximum_order_size: None + margin: False + """ name: str = "DESO-EUR" precision: int = 0.01 minimum_margin: float = None @@ -3724,11 +5187,20 @@ def __call__(self): return "DESO-EUR" -DESO_EUR = DESO_EUR() +DESO_USD = DESO_USD() @dataclass(slots=True, frozen=True) class DESO_USD: + """ + name: DESO-USD + precision: 0.01 + minimum_margin: None + initial_margin: None + minimum_order_size: 1 + maximum_order_size: None + margin: False + """ name: str = "DESO-USD" precision: int = 0.01 minimum_margin: float = None @@ -3747,11 +5219,20 @@ def __call__(self): return "DESO-USD" -DESO_USD = DESO_USD() +DESO_USDT = DESO_USDT() @dataclass(slots=True, frozen=True) class DESO_USDT: + """ + name: DESO-USDT + precision: 0.01 + minimum_margin: None + initial_margin: None + minimum_order_size: 1 + maximum_order_size: None + margin: False + """ name: str = "DESO-USDT" precision: int = 0.01 minimum_margin: float = None @@ -3770,11 +5251,20 @@ def __call__(self): return "DESO-USDT" -DESO_USDT = DESO_USDT() +DEXT_USD = DEXT_USD() @dataclass(slots=True, frozen=True) class DEXT_USD: + """ + name: DEXT-USD + precision: 0.0001 + minimum_margin: None + initial_margin: None + minimum_order_size: 1 + maximum_order_size: None + margin: False + """ name: str = "DEXT-USD" precision: int = 0.0001 minimum_margin: float = None @@ -3793,11 +5283,20 @@ def __call__(self): return "DEXT-USD" -DEXT_USD = DEXT_USD() +DIA_EUR = DIA_EUR() @dataclass(slots=True, frozen=True) class DIA_EUR: + """ + name: DIA-EUR + precision: 0.00001 + minimum_margin: None + initial_margin: None + minimum_order_size: 1 + maximum_order_size: None + margin: False + """ name: str = "DIA-EUR" precision: int = 0.00001 minimum_margin: float = None @@ -3816,11 +5315,20 @@ def __call__(self): return "DIA-EUR" -DIA_EUR = DIA_EUR() +DIA_USD = DIA_USD() @dataclass(slots=True, frozen=True) class DIA_USD: + """ + name: DIA-USD + precision: 0.00001 + minimum_margin: None + initial_margin: None + minimum_order_size: 1 + maximum_order_size: None + margin: False + """ name: str = "DIA-USD" precision: int = 0.00001 minimum_margin: float = None @@ -3839,11 +5347,20 @@ def __call__(self): return "DIA-USD" -DIA_USD = DIA_USD() +DIA_USDT = DIA_USDT() @dataclass(slots=True, frozen=True) class DIA_USDT: + """ + name: DIA-USDT + precision: 0.00001 + minimum_margin: None + initial_margin: None + minimum_order_size: 1 + maximum_order_size: None + margin: False + """ name: str = "DIA-USDT" precision: int = 0.00001 minimum_margin: float = None @@ -3862,11 +5379,20 @@ def __call__(self): return "DIA-USDT" -DIA_USDT = DIA_USDT() +DNT_USD = DNT_USD() @dataclass(slots=True, frozen=True) class DNT_USD: + """ + name: DNT-USD + precision: 0.0001 + minimum_margin: None + initial_margin: None + minimum_order_size: 1 + maximum_order_size: None + margin: False + """ name: str = "DNT-USD" precision: int = 0.0001 minimum_margin: float = None @@ -3885,11 +5411,20 @@ def __call__(self): return "DNT-USD" -DNT_USD = DNT_USD() +DNT_USDC = DNT_USDC() @dataclass(slots=True, frozen=True) class DNT_USDC: + """ + name: DNT-USDC + precision: 0.000001 + minimum_margin: None + initial_margin: None + minimum_order_size: 1 + maximum_order_size: None + margin: False + """ name: str = "DNT-USDC" precision: int = 0.000001 minimum_margin: float = None @@ -3908,11 +5443,20 @@ def __call__(self): return "DNT-USDC" -DNT_USDC = DNT_USDC() +DOGE_BTC = DOGE_BTC() @dataclass(slots=True, frozen=True) class DOGE_BTC: + """ + name: DOGE-BTC + precision: 0.00000001 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.000016 + maximum_order_size: None + margin: False + """ name: str = "DOGE-BTC" precision: int = 0.00000001 minimum_margin: float = None @@ -3931,11 +5475,20 @@ def __call__(self): return "DOGE-BTC" -DOGE_BTC = DOGE_BTC() +DOGE_EUR = DOGE_EUR() @dataclass(slots=True, frozen=True) class DOGE_EUR: + """ + name: DOGE-EUR + precision: 0.0001 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.84 + maximum_order_size: None + margin: False + """ name: str = "DOGE-EUR" precision: int = 0.0001 minimum_margin: float = None @@ -3954,11 +5507,20 @@ def __call__(self): return "DOGE-EUR" -DOGE_EUR = DOGE_EUR() +DOGE_GBP = DOGE_GBP() @dataclass(slots=True, frozen=True) class DOGE_GBP: + """ + name: DOGE-GBP + precision: 0.0001 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.72 + maximum_order_size: None + margin: False + """ name: str = "DOGE-GBP" precision: int = 0.0001 minimum_margin: float = None @@ -3977,11 +5539,20 @@ def __call__(self): return "DOGE-GBP" -DOGE_GBP = DOGE_GBP() +DOGE_USD = DOGE_USD() @dataclass(slots=True, frozen=True) class DOGE_USD: + """ + name: DOGE-USD + precision: 0.00001 + minimum_margin: None + initial_margin: None + minimum_order_size: 1 + maximum_order_size: None + margin: False + """ name: str = "DOGE-USD" precision: int = 0.00001 minimum_margin: float = None @@ -4000,11 +5571,20 @@ def __call__(self): return "DOGE-USD" -DOGE_USD = DOGE_USD() +DOGE_USDT = DOGE_USDT() @dataclass(slots=True, frozen=True) class DOGE_USDT: + """ + name: DOGE-USDT + precision: 0.0001 + minimum_margin: None + initial_margin: None + minimum_order_size: 1 + maximum_order_size: None + margin: False + """ name: str = "DOGE-USDT" precision: int = 0.0001 minimum_margin: float = None @@ -4023,11 +5603,20 @@ def __call__(self): return "DOGE-USDT" -DOGE_USDT = DOGE_USDT() +DOT_BTC = DOT_BTC() @dataclass(slots=True, frozen=True) class DOT_BTC: + """ + name: DOT-BTC + precision: 0.0000001 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.000016 + maximum_order_size: None + margin: False + """ name: str = "DOT-BTC" precision: int = 0.0000001 minimum_margin: float = None @@ -4046,11 +5635,20 @@ def __call__(self): return "DOT-BTC" -DOT_BTC = DOT_BTC() +DOT_EUR = DOT_EUR() @dataclass(slots=True, frozen=True) class DOT_EUR: + """ + name: DOT-EUR + precision: 0.01 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.84 + maximum_order_size: None + margin: False + """ name: str = "DOT-EUR" precision: int = 0.01 minimum_margin: float = None @@ -4069,11 +5667,20 @@ def __call__(self): return "DOT-EUR" -DOT_EUR = DOT_EUR() +DOT_GBP = DOT_GBP() @dataclass(slots=True, frozen=True) class DOT_GBP: + """ + name: DOT-GBP + precision: 0.01 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.72 + maximum_order_size: None + margin: False + """ name: str = "DOT-GBP" precision: int = 0.01 minimum_margin: float = None @@ -4092,11 +5699,20 @@ def __call__(self): return "DOT-GBP" -DOT_GBP = DOT_GBP() +DOT_USD = DOT_USD() @dataclass(slots=True, frozen=True) class DOT_USD: + """ + name: DOT-USD + precision: 0.001 + minimum_margin: None + initial_margin: None + minimum_order_size: 1 + maximum_order_size: None + margin: False + """ name: str = "DOT-USD" precision: int = 0.001 minimum_margin: float = None @@ -4115,11 +5731,20 @@ def __call__(self): return "DOT-USD" -DOT_USD = DOT_USD() +DOT_USDT = DOT_USDT() @dataclass(slots=True, frozen=True) class DOT_USDT: + """ + name: DOT-USDT + precision: 0.01 + minimum_margin: None + initial_margin: None + minimum_order_size: 1 + maximum_order_size: None + margin: False + """ name: str = "DOT-USDT" precision: int = 0.01 minimum_margin: float = None @@ -4138,11 +5763,20 @@ def __call__(self): return "DOT-USDT" -DOT_USDT = DOT_USDT() +DREP_USD = DREP_USD() @dataclass(slots=True, frozen=True) class DREP_USD: + """ + name: DREP-USD + precision: 0.0001 + minimum_margin: None + initial_margin: None + minimum_order_size: 1 + maximum_order_size: None + margin: False + """ name: str = "DREP-USD" precision: int = 0.0001 minimum_margin: float = None @@ -4161,11 +5795,20 @@ def __call__(self): return "DREP-USD" -DREP_USD = DREP_USD() +DREP_USDT = DREP_USDT() @dataclass(slots=True, frozen=True) class DREP_USDT: + """ + name: DREP-USDT + precision: 0.0001 + minimum_margin: None + initial_margin: None + minimum_order_size: 1 + maximum_order_size: None + margin: False + """ name: str = "DREP-USDT" precision: int = 0.0001 minimum_margin: float = None @@ -4184,11 +5827,20 @@ def __call__(self): return "DREP-USDT" -DREP_USDT = DREP_USDT() +DYP_USD = DYP_USD() @dataclass(slots=True, frozen=True) class DYP_USD: + """ + name: DYP-USD + precision: 0.00001 + minimum_margin: None + initial_margin: None + minimum_order_size: 1 + maximum_order_size: None + margin: False + """ name: str = "DYP-USD" precision: int = 0.00001 minimum_margin: float = None @@ -4207,11 +5859,20 @@ def __call__(self): return "DYP-USD" -DYP_USD = DYP_USD() +DYP_USDT = DYP_USDT() @dataclass(slots=True, frozen=True) class DYP_USDT: + """ + name: DYP-USDT + precision: 0.00001 + minimum_margin: None + initial_margin: None + minimum_order_size: 1 + maximum_order_size: None + margin: False + """ name: str = "DYP-USDT" precision: int = 0.00001 minimum_margin: float = None @@ -4230,11 +5891,20 @@ def __call__(self): return "DYP-USDT" -DYP_USDT = DYP_USDT() +EGLD_USD = EGLD_USD() @dataclass(slots=True, frozen=True) class EGLD_USD: + """ + name: EGLD-USD + precision: 0.01 + minimum_margin: None + initial_margin: None + minimum_order_size: 1 + maximum_order_size: None + margin: False + """ name: str = "EGLD-USD" precision: int = 0.01 minimum_margin: float = None @@ -4253,11 +5923,20 @@ def __call__(self): return "EGLD-USD" -EGLD_USD = EGLD_USD() +ELA_USD = ELA_USD() @dataclass(slots=True, frozen=True) class ELA_USD: + """ + name: ELA-USD + precision: 0.001 + minimum_margin: None + initial_margin: None + minimum_order_size: 1 + maximum_order_size: None + margin: False + """ name: str = "ELA-USD" precision: int = 0.001 minimum_margin: float = None @@ -4276,11 +5955,20 @@ def __call__(self): return "ELA-USD" -ELA_USD = ELA_USD() +ELA_USDT = ELA_USDT() @dataclass(slots=True, frozen=True) class ELA_USDT: + """ + name: ELA-USDT + precision: 0.001 + minimum_margin: None + initial_margin: None + minimum_order_size: 1 + maximum_order_size: None + margin: False + """ name: str = "ELA-USDT" precision: int = 0.001 minimum_margin: float = None @@ -4299,11 +5987,20 @@ def __call__(self): return "ELA-USDT" -ELA_USDT = ELA_USDT() +ENJ_BTC = ENJ_BTC() @dataclass(slots=True, frozen=True) class ENJ_BTC: + """ + name: ENJ-BTC + precision: 0.00000001 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.000016 + maximum_order_size: None + margin: False + """ name: str = "ENJ-BTC" precision: int = 0.00000001 minimum_margin: float = None @@ -4322,11 +6019,20 @@ def __call__(self): return "ENJ-BTC" -ENJ_BTC = ENJ_BTC() +ENJ_USD = ENJ_USD() @dataclass(slots=True, frozen=True) class ENJ_USD: + """ + name: ENJ-USD + precision: 0.001 + minimum_margin: None + initial_margin: None + minimum_order_size: 1 + maximum_order_size: None + margin: False + """ name: str = "ENJ-USD" precision: int = 0.001 minimum_margin: float = None @@ -4345,11 +6051,20 @@ def __call__(self): return "ENJ-USD" -ENJ_USD = ENJ_USD() +ENJ_USDT = ENJ_USDT() @dataclass(slots=True, frozen=True) class ENJ_USDT: + """ + name: ENJ-USDT + precision: 0.001 + minimum_margin: None + initial_margin: None + minimum_order_size: 1 + maximum_order_size: None + margin: False + """ name: str = "ENJ-USDT" precision: int = 0.001 minimum_margin: float = None @@ -4368,11 +6083,20 @@ def __call__(self): return "ENJ-USDT" -ENJ_USDT = ENJ_USDT() +ENS_EUR = ENS_EUR() @dataclass(slots=True, frozen=True) class ENS_EUR: + """ + name: ENS-EUR + precision: 0.01 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.84 + maximum_order_size: None + margin: False + """ name: str = "ENS-EUR" precision: int = 0.01 minimum_margin: float = None @@ -4391,11 +6115,20 @@ def __call__(self): return "ENS-EUR" -ENS_EUR = ENS_EUR() +ENS_USD = ENS_USD() @dataclass(slots=True, frozen=True) class ENS_USD: + """ + name: ENS-USD + precision: 0.01 + minimum_margin: None + initial_margin: None + minimum_order_size: 1 + maximum_order_size: None + margin: False + """ name: str = "ENS-USD" precision: int = 0.01 minimum_margin: float = None @@ -4414,11 +6147,20 @@ def __call__(self): return "ENS-USD" -ENS_USD = ENS_USD() +ENS_USDT = ENS_USDT() @dataclass(slots=True, frozen=True) class ENS_USDT: + """ + name: ENS-USDT + precision: 0.01 + minimum_margin: None + initial_margin: None + minimum_order_size: 1 + maximum_order_size: None + margin: False + """ name: str = "ENS-USDT" precision: int = 0.01 minimum_margin: float = None @@ -4437,11 +6179,20 @@ def __call__(self): return "ENS-USDT" -ENS_USDT = ENS_USDT() +EOS_BTC = EOS_BTC() @dataclass(slots=True, frozen=True) class EOS_BTC: + """ + name: EOS-BTC + precision: 0.00000001 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.000016 + maximum_order_size: None + margin: False + """ name: str = "EOS-BTC" precision: int = 0.00000001 minimum_margin: float = None @@ -4460,11 +6211,20 @@ def __call__(self): return "EOS-BTC" -EOS_BTC = EOS_BTC() +EOS_EUR = EOS_EUR() @dataclass(slots=True, frozen=True) class EOS_EUR: + """ + name: EOS-EUR + precision: 0.0001 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.84 + maximum_order_size: None + margin: False + """ name: str = "EOS-EUR" precision: int = 0.0001 minimum_margin: float = None @@ -4483,11 +6243,20 @@ def __call__(self): return "EOS-EUR" -EOS_EUR = EOS_EUR() +EOS_USD = EOS_USD() @dataclass(slots=True, frozen=True) class EOS_USD: + """ + name: EOS-USD + precision: 0.0001 + minimum_margin: None + initial_margin: None + minimum_order_size: 1 + maximum_order_size: None + margin: False + """ name: str = "EOS-USD" precision: int = 0.0001 minimum_margin: float = None @@ -4506,11 +6275,20 @@ def __call__(self): return "EOS-USD" -EOS_USD = EOS_USD() +ERN_EUR = ERN_EUR() @dataclass(slots=True, frozen=True) class ERN_EUR: + """ + name: ERN-EUR + precision: 0.01 + minimum_margin: None + initial_margin: None + minimum_order_size: 1 + maximum_order_size: None + margin: False + """ name: str = "ERN-EUR" precision: int = 0.01 minimum_margin: float = None @@ -4529,11 +6307,20 @@ def __call__(self): return "ERN-EUR" -ERN_EUR = ERN_EUR() +ERN_USD = ERN_USD() @dataclass(slots=True, frozen=True) class ERN_USD: + """ + name: ERN-USD + precision: 0.01 + minimum_margin: None + initial_margin: None + minimum_order_size: 1 + maximum_order_size: None + margin: False + """ name: str = "ERN-USD" precision: int = 0.01 minimum_margin: float = None @@ -4552,11 +6339,20 @@ def __call__(self): return "ERN-USD" -ERN_USD = ERN_USD() +ERN_USDT = ERN_USDT() @dataclass(slots=True, frozen=True) class ERN_USDT: + """ + name: ERN-USDT + precision: 0.01 + minimum_margin: None + initial_margin: None + minimum_order_size: 1 + maximum_order_size: None + margin: False + """ name: str = "ERN-USDT" precision: int = 0.01 minimum_margin: float = None @@ -4575,11 +6371,20 @@ def __call__(self): return "ERN-USDT" -ERN_USDT = ERN_USDT() +ETC_BTC = ETC_BTC() @dataclass(slots=True, frozen=True) class ETC_BTC: + """ + name: ETC-BTC + precision: 0.000001 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.000016 + maximum_order_size: None + margin: False + """ name: str = "ETC-BTC" precision: int = 0.000001 minimum_margin: float = None @@ -4598,11 +6403,20 @@ def __call__(self): return "ETC-BTC" -ETC_BTC = ETC_BTC() +ETC_EUR = ETC_EUR() @dataclass(slots=True, frozen=True) class ETC_EUR: + """ + name: ETC-EUR + precision: 0.01 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.84 + maximum_order_size: None + margin: False + """ name: str = "ETC-EUR" precision: int = 0.01 minimum_margin: float = None @@ -4621,11 +6435,20 @@ def __call__(self): return "ETC-EUR" -ETC_EUR = ETC_EUR() +ETC_GBP = ETC_GBP() @dataclass(slots=True, frozen=True) class ETC_GBP: + """ + name: ETC-GBP + precision: 0.01 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.72 + maximum_order_size: None + margin: False + """ name: str = "ETC-GBP" precision: int = 0.01 minimum_margin: float = None @@ -4644,11 +6467,20 @@ def __call__(self): return "ETC-GBP" -ETC_GBP = ETC_GBP() +ETC_USD = ETC_USD() @dataclass(slots=True, frozen=True) class ETC_USD: + """ + name: ETC-USD + precision: 0.01 + minimum_margin: None + initial_margin: None + minimum_order_size: 1 + maximum_order_size: None + margin: False + """ name: str = "ETC-USD" precision: int = 0.01 minimum_margin: float = None @@ -4667,11 +6499,20 @@ def __call__(self): return "ETC-USD" -ETC_USD = ETC_USD() +ETH_BTC = ETH_BTC() @dataclass(slots=True, frozen=True) class ETH_BTC: + """ + name: ETH-BTC + precision: 0.00001 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.00001 + maximum_order_size: None + margin: False + """ name: str = "ETH-BTC" precision: int = 0.00001 minimum_margin: float = None @@ -4690,11 +6531,20 @@ def __call__(self): return "ETH-BTC" -ETH_BTC = ETH_BTC() +ETH_DAI = ETH_DAI() @dataclass(slots=True, frozen=True) class ETH_DAI: + """ + name: ETH-DAI + precision: 0.01 + minimum_margin: None + initial_margin: None + minimum_order_size: 1 + maximum_order_size: None + margin: False + """ name: str = "ETH-DAI" precision: int = 0.01 minimum_margin: float = None @@ -4713,11 +6563,20 @@ def __call__(self): return "ETH-DAI" -ETH_DAI = ETH_DAI() +ETH_EUR = ETH_EUR() @dataclass(slots=True, frozen=True) class ETH_EUR: + """ + name: ETH-EUR + precision: 0.01 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.84 + maximum_order_size: None + margin: False + """ name: str = "ETH-EUR" precision: int = 0.01 minimum_margin: float = None @@ -4736,11 +6595,20 @@ def __call__(self): return "ETH-EUR" -ETH_EUR = ETH_EUR() +ETH_GBP = ETH_GBP() @dataclass(slots=True, frozen=True) class ETH_GBP: + """ + name: ETH-GBP + precision: 0.01 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.72 + maximum_order_size: None + margin: False + """ name: str = "ETH-GBP" precision: int = 0.01 minimum_margin: float = None @@ -4759,11 +6627,20 @@ def __call__(self): return "ETH-GBP" -ETH_GBP = ETH_GBP() +ETH_USD = ETH_USD() @dataclass(slots=True, frozen=True) class ETH_USD: + """ + name: ETH-USD + precision: 0.01 + minimum_margin: None + initial_margin: None + minimum_order_size: 1 + maximum_order_size: None + margin: False + """ name: str = "ETH-USD" precision: int = 0.01 minimum_margin: float = None @@ -4782,11 +6659,20 @@ def __call__(self): return "ETH-USD" -ETH_USD = ETH_USD() +ETH_USDC = ETH_USDC() @dataclass(slots=True, frozen=True) class ETH_USDC: + """ + name: ETH-USDC + precision: 1 + minimum_margin: None + initial_margin: None + minimum_order_size: 1 + maximum_order_size: None + margin: False + """ name: str = "ETH-USDC" precision: int = 1 minimum_margin: float = None @@ -4805,11 +6691,20 @@ def __call__(self): return "ETH-USDC" -ETH_USDC = ETH_USDC() +ETH_USDT = ETH_USDT() @dataclass(slots=True, frozen=True) class ETH_USDT: + """ + name: ETH-USDT + precision: 0.01 + minimum_margin: None + initial_margin: None + minimum_order_size: 1 + maximum_order_size: None + margin: False + """ name: str = "ETH-USDT" precision: int = 0.01 minimum_margin: float = None @@ -4828,11 +6723,20 @@ def __call__(self): return "ETH-USDT" -ETH_USDT = ETH_USDT() +FARM_USD = FARM_USD() @dataclass(slots=True, frozen=True) class FARM_USD: + """ + name: FARM-USD + precision: 0.01 + minimum_margin: None + initial_margin: None + minimum_order_size: 1 + maximum_order_size: None + margin: False + """ name: str = "FARM-USD" precision: int = 0.01 minimum_margin: float = None @@ -4851,11 +6755,20 @@ def __call__(self): return "FARM-USD" -FARM_USD = FARM_USD() +FARM_USDT = FARM_USDT() @dataclass(slots=True, frozen=True) class FARM_USDT: + """ + name: FARM-USDT + precision: 0.01 + minimum_margin: None + initial_margin: None + minimum_order_size: 1 + maximum_order_size: None + margin: False + """ name: str = "FARM-USDT" precision: int = 0.01 minimum_margin: float = None @@ -4874,11 +6787,20 @@ def __call__(self): return "FARM-USDT" -FARM_USDT = FARM_USDT() +FET_USD = FET_USD() @dataclass(slots=True, frozen=True) class FET_USD: + """ + name: FET-USD + precision: 0.0001 + minimum_margin: None + initial_margin: None + minimum_order_size: 1 + maximum_order_size: None + margin: False + """ name: str = "FET-USD" precision: int = 0.0001 minimum_margin: float = None @@ -4897,11 +6819,20 @@ def __call__(self): return "FET-USD" -FET_USD = FET_USD() +FET_USDT = FET_USDT() @dataclass(slots=True, frozen=True) class FET_USDT: + """ + name: FET-USDT + precision: 0.0001 + minimum_margin: None + initial_margin: None + minimum_order_size: 1 + maximum_order_size: None + margin: False + """ name: str = "FET-USDT" precision: int = 0.0001 minimum_margin: float = None @@ -4920,11 +6851,20 @@ def __call__(self): return "FET-USDT" -FET_USDT = FET_USDT() +FIDA_EUR = FIDA_EUR() @dataclass(slots=True, frozen=True) class FIDA_EUR: + """ + name: FIDA-EUR + precision: 0.0001 + minimum_margin: None + initial_margin: None + minimum_order_size: 1 + maximum_order_size: None + margin: False + """ name: str = "FIDA-EUR" precision: int = 0.0001 minimum_margin: float = None @@ -4943,11 +6883,20 @@ def __call__(self): return "FIDA-EUR" -FIDA_EUR = FIDA_EUR() +FIDA_USD = FIDA_USD() @dataclass(slots=True, frozen=True) class FIDA_USD: + """ + name: FIDA-USD + precision: 0.0001 + minimum_margin: None + initial_margin: None + minimum_order_size: 1 + maximum_order_size: None + margin: False + """ name: str = "FIDA-USD" precision: int = 0.0001 minimum_margin: float = None @@ -4966,11 +6915,20 @@ def __call__(self): return "FIDA-USD" -FIDA_USD = FIDA_USD() +FIDA_USDT = FIDA_USDT() @dataclass(slots=True, frozen=True) class FIDA_USDT: + """ + name: FIDA-USDT + precision: 0.0001 + minimum_margin: None + initial_margin: None + minimum_order_size: 1 + maximum_order_size: None + margin: False + """ name: str = "FIDA-USDT" precision: int = 0.0001 minimum_margin: float = None @@ -4989,11 +6947,20 @@ def __call__(self): return "FIDA-USDT" -FIDA_USDT = FIDA_USDT() +FIL_BTC = FIL_BTC() @dataclass(slots=True, frozen=True) class FIL_BTC: + """ + name: FIL-BTC + precision: 0.00000001 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.000016 + maximum_order_size: None + margin: False + """ name: str = "FIL-BTC" precision: int = 0.00000001 minimum_margin: float = None @@ -5012,11 +6979,20 @@ def __call__(self): return "FIL-BTC" -FIL_BTC = FIL_BTC() +FIL_EUR = FIL_EUR() @dataclass(slots=True, frozen=True) class FIL_EUR: + """ + name: FIL-EUR + precision: 0.01 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.84 + maximum_order_size: None + margin: False + """ name: str = "FIL-EUR" precision: int = 0.01 minimum_margin: float = None @@ -5035,11 +7011,20 @@ def __call__(self): return "FIL-EUR" -FIL_EUR = FIL_EUR() +FIL_GBP = FIL_GBP() @dataclass(slots=True, frozen=True) class FIL_GBP: + """ + name: FIL-GBP + precision: 0.01 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.72 + maximum_order_size: None + margin: False + """ name: str = "FIL-GBP" precision: int = 0.01 minimum_margin: float = None @@ -5058,11 +7043,20 @@ def __call__(self): return "FIL-GBP" -FIL_GBP = FIL_GBP() +FIL_USD = FIL_USD() @dataclass(slots=True, frozen=True) class FIL_USD: + """ + name: FIL-USD + precision: 0.001 + minimum_margin: None + initial_margin: None + minimum_order_size: 1 + maximum_order_size: None + margin: False + """ name: str = "FIL-USD" precision: int = 0.001 minimum_margin: float = None @@ -5081,11 +7075,20 @@ def __call__(self): return "FIL-USD" -FIL_USD = FIL_USD() +FIS_USD = FIS_USD() @dataclass(slots=True, frozen=True) class FIS_USD: + """ + name: FIS-USD + precision: 0.0001 + minimum_margin: None + initial_margin: None + minimum_order_size: 1 + maximum_order_size: None + margin: False + """ name: str = "FIS-USD" precision: int = 0.0001 minimum_margin: float = None @@ -5104,11 +7107,20 @@ def __call__(self): return "FIS-USD" -FIS_USD = FIS_USD() +FIS_USDT = FIS_USDT() @dataclass(slots=True, frozen=True) class FIS_USDT: + """ + name: FIS-USDT + precision: 0.0001 + minimum_margin: None + initial_margin: None + minimum_order_size: 1 + maximum_order_size: None + margin: False + """ name: str = "FIS-USDT" precision: int = 0.0001 minimum_margin: float = None @@ -5127,11 +7139,20 @@ def __call__(self): return "FIS-USDT" -FIS_USDT = FIS_USDT() +FLOW_USD = FLOW_USD() @dataclass(slots=True, frozen=True) class FLOW_USD: + """ + name: FLOW-USD + precision: 0.001 + minimum_margin: None + initial_margin: None + minimum_order_size: 1 + maximum_order_size: None + margin: False + """ name: str = "FLOW-USD" precision: int = 0.001 minimum_margin: float = None @@ -5150,11 +7171,20 @@ def __call__(self): return "FLOW-USD" -FLOW_USD = FLOW_USD() +FLOW_USDT = FLOW_USDT() @dataclass(slots=True, frozen=True) class FLOW_USDT: + """ + name: FLOW-USDT + precision: 0.001 + minimum_margin: None + initial_margin: None + minimum_order_size: 1 + maximum_order_size: None + margin: False + """ name: str = "FLOW-USDT" precision: int = 0.001 minimum_margin: float = None @@ -5173,11 +7203,20 @@ def __call__(self): return "FLOW-USDT" -FLOW_USDT = FLOW_USDT() +FORT_USD = FORT_USD() @dataclass(slots=True, frozen=True) class FORT_USD: + """ + name: FORT-USD + precision: 0.0001 + minimum_margin: None + initial_margin: None + minimum_order_size: 1 + maximum_order_size: None + margin: False + """ name: str = "FORT-USD" precision: int = 0.0001 minimum_margin: float = None @@ -5196,11 +7235,20 @@ def __call__(self): return "FORT-USD" -FORT_USD = FORT_USD() +FORT_USDT = FORT_USDT() @dataclass(slots=True, frozen=True) class FORT_USDT: + """ + name: FORT-USDT + precision: 0.0001 + minimum_margin: None + initial_margin: None + minimum_order_size: 1 + maximum_order_size: None + margin: False + """ name: str = "FORT-USDT" precision: int = 0.0001 minimum_margin: float = None @@ -5219,11 +7267,20 @@ def __call__(self): return "FORT-USDT" -FORT_USDT = FORT_USDT() +FORTH_BTC = FORTH_BTC() @dataclass(slots=True, frozen=True) class FORTH_BTC: + """ + name: FORTH-BTC + precision: 0.0000001 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.000016 + maximum_order_size: None + margin: False + """ name: str = "FORTH-BTC" precision: int = 0.0000001 minimum_margin: float = None @@ -5242,11 +7299,20 @@ def __call__(self): return "FORTH-BTC" -FORTH_BTC = FORTH_BTC() +FORTH_EUR = FORTH_EUR() @dataclass(slots=True, frozen=True) class FORTH_EUR: + """ + name: FORTH-EUR + precision: 0.01 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.84 + maximum_order_size: None + margin: False + """ name: str = "FORTH-EUR" precision: int = 0.01 minimum_margin: float = None @@ -5265,11 +7331,20 @@ def __call__(self): return "FORTH-EUR" -FORTH_EUR = FORTH_EUR() +FORTH_GBP = FORTH_GBP() @dataclass(slots=True, frozen=True) class FORTH_GBP: + """ + name: FORTH-GBP + precision: 0.001 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.72 + maximum_order_size: None + margin: False + """ name: str = "FORTH-GBP" precision: int = 0.001 minimum_margin: float = None @@ -5288,11 +7363,20 @@ def __call__(self): return "FORTH-GBP" -FORTH_GBP = FORTH_GBP() +FORTH_USD = FORTH_USD() @dataclass(slots=True, frozen=True) class FORTH_USD: + """ + name: FORTH-USD + precision: 0.01 + minimum_margin: None + initial_margin: None + minimum_order_size: 1 + maximum_order_size: None + margin: False + """ name: str = "FORTH-USD" precision: int = 0.01 minimum_margin: float = None @@ -5311,11 +7395,20 @@ def __call__(self): return "FORTH-USD" -FORTH_USD = FORTH_USD() +FOX_USD = FOX_USD() @dataclass(slots=True, frozen=True) class FOX_USD: + """ + name: FOX-USD + precision: 0.0001 + minimum_margin: None + initial_margin: None + minimum_order_size: 1 + maximum_order_size: None + margin: False + """ name: str = "FOX-USD" precision: int = 0.0001 minimum_margin: float = None @@ -5334,11 +7427,20 @@ def __call__(self): return "FOX-USD" -FOX_USD = FOX_USD() +FOX_USDT = FOX_USDT() @dataclass(slots=True, frozen=True) class FOX_USDT: + """ + name: FOX-USDT + precision: 0.0001 + minimum_margin: None + initial_margin: None + minimum_order_size: 1 + maximum_order_size: None + margin: False + """ name: str = "FOX-USDT" precision: int = 0.0001 minimum_margin: float = None @@ -5357,11 +7459,20 @@ def __call__(self): return "FOX-USDT" -FOX_USDT = FOX_USDT() +FX_USD = FX_USD() @dataclass(slots=True, frozen=True) class FX_USD: + """ + name: FX-USD + precision: 0.0001 + minimum_margin: None + initial_margin: None + minimum_order_size: 1 + maximum_order_size: None + margin: False + """ name: str = "FX-USD" precision: int = 0.0001 minimum_margin: float = None @@ -5380,11 +7491,20 @@ def __call__(self): return "FX-USD" -FX_USD = FX_USD() +GAL_USD = GAL_USD() @dataclass(slots=True, frozen=True) class GAL_USD: + """ + name: GAL-USD + precision: 0.001 + minimum_margin: None + initial_margin: None + minimum_order_size: 1 + maximum_order_size: None + margin: False + """ name: str = "GAL-USD" precision: int = 0.001 minimum_margin: float = None @@ -5403,11 +7523,20 @@ def __call__(self): return "GAL-USD" -GAL_USD = GAL_USD() +GAL_USDT = GAL_USDT() @dataclass(slots=True, frozen=True) class GAL_USDT: + """ + name: GAL-USDT + precision: 0.001 + minimum_margin: None + initial_margin: None + minimum_order_size: 1 + maximum_order_size: None + margin: False + """ name: str = "GAL-USDT" precision: int = 0.001 minimum_margin: float = None @@ -5426,11 +7555,20 @@ def __call__(self): return "GAL-USDT" -GAL_USDT = GAL_USDT() +GALA_EUR = GALA_EUR() @dataclass(slots=True, frozen=True) class GALA_EUR: + """ + name: GALA-EUR + precision: 0.0001 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.84 + maximum_order_size: None + margin: False + """ name: str = "GALA-EUR" precision: int = 0.0001 minimum_margin: float = None @@ -5449,11 +7587,20 @@ def __call__(self): return "GALA-EUR" -GALA_EUR = GALA_EUR() +GALA_USD = GALA_USD() @dataclass(slots=True, frozen=True) class GALA_USD: + """ + name: GALA-USD + precision: 0.00001 + minimum_margin: None + initial_margin: None + minimum_order_size: 1 + maximum_order_size: None + margin: False + """ name: str = "GALA-USD" precision: int = 0.00001 minimum_margin: float = None @@ -5472,11 +7619,20 @@ def __call__(self): return "GALA-USD" -GALA_USD = GALA_USD() +GALA_USDT = GALA_USDT() @dataclass(slots=True, frozen=True) class GALA_USDT: + """ + name: GALA-USDT + precision: 0.00001 + minimum_margin: None + initial_margin: None + minimum_order_size: 1 + maximum_order_size: None + margin: False + """ name: str = "GALA-USDT" precision: int = 0.00001 minimum_margin: float = None @@ -5495,11 +7651,20 @@ def __call__(self): return "GALA-USDT" -GALA_USDT = GALA_USDT() +GFI_USD = GFI_USD() @dataclass(slots=True, frozen=True) class GFI_USD: + """ + name: GFI-USD + precision: 0.0001 + minimum_margin: None + initial_margin: None + minimum_order_size: 1 + maximum_order_size: None + margin: False + """ name: str = "GFI-USD" precision: int = 0.0001 minimum_margin: float = None @@ -5518,11 +7683,20 @@ def __call__(self): return "GFI-USD" -GFI_USD = GFI_USD() +GHST_USD = GHST_USD() @dataclass(slots=True, frozen=True) class GHST_USD: + """ + name: GHST-USD + precision: 0.001 + minimum_margin: None + initial_margin: None + minimum_order_size: 1 + maximum_order_size: None + margin: False + """ name: str = "GHST-USD" precision: int = 0.001 minimum_margin: float = None @@ -5541,11 +7715,20 @@ def __call__(self): return "GHST-USD" -GHST_USD = GHST_USD() +GLM_USD = GLM_USD() @dataclass(slots=True, frozen=True) class GLM_USD: + """ + name: GLM-USD + precision: 0.0001 + minimum_margin: None + initial_margin: None + minimum_order_size: 1 + maximum_order_size: None + margin: False + """ name: str = "GLM-USD" precision: int = 0.0001 minimum_margin: float = None @@ -5564,11 +7747,20 @@ def __call__(self): return "GLM-USD" -GLM_USD = GLM_USD() +GMT_USD = GMT_USD() @dataclass(slots=True, frozen=True) class GMT_USD: + """ + name: GMT-USD + precision: 0.0001 + minimum_margin: None + initial_margin: None + minimum_order_size: 1 + maximum_order_size: None + margin: False + """ name: str = "GMT-USD" precision: int = 0.0001 minimum_margin: float = None @@ -5587,11 +7779,20 @@ def __call__(self): return "GMT-USD" -GMT_USD = GMT_USD() +GMT_USDT = GMT_USDT() @dataclass(slots=True, frozen=True) class GMT_USDT: + """ + name: GMT-USDT + precision: 0.0001 + minimum_margin: None + initial_margin: None + minimum_order_size: 1 + maximum_order_size: None + margin: False + """ name: str = "GMT-USDT" precision: int = 0.0001 minimum_margin: float = None @@ -5610,11 +7811,20 @@ def __call__(self): return "GMT-USDT" -GMT_USDT = GMT_USDT() +GNO_USD = GNO_USD() @dataclass(slots=True, frozen=True) class GNO_USD: + """ + name: GNO-USD + precision: 0.01 + minimum_margin: None + initial_margin: None + minimum_order_size: 1 + maximum_order_size: None + margin: False + """ name: str = "GNO-USD" precision: int = 0.01 minimum_margin: float = None @@ -5633,11 +7843,20 @@ def __call__(self): return "GNO-USD" -GNO_USD = GNO_USD() +GNO_USDT = GNO_USDT() @dataclass(slots=True, frozen=True) class GNO_USDT: + """ + name: GNO-USDT + precision: 0.01 + minimum_margin: None + initial_margin: None + minimum_order_size: 1 + maximum_order_size: None + margin: False + """ name: str = "GNO-USDT" precision: int = 0.01 minimum_margin: float = None @@ -5656,11 +7875,20 @@ def __call__(self): return "GNO-USDT" -GNO_USDT = GNO_USDT() +GNT_USDC = GNT_USDC() @dataclass(slots=True, frozen=True) class GNT_USDC: + """ + name: GNT-USDC + precision: 0.000001 + minimum_margin: None + initial_margin: None + minimum_order_size: 1 + maximum_order_size: None + margin: False + """ name: str = "GNT-USDC" precision: int = 0.000001 minimum_margin: float = None @@ -5679,11 +7907,20 @@ def __call__(self): return "GNT-USDC" -GNT_USDC = GNT_USDC() +GODS_USD = GODS_USD() @dataclass(slots=True, frozen=True) class GODS_USD: + """ + name: GODS-USD + precision: 0.00001 + minimum_margin: None + initial_margin: None + minimum_order_size: 1 + maximum_order_size: None + margin: False + """ name: str = "GODS-USD" precision: int = 0.00001 minimum_margin: float = None @@ -5702,11 +7939,20 @@ def __call__(self): return "GODS-USD" -GODS_USD = GODS_USD() +GRT_BTC = GRT_BTC() @dataclass(slots=True, frozen=True) class GRT_BTC: + """ + name: GRT-BTC + precision: 0.00000001 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.000016 + maximum_order_size: None + margin: False + """ name: str = "GRT-BTC" precision: int = 0.00000001 minimum_margin: float = None @@ -5725,11 +7971,20 @@ def __call__(self): return "GRT-BTC" -GRT_BTC = GRT_BTC() +GRT_EUR = GRT_EUR() @dataclass(slots=True, frozen=True) class GRT_EUR: + """ + name: GRT-EUR + precision: 0.0001 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.84 + maximum_order_size: None + margin: False + """ name: str = "GRT-EUR" precision: int = 0.0001 minimum_margin: float = None @@ -5748,11 +8003,20 @@ def __call__(self): return "GRT-EUR" -GRT_EUR = GRT_EUR() +GRT_GBP = GRT_GBP() @dataclass(slots=True, frozen=True) class GRT_GBP: + """ + name: GRT-GBP + precision: 0.0001 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.72 + maximum_order_size: None + margin: False + """ name: str = "GRT-GBP" precision: int = 0.0001 minimum_margin: float = None @@ -5771,11 +8035,20 @@ def __call__(self): return "GRT-GBP" -GRT_GBP = GRT_GBP() +GRT_USD = GRT_USD() @dataclass(slots=True, frozen=True) class GRT_USD: + """ + name: GRT-USD + precision: 0.0001 + minimum_margin: None + initial_margin: None + minimum_order_size: 1 + maximum_order_size: None + margin: False + """ name: str = "GRT-USD" precision: int = 0.0001 minimum_margin: float = None @@ -5794,11 +8067,20 @@ def __call__(self): return "GRT-USD" -GRT_USD = GRT_USD() +GST_USD = GST_USD() @dataclass(slots=True, frozen=True) class GST_USD: + """ + name: GST-USD + precision: 0.000001 + minimum_margin: None + initial_margin: None + minimum_order_size: 1 + maximum_order_size: None + margin: False + """ name: str = "GST-USD" precision: int = 0.000001 minimum_margin: float = None @@ -5817,11 +8099,20 @@ def __call__(self): return "GST-USD" -GST_USD = GST_USD() +GTC_USD = GTC_USD() @dataclass(slots=True, frozen=True) class GTC_USD: + """ + name: GTC-USD + precision: 0.01 + minimum_margin: None + initial_margin: None + minimum_order_size: 1 + maximum_order_size: None + margin: False + """ name: str = "GTC-USD" precision: int = 0.01 minimum_margin: float = None @@ -5840,11 +8131,20 @@ def __call__(self): return "GTC-USD" -GTC_USD = GTC_USD() +GUSD_USD = GUSD_USD() @dataclass(slots=True, frozen=True) class GUSD_USD: + """ + name: GUSD-USD + precision: 0.001 + minimum_margin: None + initial_margin: None + minimum_order_size: 1 + maximum_order_size: None + margin: False + """ name: str = "GUSD-USD" precision: int = 0.001 minimum_margin: float = None @@ -5863,11 +8163,20 @@ def __call__(self): return "GUSD-USD" -GUSD_USD = GUSD_USD() +GYEN_USD = GYEN_USD() @dataclass(slots=True, frozen=True) class GYEN_USD: + """ + name: GYEN-USD + precision: 0.000001 + minimum_margin: None + initial_margin: None + minimum_order_size: 1 + maximum_order_size: None + margin: False + """ name: str = "GYEN-USD" precision: int = 0.000001 minimum_margin: float = None @@ -5886,11 +8195,20 @@ def __call__(self): return "GYEN-USD" -GYEN_USD = GYEN_USD() +HBAR_USD = HBAR_USD() @dataclass(slots=True, frozen=True) class HBAR_USD: + """ + name: HBAR-USD + precision: 0.00001 + minimum_margin: None + initial_margin: None + minimum_order_size: 1 + maximum_order_size: None + margin: False + """ name: str = "HBAR-USD" precision: int = 0.00001 minimum_margin: float = None @@ -5909,11 +8227,20 @@ def __call__(self): return "HBAR-USD" -HBAR_USD = HBAR_USD() +HBAR_USDT = HBAR_USDT() @dataclass(slots=True, frozen=True) class HBAR_USDT: + """ + name: HBAR-USDT + precision: 0.00001 + minimum_margin: None + initial_margin: None + minimum_order_size: 1 + maximum_order_size: None + margin: False + """ name: str = "HBAR-USDT" precision: int = 0.00001 minimum_margin: float = None @@ -5932,11 +8259,20 @@ def __call__(self): return "HBAR-USDT" -HBAR_USDT = HBAR_USDT() +HFT_USD = HFT_USD() @dataclass(slots=True, frozen=True) class HFT_USD: + """ + name: HFT-USD + precision: 0.0001 + minimum_margin: None + initial_margin: None + minimum_order_size: 1 + maximum_order_size: None + margin: False + """ name: str = "HFT-USD" precision: int = 0.0001 minimum_margin: float = None @@ -5955,11 +8291,20 @@ def __call__(self): return "HFT-USD" -HFT_USD = HFT_USD() +HFT_USDT = HFT_USDT() @dataclass(slots=True, frozen=True) class HFT_USDT: + """ + name: HFT-USDT + precision: 0.0001 + minimum_margin: None + initial_margin: None + minimum_order_size: 1 + maximum_order_size: None + margin: False + """ name: str = "HFT-USDT" precision: int = 0.0001 minimum_margin: float = None @@ -5978,11 +8323,20 @@ def __call__(self): return "HFT-USDT" -HFT_USDT = HFT_USDT() +HIGH_USD = HIGH_USD() @dataclass(slots=True, frozen=True) class HIGH_USD: + """ + name: HIGH-USD + precision: 0.001 + minimum_margin: None + initial_margin: None + minimum_order_size: 1 + maximum_order_size: None + margin: False + """ name: str = "HIGH-USD" precision: int = 0.001 minimum_margin: float = None @@ -6001,11 +8355,20 @@ def __call__(self): return "HIGH-USD" -HIGH_USD = HIGH_USD() +HOPR_USD = HOPR_USD() @dataclass(slots=True, frozen=True) class HOPR_USD: + """ + name: HOPR-USD + precision: 0.0001 + minimum_margin: None + initial_margin: None + minimum_order_size: 1 + maximum_order_size: None + margin: False + """ name: str = "HOPR-USD" precision: int = 0.0001 minimum_margin: float = None @@ -6024,11 +8387,20 @@ def __call__(self): return "HOPR-USD" -HOPR_USD = HOPR_USD() +HOPR_USDT = HOPR_USDT() @dataclass(slots=True, frozen=True) class HOPR_USDT: + """ + name: HOPR-USDT + precision: 0.0001 + minimum_margin: None + initial_margin: None + minimum_order_size: 1 + maximum_order_size: None + margin: False + """ name: str = "HOPR-USDT" precision: int = 0.0001 minimum_margin: float = None @@ -6047,11 +8419,20 @@ def __call__(self): return "HOPR-USDT" -HOPR_USDT = HOPR_USDT() +ICP_BTC = ICP_BTC() @dataclass(slots=True, frozen=True) class ICP_BTC: + """ + name: ICP-BTC + precision: 0.0000001 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.000016 + maximum_order_size: None + margin: False + """ name: str = "ICP-BTC" precision: int = 0.0000001 minimum_margin: float = None @@ -6070,11 +8451,20 @@ def __call__(self): return "ICP-BTC" -ICP_BTC = ICP_BTC() +ICP_EUR = ICP_EUR() @dataclass(slots=True, frozen=True) class ICP_EUR: + """ + name: ICP-EUR + precision: 0.01 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.84 + maximum_order_size: None + margin: False + """ name: str = "ICP-EUR" precision: int = 0.01 minimum_margin: float = None @@ -6093,11 +8483,20 @@ def __call__(self): return "ICP-EUR" -ICP_EUR = ICP_EUR() +ICP_GBP = ICP_GBP() @dataclass(slots=True, frozen=True) class ICP_GBP: + """ + name: ICP-GBP + precision: 0.01 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.72 + maximum_order_size: None + margin: False + """ name: str = "ICP-GBP" precision: int = 0.01 minimum_margin: float = None @@ -6116,11 +8515,20 @@ def __call__(self): return "ICP-GBP" -ICP_GBP = ICP_GBP() +ICP_USD = ICP_USD() @dataclass(slots=True, frozen=True) class ICP_USD: + """ + name: ICP-USD + precision: 0.001 + minimum_margin: None + initial_margin: None + minimum_order_size: 1 + maximum_order_size: None + margin: False + """ name: str = "ICP-USD" precision: int = 0.001 minimum_margin: float = None @@ -6139,11 +8547,20 @@ def __call__(self): return "ICP-USD" -ICP_USD = ICP_USD() +ICP_USDT = ICP_USDT() @dataclass(slots=True, frozen=True) class ICP_USDT: + """ + name: ICP-USDT + precision: 0.01 + minimum_margin: None + initial_margin: None + minimum_order_size: 1 + maximum_order_size: None + margin: False + """ name: str = "ICP-USDT" precision: int = 0.01 minimum_margin: float = None @@ -6162,11 +8579,20 @@ def __call__(self): return "ICP-USDT" -ICP_USDT = ICP_USDT() +IDEX_USD = IDEX_USD() @dataclass(slots=True, frozen=True) class IDEX_USD: + """ + name: IDEX-USD + precision: 0.0001 + minimum_margin: None + initial_margin: None + minimum_order_size: 1 + maximum_order_size: None + margin: False + """ name: str = "IDEX-USD" precision: int = 0.0001 minimum_margin: float = None @@ -6185,11 +8611,20 @@ def __call__(self): return "IDEX-USD" -IDEX_USD = IDEX_USD() +IDEX_USDT = IDEX_USDT() @dataclass(slots=True, frozen=True) class IDEX_USDT: + """ + name: IDEX-USDT + precision: 0.0001 + minimum_margin: None + initial_margin: None + minimum_order_size: 1 + maximum_order_size: None + margin: False + """ name: str = "IDEX-USDT" precision: int = 0.0001 minimum_margin: float = None @@ -6208,11 +8643,20 @@ def __call__(self): return "IDEX-USDT" -IDEX_USDT = IDEX_USDT() +ILV_USD = ILV_USD() @dataclass(slots=True, frozen=True) class ILV_USD: + """ + name: ILV-USD + precision: 0.01 + minimum_margin: None + initial_margin: None + minimum_order_size: 1 + maximum_order_size: None + margin: False + """ name: str = "ILV-USD" precision: int = 0.01 minimum_margin: float = None @@ -6231,11 +8675,20 @@ def __call__(self): return "ILV-USD" -ILV_USD = ILV_USD() +IMX_USD = IMX_USD() @dataclass(slots=True, frozen=True) class IMX_USD: + """ + name: IMX-USD + precision: 0.0001 + minimum_margin: None + initial_margin: None + minimum_order_size: 1 + maximum_order_size: None + margin: False + """ name: str = "IMX-USD" precision: int = 0.0001 minimum_margin: float = None @@ -6254,11 +8707,20 @@ def __call__(self): return "IMX-USD" -IMX_USD = IMX_USD() +IMX_USDT = IMX_USDT() @dataclass(slots=True, frozen=True) class IMX_USDT: + """ + name: IMX-USDT + precision: 0.0001 + minimum_margin: None + initial_margin: None + minimum_order_size: 1 + maximum_order_size: None + margin: False + """ name: str = "IMX-USDT" precision: int = 0.0001 minimum_margin: float = None @@ -6277,11 +8739,20 @@ def __call__(self): return "IMX-USDT" -IMX_USDT = IMX_USDT() +INDEX_USD = INDEX_USD() @dataclass(slots=True, frozen=True) class INDEX_USD: + """ + name: INDEX-USD + precision: 0.01 + minimum_margin: None + initial_margin: None + minimum_order_size: 1 + maximum_order_size: None + margin: False + """ name: str = "INDEX-USD" precision: int = 0.01 minimum_margin: float = None @@ -6300,11 +8771,20 @@ def __call__(self): return "INDEX-USD" -INDEX_USD = INDEX_USD() +INDEX_USDT = INDEX_USDT() @dataclass(slots=True, frozen=True) class INDEX_USDT: + """ + name: INDEX-USDT + precision: 0.01 + minimum_margin: None + initial_margin: None + minimum_order_size: 1 + maximum_order_size: None + margin: False + """ name: str = "INDEX-USDT" precision: int = 0.01 minimum_margin: float = None @@ -6323,11 +8803,20 @@ def __call__(self): return "INDEX-USDT" -INDEX_USDT = INDEX_USDT() +INJ_USD = INJ_USD() @dataclass(slots=True, frozen=True) class INJ_USD: + """ + name: INJ-USD + precision: 0.001 + minimum_margin: None + initial_margin: None + minimum_order_size: 1 + maximum_order_size: None + margin: False + """ name: str = "INJ-USD" precision: int = 0.001 minimum_margin: float = None @@ -6346,11 +8835,20 @@ def __call__(self): return "INJ-USD" -INJ_USD = INJ_USD() +INV_USD = INV_USD() @dataclass(slots=True, frozen=True) class INV_USD: + """ + name: INV-USD + precision: 0.01 + minimum_margin: None + initial_margin: None + minimum_order_size: 1 + maximum_order_size: None + margin: False + """ name: str = "INV-USD" precision: int = 0.01 minimum_margin: float = None @@ -6369,11 +8867,20 @@ def __call__(self): return "INV-USD" -INV_USD = INV_USD() +IOTX_EUR = IOTX_EUR() @dataclass(slots=True, frozen=True) class IOTX_EUR: + """ + name: IOTX-EUR + precision: 0.00001 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.84 + maximum_order_size: None + margin: False + """ name: str = "IOTX-EUR" precision: int = 0.00001 minimum_margin: float = None @@ -6392,11 +8899,20 @@ def __call__(self): return "IOTX-EUR" -IOTX_EUR = IOTX_EUR() +IOTX_USD = IOTX_USD() @dataclass(slots=True, frozen=True) class IOTX_USD: + """ + name: IOTX-USD + precision: 0.00001 + minimum_margin: None + initial_margin: None + minimum_order_size: 1 + maximum_order_size: None + margin: False + """ name: str = "IOTX-USD" precision: int = 0.00001 minimum_margin: float = None @@ -6415,11 +8931,20 @@ def __call__(self): return "IOTX-USD" -IOTX_USD = IOTX_USD() +JASMY_USD = JASMY_USD() @dataclass(slots=True, frozen=True) class JASMY_USD: + """ + name: JASMY-USD + precision: 0.00001 + minimum_margin: None + initial_margin: None + minimum_order_size: 1 + maximum_order_size: None + margin: False + """ name: str = "JASMY-USD" precision: int = 0.00001 minimum_margin: float = None @@ -6438,11 +8963,20 @@ def __call__(self): return "JASMY-USD" -JASMY_USD = JASMY_USD() +JASMY_USDT = JASMY_USDT() @dataclass(slots=True, frozen=True) class JASMY_USDT: + """ + name: JASMY-USDT + precision: 0.00001 + minimum_margin: None + initial_margin: None + minimum_order_size: 1 + maximum_order_size: None + margin: False + """ name: str = "JASMY-USDT" precision: int = 0.00001 minimum_margin: float = None @@ -6461,11 +8995,20 @@ def __call__(self): return "JASMY-USDT" -JASMY_USDT = JASMY_USDT() +JUP_USD = JUP_USD() @dataclass(slots=True, frozen=True) class JUP_USD: + """ + name: JUP-USD + precision: 0.000001 + minimum_margin: None + initial_margin: None + minimum_order_size: 1 + maximum_order_size: None + margin: False + """ name: str = "JUP-USD" precision: int = 0.000001 minimum_margin: float = None @@ -6484,11 +9027,20 @@ def __call__(self): return "JUP-USD" -JUP_USD = JUP_USD() +KEEP_USD = KEEP_USD() @dataclass(slots=True, frozen=True) class KEEP_USD: + """ + name: KEEP-USD + precision: 0.0001 + minimum_margin: None + initial_margin: None + minimum_order_size: 1 + maximum_order_size: None + margin: False + """ name: str = "KEEP-USD" precision: int = 0.0001 minimum_margin: float = None @@ -6507,11 +9059,20 @@ def __call__(self): return "KEEP-USD" -KEEP_USD = KEEP_USD() +KNC_BTC = KNC_BTC() @dataclass(slots=True, frozen=True) class KNC_BTC: + """ + name: KNC-BTC + precision: 0.00000001 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.000016 + maximum_order_size: None + margin: False + """ name: str = "KNC-BTC" precision: int = 0.00000001 minimum_margin: float = None @@ -6530,11 +9091,20 @@ def __call__(self): return "KNC-BTC" -KNC_BTC = KNC_BTC() +KNC_USD = KNC_USD() @dataclass(slots=True, frozen=True) class KNC_USD: + """ + name: KNC-USD + precision: 0.0001 + minimum_margin: None + initial_margin: None + minimum_order_size: 1 + maximum_order_size: None + margin: False + """ name: str = "KNC-USD" precision: int = 0.0001 minimum_margin: float = None @@ -6553,11 +9123,20 @@ def __call__(self): return "KNC-USD" -KNC_USD = KNC_USD() +KRL_EUR = KRL_EUR() @dataclass(slots=True, frozen=True) class KRL_EUR: + """ + name: KRL-EUR + precision: 0.0001 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.84 + maximum_order_size: None + margin: False + """ name: str = "KRL-EUR" precision: int = 0.0001 minimum_margin: float = None @@ -6576,11 +9155,20 @@ def __call__(self): return "KRL-EUR" -KRL_EUR = KRL_EUR() +KRL_USD = KRL_USD() @dataclass(slots=True, frozen=True) class KRL_USD: + """ + name: KRL-USD + precision: 0.0001 + minimum_margin: None + initial_margin: None + minimum_order_size: 1 + maximum_order_size: None + margin: False + """ name: str = "KRL-USD" precision: int = 0.0001 minimum_margin: float = None @@ -6599,11 +9187,20 @@ def __call__(self): return "KRL-USD" -KRL_USD = KRL_USD() +KRL_USDT = KRL_USDT() @dataclass(slots=True, frozen=True) class KRL_USDT: + """ + name: KRL-USDT + precision: 0.0001 + minimum_margin: None + initial_margin: None + minimum_order_size: 1 + maximum_order_size: None + margin: False + """ name: str = "KRL-USDT" precision: int = 0.0001 minimum_margin: float = None @@ -6622,11 +9219,20 @@ def __call__(self): return "KRL-USDT" -KRL_USDT = KRL_USDT() +KSM_USD = KSM_USD() @dataclass(slots=True, frozen=True) class KSM_USD: + """ + name: KSM-USD + precision: 0.01 + minimum_margin: None + initial_margin: None + minimum_order_size: 1 + maximum_order_size: None + margin: False + """ name: str = "KSM-USD" precision: int = 0.01 minimum_margin: float = None @@ -6645,11 +9251,20 @@ def __call__(self): return "KSM-USD" -KSM_USD = KSM_USD() +KSM_USDT = KSM_USDT() @dataclass(slots=True, frozen=True) class KSM_USDT: + """ + name: KSM-USDT + precision: 0.01 + minimum_margin: None + initial_margin: None + minimum_order_size: 1 + maximum_order_size: None + margin: False + """ name: str = "KSM-USDT" precision: int = 0.01 minimum_margin: float = None @@ -6668,11 +9283,20 @@ def __call__(self): return "KSM-USDT" -KSM_USDT = KSM_USDT() +LCX_EUR = LCX_EUR() @dataclass(slots=True, frozen=True) class LCX_EUR: + """ + name: LCX-EUR + precision: 0.0001 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.84 + maximum_order_size: None + margin: False + """ name: str = "LCX-EUR" precision: int = 0.0001 minimum_margin: float = None @@ -6691,11 +9315,20 @@ def __call__(self): return "LCX-EUR" -LCX_EUR = LCX_EUR() +LCX_USD = LCX_USD() @dataclass(slots=True, frozen=True) class LCX_USD: + """ + name: LCX-USD + precision: 0.0001 + minimum_margin: None + initial_margin: None + minimum_order_size: 1 + maximum_order_size: None + margin: False + """ name: str = "LCX-USD" precision: int = 0.0001 minimum_margin: float = None @@ -6714,11 +9347,20 @@ def __call__(self): return "LCX-USD" -LCX_USD = LCX_USD() +LCX_USDT = LCX_USDT() @dataclass(slots=True, frozen=True) class LCX_USDT: + """ + name: LCX-USDT + precision: 0.0001 + minimum_margin: None + initial_margin: None + minimum_order_size: 1 + maximum_order_size: None + margin: False + """ name: str = "LCX-USDT" precision: int = 0.0001 minimum_margin: float = None @@ -6737,11 +9379,20 @@ def __call__(self): return "LCX-USDT" -LCX_USDT = LCX_USDT() +LDO_USD = LDO_USD() @dataclass(slots=True, frozen=True) class LDO_USD: + """ + name: LDO-USD + precision: 0.001 + minimum_margin: None + initial_margin: None + minimum_order_size: 1 + maximum_order_size: None + margin: False + """ name: str = "LDO-USD" precision: int = 0.001 minimum_margin: float = None @@ -6760,11 +9411,20 @@ def __call__(self): return "LDO-USD" -LDO_USD = LDO_USD() +LINK_BTC = LINK_BTC() @dataclass(slots=True, frozen=True) class LINK_BTC: + """ + name: LINK-BTC + precision: 0.00000001 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.000016 + maximum_order_size: None + margin: False + """ name: str = "LINK-BTC" precision: int = 0.00000001 minimum_margin: float = None @@ -6783,11 +9443,20 @@ def __call__(self): return "LINK-BTC" -LINK_BTC = LINK_BTC() +LINK_ETH = LINK_ETH() @dataclass(slots=True, frozen=True) class LINK_ETH: + """ + name: LINK-ETH + precision: 0.00000001 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.00022 + maximum_order_size: None + margin: False + """ name: str = "LINK-ETH" precision: int = 0.00000001 minimum_margin: float = None @@ -6806,11 +9475,20 @@ def __call__(self): return "LINK-ETH" -LINK_ETH = LINK_ETH() +LINK_EUR = LINK_EUR() @dataclass(slots=True, frozen=True) class LINK_EUR: + """ + name: LINK-EUR + precision: 0.01 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.84 + maximum_order_size: None + margin: False + """ name: str = "LINK-EUR" precision: int = 0.01 minimum_margin: float = None @@ -6829,11 +9507,20 @@ def __call__(self): return "LINK-EUR" -LINK_EUR = LINK_EUR() +LINK_GBP = LINK_GBP() @dataclass(slots=True, frozen=True) class LINK_GBP: + """ + name: LINK-GBP + precision: 0.01 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.72 + maximum_order_size: None + margin: False + """ name: str = "LINK-GBP" precision: int = 0.01 minimum_margin: float = None @@ -6852,11 +9539,20 @@ def __call__(self): return "LINK-GBP" -LINK_GBP = LINK_GBP() +LINK_USD = LINK_USD() @dataclass(slots=True, frozen=True) class LINK_USD: + """ + name: LINK-USD + precision: 0.001 + minimum_margin: None + initial_margin: None + minimum_order_size: 1 + maximum_order_size: None + margin: False + """ name: str = "LINK-USD" precision: int = 0.001 minimum_margin: float = None @@ -6875,11 +9571,20 @@ def __call__(self): return "LINK-USD" -LINK_USD = LINK_USD() +LINK_USDT = LINK_USDT() @dataclass(slots=True, frozen=True) class LINK_USDT: + """ + name: LINK-USDT + precision: 0.01 + minimum_margin: None + initial_margin: None + minimum_order_size: 1 + maximum_order_size: None + margin: False + """ name: str = "LINK-USDT" precision: int = 0.01 minimum_margin: float = None @@ -6898,11 +9603,20 @@ def __call__(self): return "LINK-USDT" -LINK_USDT = LINK_USDT() +LIT_USD = LIT_USD() @dataclass(slots=True, frozen=True) class LIT_USD: + """ + name: LIT-USD + precision: 0.0001 + minimum_margin: None + initial_margin: None + minimum_order_size: 1 + maximum_order_size: None + margin: False + """ name: str = "LIT-USD" precision: int = 0.0001 minimum_margin: float = None @@ -6921,11 +9635,20 @@ def __call__(self): return "LIT-USD" -LIT_USD = LIT_USD() +LOKA_USD = LOKA_USD() @dataclass(slots=True, frozen=True) class LOKA_USD: + """ + name: LOKA-USD + precision: 0.0001 + minimum_margin: None + initial_margin: None + minimum_order_size: 1 + maximum_order_size: None + margin: False + """ name: str = "LOKA-USD" precision: int = 0.0001 minimum_margin: float = None @@ -6944,11 +9667,20 @@ def __call__(self): return "LOKA-USD" -LOKA_USD = LOKA_USD() +LOOM_USD = LOOM_USD() @dataclass(slots=True, frozen=True) class LOOM_USD: + """ + name: LOOM-USD + precision: 0.0001 + minimum_margin: None + initial_margin: None + minimum_order_size: 1 + maximum_order_size: None + margin: False + """ name: str = "LOOM-USD" precision: int = 0.0001 minimum_margin: float = None @@ -6967,11 +9699,20 @@ def __call__(self): return "LOOM-USD" -LOOM_USD = LOOM_USD() +LOOM_USDC = LOOM_USDC() @dataclass(slots=True, frozen=True) class LOOM_USDC: + """ + name: LOOM-USDC + precision: 0.000001 + minimum_margin: None + initial_margin: None + minimum_order_size: 1 + maximum_order_size: None + margin: False + """ name: str = "LOOM-USDC" precision: int = 0.000001 minimum_margin: float = None @@ -6990,11 +9731,20 @@ def __call__(self): return "LOOM-USDC" -LOOM_USDC = LOOM_USDC() +LPT_USD = LPT_USD() @dataclass(slots=True, frozen=True) class LPT_USD: + """ + name: LPT-USD + precision: 0.01 + minimum_margin: None + initial_margin: None + minimum_order_size: 1 + maximum_order_size: None + margin: False + """ name: str = "LPT-USD" precision: int = 0.01 minimum_margin: float = None @@ -7013,11 +9763,20 @@ def __call__(self): return "LPT-USD" -LPT_USD = LPT_USD() +LQTY_EUR = LQTY_EUR() @dataclass(slots=True, frozen=True) class LQTY_EUR: + """ + name: LQTY-EUR + precision: 0.0001 + minimum_margin: None + initial_margin: None + minimum_order_size: 1 + maximum_order_size: None + margin: False + """ name: str = "LQTY-EUR" precision: int = 0.0001 minimum_margin: float = None @@ -7036,11 +9795,20 @@ def __call__(self): return "LQTY-EUR" -LQTY_EUR = LQTY_EUR() +LQTY_USD = LQTY_USD() @dataclass(slots=True, frozen=True) class LQTY_USD: + """ + name: LQTY-USD + precision: 0.0001 + minimum_margin: None + initial_margin: None + minimum_order_size: 1 + maximum_order_size: None + margin: False + """ name: str = "LQTY-USD" precision: int = 0.0001 minimum_margin: float = None @@ -7059,11 +9827,20 @@ def __call__(self): return "LQTY-USD" -LQTY_USD = LQTY_USD() +LQTY_USDT = LQTY_USDT() @dataclass(slots=True, frozen=True) class LQTY_USDT: + """ + name: LQTY-USDT + precision: 0.0001 + minimum_margin: None + initial_margin: None + minimum_order_size: 1 + maximum_order_size: None + margin: False + """ name: str = "LQTY-USDT" precision: int = 0.0001 minimum_margin: float = None @@ -7082,11 +9859,20 @@ def __call__(self): return "LQTY-USDT" -LQTY_USDT = LQTY_USDT() +LRC_BTC = LRC_BTC() @dataclass(slots=True, frozen=True) class LRC_BTC: + """ + name: LRC-BTC + precision: 0.00000001 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.000016 + maximum_order_size: None + margin: False + """ name: str = "LRC-BTC" precision: int = 0.00000001 minimum_margin: float = None @@ -7105,11 +9891,20 @@ def __call__(self): return "LRC-BTC" -LRC_BTC = LRC_BTC() +LRC_USD = LRC_USD() @dataclass(slots=True, frozen=True) class LRC_USD: + """ + name: LRC-USD + precision: 0.0001 + minimum_margin: None + initial_margin: None + minimum_order_size: 1 + maximum_order_size: None + margin: False + """ name: str = "LRC-USD" precision: int = 0.0001 minimum_margin: float = None @@ -7128,11 +9923,20 @@ def __call__(self): return "LRC-USD" -LRC_USD = LRC_USD() +LRC_USDT = LRC_USDT() @dataclass(slots=True, frozen=True) class LRC_USDT: + """ + name: LRC-USDT + precision: 0.0001 + minimum_margin: None + initial_margin: None + minimum_order_size: 1 + maximum_order_size: None + margin: False + """ name: str = "LRC-USDT" precision: int = 0.0001 minimum_margin: float = None @@ -7151,11 +9955,20 @@ def __call__(self): return "LRC-USDT" -LRC_USDT = LRC_USDT() +LTC_BTC = LTC_BTC() @dataclass(slots=True, frozen=True) class LTC_BTC: + """ + name: LTC-BTC + precision: 0.000001 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.000016 + maximum_order_size: None + margin: False + """ name: str = "LTC-BTC" precision: int = 0.000001 minimum_margin: float = None @@ -7174,11 +9987,20 @@ def __call__(self): return "LTC-BTC" -LTC_BTC = LTC_BTC() +LTC_EUR = LTC_EUR() @dataclass(slots=True, frozen=True) class LTC_EUR: + """ + name: LTC-EUR + precision: 0.01 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.84 + maximum_order_size: None + margin: False + """ name: str = "LTC-EUR" precision: int = 0.01 minimum_margin: float = None @@ -7197,11 +10019,20 @@ def __call__(self): return "LTC-EUR" -LTC_EUR = LTC_EUR() +LTC_GBP = LTC_GBP() @dataclass(slots=True, frozen=True) class LTC_GBP: + """ + name: LTC-GBP + precision: 0.01 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.72 + maximum_order_size: None + margin: False + """ name: str = "LTC-GBP" precision: int = 0.01 minimum_margin: float = None @@ -7220,11 +10051,20 @@ def __call__(self): return "LTC-GBP" -LTC_GBP = LTC_GBP() +LTC_USD = LTC_USD() @dataclass(slots=True, frozen=True) class LTC_USD: + """ + name: LTC-USD + precision: 0.01 + minimum_margin: None + initial_margin: None + minimum_order_size: 1 + maximum_order_size: None + margin: False + """ name: str = "LTC-USD" precision: int = 0.01 minimum_margin: float = None @@ -7243,11 +10083,20 @@ def __call__(self): return "LTC-USD" -LTC_USD = LTC_USD() +MAGIC_USD = MAGIC_USD() @dataclass(slots=True, frozen=True) class MAGIC_USD: + """ + name: MAGIC-USD + precision: 0.0001 + minimum_margin: None + initial_margin: None + minimum_order_size: 1 + maximum_order_size: None + margin: False + """ name: str = "MAGIC-USD" precision: int = 0.0001 minimum_margin: float = None @@ -7266,11 +10115,20 @@ def __call__(self): return "MAGIC-USD" -MAGIC_USD = MAGIC_USD() +MANA_BTC = MANA_BTC() @dataclass(slots=True, frozen=True) class MANA_BTC: + """ + name: MANA-BTC + precision: 0.0000001 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.000016 + maximum_order_size: None + margin: False + """ name: str = "MANA-BTC" precision: int = 0.0000001 minimum_margin: float = None @@ -7289,11 +10147,20 @@ def __call__(self): return "MANA-BTC" -MANA_BTC = MANA_BTC() +MANA_ETH = MANA_ETH() @dataclass(slots=True, frozen=True) class MANA_ETH: + """ + name: MANA-ETH + precision: 0.0000001 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.00022 + maximum_order_size: None + margin: False + """ name: str = "MANA-ETH" precision: int = 0.0000001 minimum_margin: float = None @@ -7312,11 +10179,20 @@ def __call__(self): return "MANA-ETH" -MANA_ETH = MANA_ETH() +MANA_EUR = MANA_EUR() @dataclass(slots=True, frozen=True) class MANA_EUR: + """ + name: MANA-EUR + precision: 0.001 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.84 + maximum_order_size: None + margin: False + """ name: str = "MANA-EUR" precision: int = 0.001 minimum_margin: float = None @@ -7335,11 +10211,20 @@ def __call__(self): return "MANA-EUR" -MANA_EUR = MANA_EUR() +MANA_USD = MANA_USD() @dataclass(slots=True, frozen=True) class MANA_USD: + """ + name: MANA-USD + precision: 0.0001 + minimum_margin: None + initial_margin: None + minimum_order_size: 1 + maximum_order_size: None + margin: False + """ name: str = "MANA-USD" precision: int = 0.0001 minimum_margin: float = None @@ -7358,11 +10243,20 @@ def __call__(self): return "MANA-USD" -MANA_USD = MANA_USD() +MANA_USDC = MANA_USDC() @dataclass(slots=True, frozen=True) class MANA_USDC: + """ + name: MANA-USDC + precision: 0.000001 + minimum_margin: None + initial_margin: None + minimum_order_size: 1 + maximum_order_size: None + margin: False + """ name: str = "MANA-USDC" precision: int = 0.000001 minimum_margin: float = None @@ -7381,11 +10275,20 @@ def __call__(self): return "MANA-USDC" -MANA_USDC = MANA_USDC() +MASK_EUR = MASK_EUR() @dataclass(slots=True, frozen=True) class MASK_EUR: + """ + name: MASK-EUR + precision: 0.01 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.84 + maximum_order_size: None + margin: False + """ name: str = "MASK-EUR" precision: int = 0.01 minimum_margin: float = None @@ -7404,11 +10307,20 @@ def __call__(self): return "MASK-EUR" -MASK_EUR = MASK_EUR() +MASK_GBP = MASK_GBP() @dataclass(slots=True, frozen=True) class MASK_GBP: + """ + name: MASK-GBP + precision: 0.001 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.72 + maximum_order_size: None + margin: False + """ name: str = "MASK-GBP" precision: int = 0.001 minimum_margin: float = None @@ -7427,11 +10339,20 @@ def __call__(self): return "MASK-GBP" -MASK_GBP = MASK_GBP() +MASK_USD = MASK_USD() @dataclass(slots=True, frozen=True) class MASK_USD: + """ + name: MASK-USD + precision: 0.01 + minimum_margin: None + initial_margin: None + minimum_order_size: 1 + maximum_order_size: None + margin: False + """ name: str = "MASK-USD" precision: int = 0.01 minimum_margin: float = None @@ -7450,11 +10371,20 @@ def __call__(self): return "MASK-USD" -MASK_USD = MASK_USD() +MASK_USDT = MASK_USDT() @dataclass(slots=True, frozen=True) class MASK_USDT: + """ + name: MASK-USDT + precision: 0.01 + minimum_margin: None + initial_margin: None + minimum_order_size: 1 + maximum_order_size: None + margin: False + """ name: str = "MASK-USDT" precision: int = 0.01 minimum_margin: float = None @@ -7473,11 +10403,20 @@ def __call__(self): return "MASK-USDT" -MASK_USDT = MASK_USDT() +MATH_USD = MATH_USD() @dataclass(slots=True, frozen=True) class MATH_USD: + """ + name: MATH-USD + precision: 0.0001 + minimum_margin: None + initial_margin: None + minimum_order_size: 1 + maximum_order_size: None + margin: False + """ name: str = "MATH-USD" precision: int = 0.0001 minimum_margin: float = None @@ -7496,11 +10435,20 @@ def __call__(self): return "MATH-USD" -MATH_USD = MATH_USD() +MATH_USDT = MATH_USDT() @dataclass(slots=True, frozen=True) class MATH_USDT: + """ + name: MATH-USDT + precision: 0.0001 + minimum_margin: None + initial_margin: None + minimum_order_size: 1 + maximum_order_size: None + margin: False + """ name: str = "MATH-USDT" precision: int = 0.0001 minimum_margin: float = None @@ -7519,11 +10467,20 @@ def __call__(self): return "MATH-USDT" -MATH_USDT = MATH_USDT() +MATIC_BTC = MATIC_BTC() @dataclass(slots=True, frozen=True) class MATIC_BTC: + """ + name: MATIC-BTC + precision: 0.00000001 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.000016 + maximum_order_size: None + margin: False + """ name: str = "MATIC-BTC" precision: int = 0.00000001 minimum_margin: float = None @@ -7542,11 +10499,20 @@ def __call__(self): return "MATIC-BTC" -MATIC_BTC = MATIC_BTC() +MATIC_EUR = MATIC_EUR() @dataclass(slots=True, frozen=True) class MATIC_EUR: + """ + name: MATIC-EUR + precision: 0.0001 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.84 + maximum_order_size: None + margin: False + """ name: str = "MATIC-EUR" precision: int = 0.0001 minimum_margin: float = None @@ -7565,11 +10531,20 @@ def __call__(self): return "MATIC-EUR" -MATIC_EUR = MATIC_EUR() +MATIC_GBP = MATIC_GBP() @dataclass(slots=True, frozen=True) class MATIC_GBP: + """ + name: MATIC-GBP + precision: 0.0001 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.72 + maximum_order_size: None + margin: False + """ name: str = "MATIC-GBP" precision: int = 0.0001 minimum_margin: float = None @@ -7588,11 +10563,20 @@ def __call__(self): return "MATIC-GBP" -MATIC_GBP = MATIC_GBP() +MATIC_USD = MATIC_USD() @dataclass(slots=True, frozen=True) class MATIC_USD: + """ + name: MATIC-USD + precision: 0.0001 + minimum_margin: None + initial_margin: None + minimum_order_size: 1 + maximum_order_size: None + margin: False + """ name: str = "MATIC-USD" precision: int = 0.0001 minimum_margin: float = None @@ -7611,11 +10595,20 @@ def __call__(self): return "MATIC-USD" -MATIC_USD = MATIC_USD() +MATIC_USDT = MATIC_USDT() @dataclass(slots=True, frozen=True) class MATIC_USDT: + """ + name: MATIC-USDT + precision: 0.001 + minimum_margin: None + initial_margin: None + minimum_order_size: 1 + maximum_order_size: None + margin: False + """ name: str = "MATIC-USDT" precision: int = 0.001 minimum_margin: float = None @@ -7634,11 +10627,20 @@ def __call__(self): return "MATIC-USDT" -MATIC_USDT = MATIC_USDT() +MCO2_USD = MCO2_USD() @dataclass(slots=True, frozen=True) class MCO2_USD: + """ + name: MCO2-USD + precision: 0.01 + minimum_margin: None + initial_margin: None + minimum_order_size: 1 + maximum_order_size: None + margin: False + """ name: str = "MCO2-USD" precision: int = 0.01 minimum_margin: float = None @@ -7657,11 +10659,20 @@ def __call__(self): return "MCO2-USD" -MCO2_USD = MCO2_USD() +MCO2_USDT = MCO2_USDT() @dataclass(slots=True, frozen=True) class MCO2_USDT: + """ + name: MCO2-USDT + precision: 0.01 + minimum_margin: None + initial_margin: None + minimum_order_size: 1 + maximum_order_size: None + margin: False + """ name: str = "MCO2-USDT" precision: int = 0.01 minimum_margin: float = None @@ -7680,11 +10691,20 @@ def __call__(self): return "MCO2-USDT" -MCO2_USDT = MCO2_USDT() +MDT_USD = MDT_USD() @dataclass(slots=True, frozen=True) class MDT_USD: + """ + name: MDT-USD + precision: 0.00001 + minimum_margin: None + initial_margin: None + minimum_order_size: 1 + maximum_order_size: None + margin: False + """ name: str = "MDT-USD" precision: int = 0.00001 minimum_margin: float = None @@ -7703,11 +10723,20 @@ def __call__(self): return "MDT-USD" -MDT_USD = MDT_USD() +MDT_USDT = MDT_USDT() @dataclass(slots=True, frozen=True) class MDT_USDT: + """ + name: MDT-USDT + precision: 0.00001 + minimum_margin: None + initial_margin: None + minimum_order_size: 1 + maximum_order_size: None + margin: False + """ name: str = "MDT-USDT" precision: int = 0.00001 minimum_margin: float = None @@ -7726,11 +10755,20 @@ def __call__(self): return "MDT-USDT" -MDT_USDT = MDT_USDT() +MEDIA_USD = MEDIA_USD() @dataclass(slots=True, frozen=True) class MEDIA_USD: + """ + name: MEDIA-USD + precision: 0.01 + minimum_margin: None + initial_margin: None + minimum_order_size: 1 + maximum_order_size: None + margin: False + """ name: str = "MEDIA-USD" precision: int = 0.01 minimum_margin: float = None @@ -7749,11 +10787,20 @@ def __call__(self): return "MEDIA-USD" -MEDIA_USD = MEDIA_USD() +MEDIA_USDT = MEDIA_USDT() @dataclass(slots=True, frozen=True) class MEDIA_USDT: + """ + name: MEDIA-USDT + precision: 0.01 + minimum_margin: None + initial_margin: None + minimum_order_size: 1 + maximum_order_size: None + margin: False + """ name: str = "MEDIA-USDT" precision: int = 0.01 minimum_margin: float = None @@ -7772,11 +10819,20 @@ def __call__(self): return "MEDIA-USDT" -MEDIA_USDT = MEDIA_USDT() +METIS_USD = METIS_USD() @dataclass(slots=True, frozen=True) class METIS_USD: + """ + name: METIS-USD + precision: 0.01 + minimum_margin: None + initial_margin: None + minimum_order_size: 1 + maximum_order_size: None + margin: False + """ name: str = "METIS-USD" precision: int = 0.01 minimum_margin: float = None @@ -7795,11 +10851,20 @@ def __call__(self): return "METIS-USD" -METIS_USD = METIS_USD() +METIS_USDT = METIS_USDT() @dataclass(slots=True, frozen=True) class METIS_USDT: + """ + name: METIS-USDT + precision: 0.01 + minimum_margin: None + initial_margin: None + minimum_order_size: 1 + maximum_order_size: None + margin: False + """ name: str = "METIS-USDT" precision: int = 0.01 minimum_margin: float = None @@ -7818,11 +10883,20 @@ def __call__(self): return "METIS-USDT" -METIS_USDT = METIS_USDT() +MINA_EUR = MINA_EUR() @dataclass(slots=True, frozen=True) class MINA_EUR: + """ + name: MINA-EUR + precision: 0.001 + minimum_margin: None + initial_margin: None + minimum_order_size: 1 + maximum_order_size: None + margin: False + """ name: str = "MINA-EUR" precision: int = 0.001 minimum_margin: float = None @@ -7841,11 +10915,20 @@ def __call__(self): return "MINA-EUR" -MINA_EUR = MINA_EUR() +MINA_USD = MINA_USD() @dataclass(slots=True, frozen=True) class MINA_USD: + """ + name: MINA-USD + precision: 0.001 + minimum_margin: None + initial_margin: None + minimum_order_size: 1 + maximum_order_size: None + margin: False + """ name: str = "MINA-USD" precision: int = 0.001 minimum_margin: float = None @@ -7864,11 +10947,20 @@ def __call__(self): return "MINA-USD" -MINA_USD = MINA_USD() +MINA_USDT = MINA_USDT() @dataclass(slots=True, frozen=True) class MINA_USDT: + """ + name: MINA-USDT + precision: 0.001 + minimum_margin: None + initial_margin: None + minimum_order_size: 1 + maximum_order_size: None + margin: False + """ name: str = "MINA-USDT" precision: int = 0.001 minimum_margin: float = None @@ -7887,11 +10979,20 @@ def __call__(self): return "MINA-USDT" -MINA_USDT = MINA_USDT() +MIR_BTC = MIR_BTC() @dataclass(slots=True, frozen=True) class MIR_BTC: + """ + name: MIR-BTC + precision: 0.00000001 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.000016 + maximum_order_size: None + margin: False + """ name: str = "MIR-BTC" precision: int = 0.00000001 minimum_margin: float = None @@ -7910,11 +11011,20 @@ def __call__(self): return "MIR-BTC" -MIR_BTC = MIR_BTC() +MIR_EUR = MIR_EUR() @dataclass(slots=True, frozen=True) class MIR_EUR: + """ + name: MIR-EUR + precision: 0.001 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.84 + maximum_order_size: None + margin: False + """ name: str = "MIR-EUR" precision: int = 0.001 minimum_margin: float = None @@ -7933,11 +11043,20 @@ def __call__(self): return "MIR-EUR" -MIR_EUR = MIR_EUR() +MIR_GBP = MIR_GBP() @dataclass(slots=True, frozen=True) class MIR_GBP: + """ + name: MIR-GBP + precision: 0.001 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.72 + maximum_order_size: None + margin: False + """ name: str = "MIR-GBP" precision: int = 0.001 minimum_margin: float = None @@ -7956,11 +11075,20 @@ def __call__(self): return "MIR-GBP" -MIR_GBP = MIR_GBP() +MIR_USD = MIR_USD() @dataclass(slots=True, frozen=True) class MIR_USD: + """ + name: MIR-USD + precision: 0.0001 + minimum_margin: None + initial_margin: None + minimum_order_size: 1 + maximum_order_size: None + margin: False + """ name: str = "MIR-USD" precision: int = 0.0001 minimum_margin: float = None @@ -7979,11 +11107,20 @@ def __call__(self): return "MIR-USD" -MIR_USD = MIR_USD() +MKR_BTC = MKR_BTC() @dataclass(slots=True, frozen=True) class MKR_BTC: + """ + name: MKR-BTC + precision: 0.00001 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.00001 + maximum_order_size: None + margin: False + """ name: str = "MKR-BTC" precision: int = 0.00001 minimum_margin: float = None @@ -8002,11 +11139,20 @@ def __call__(self): return "MKR-BTC" -MKR_BTC = MKR_BTC() +MKR_USD = MKR_USD() @dataclass(slots=True, frozen=True) class MKR_USD: + """ + name: MKR-USD + precision: 0.01 + minimum_margin: None + initial_margin: None + minimum_order_size: 1 + maximum_order_size: None + margin: False + """ name: str = "MKR-USD" precision: int = 0.01 minimum_margin: float = None @@ -8025,11 +11171,20 @@ def __call__(self): return "MKR-USD" -MKR_USD = MKR_USD() +MLN_USD = MLN_USD() @dataclass(slots=True, frozen=True) class MLN_USD: + """ + name: MLN-USD + precision: 0.01 + minimum_margin: None + initial_margin: None + minimum_order_size: 1 + maximum_order_size: None + margin: False + """ name: str = "MLN-USD" precision: int = 0.01 minimum_margin: float = None @@ -8048,11 +11203,20 @@ def __call__(self): return "MLN-USD" -MLN_USD = MLN_USD() +MNDE_USD = MNDE_USD() @dataclass(slots=True, frozen=True) class MNDE_USD: + """ + name: MNDE-USD + precision: 0.00001 + minimum_margin: None + initial_margin: None + minimum_order_size: 1 + maximum_order_size: None + margin: False + """ name: str = "MNDE-USD" precision: int = 0.00001 minimum_margin: float = None @@ -8071,11 +11235,20 @@ def __call__(self): return "MNDE-USD" -MNDE_USD = MNDE_USD() +MONA_USD = MONA_USD() @dataclass(slots=True, frozen=True) class MONA_USD: + """ + name: MONA-USD + precision: 0.01 + minimum_margin: None + initial_margin: None + minimum_order_size: 1 + maximum_order_size: None + margin: False + """ name: str = "MONA-USD" precision: int = 0.01 minimum_margin: float = None @@ -8094,11 +11267,20 @@ def __call__(self): return "MONA-USD" -MONA_USD = MONA_USD() +MPL_USD = MPL_USD() @dataclass(slots=True, frozen=True) class MPL_USD: + """ + name: MPL-USD + precision: 0.01 + minimum_margin: None + initial_margin: None + minimum_order_size: 1 + maximum_order_size: None + margin: False + """ name: str = "MPL-USD" precision: int = 0.01 minimum_margin: float = None @@ -8117,11 +11299,20 @@ def __call__(self): return "MPL-USD" -MPL_USD = MPL_USD() +MSOL_USD = MSOL_USD() @dataclass(slots=True, frozen=True) class MSOL_USD: + """ + name: MSOL-USD + precision: 0.01 + minimum_margin: None + initial_margin: None + minimum_order_size: 1 + maximum_order_size: None + margin: False + """ name: str = "MSOL-USD" precision: int = 0.01 minimum_margin: float = None @@ -8140,11 +11331,20 @@ def __call__(self): return "MSOL-USD" -MSOL_USD = MSOL_USD() +MTL_USD = MTL_USD() @dataclass(slots=True, frozen=True) class MTL_USD: + """ + name: MTL-USD + precision: 0.001 + minimum_margin: None + initial_margin: None + minimum_order_size: 1 + maximum_order_size: None + margin: False + """ name: str = "MTL-USD" precision: int = 0.001 minimum_margin: float = None @@ -8163,11 +11363,20 @@ def __call__(self): return "MTL-USD" -MTL_USD = MTL_USD() +MUSD_USD = MUSD_USD() @dataclass(slots=True, frozen=True) class MUSD_USD: + """ + name: MUSD-USD + precision: 0.0001 + minimum_margin: None + initial_margin: None + minimum_order_size: 1 + maximum_order_size: None + margin: False + """ name: str = "MUSD-USD" precision: int = 0.0001 minimum_margin: float = None @@ -8186,11 +11395,20 @@ def __call__(self): return "MUSD-USD" -MUSD_USD = MUSD_USD() +MUSE_USD = MUSE_USD() @dataclass(slots=True, frozen=True) class MUSE_USD: + """ + name: MUSE-USD + precision: 0.001 + minimum_margin: None + initial_margin: None + minimum_order_size: 1 + maximum_order_size: None + margin: False + """ name: str = "MUSE-USD" precision: int = 0.001 minimum_margin: float = None @@ -8209,11 +11427,20 @@ def __call__(self): return "MUSE-USD" -MUSE_USD = MUSE_USD() +MXC_USD = MXC_USD() @dataclass(slots=True, frozen=True) class MXC_USD: + """ + name: MXC-USD + precision: 0.00001 + minimum_margin: None + initial_margin: None + minimum_order_size: 1 + maximum_order_size: None + margin: False + """ name: str = "MXC-USD" precision: int = 0.00001 minimum_margin: float = None @@ -8232,11 +11459,20 @@ def __call__(self): return "MXC-USD" -MXC_USD = MXC_USD() +NCT_EUR = NCT_EUR() @dataclass(slots=True, frozen=True) class NCT_EUR: + """ + name: NCT-EUR + precision: 0.00001 + minimum_margin: None + initial_margin: None + minimum_order_size: 1 + maximum_order_size: None + margin: False + """ name: str = "NCT-EUR" precision: int = 0.00001 minimum_margin: float = None @@ -8255,11 +11491,20 @@ def __call__(self): return "NCT-EUR" -NCT_EUR = NCT_EUR() +NCT_USD = NCT_USD() @dataclass(slots=True, frozen=True) class NCT_USD: + """ + name: NCT-USD + precision: 0.00001 + minimum_margin: None + initial_margin: None + minimum_order_size: 1 + maximum_order_size: None + margin: False + """ name: str = "NCT-USD" precision: int = 0.00001 minimum_margin: float = None @@ -8278,11 +11523,20 @@ def __call__(self): return "NCT-USD" -NCT_USD = NCT_USD() +NCT_USDT = NCT_USDT() @dataclass(slots=True, frozen=True) class NCT_USDT: + """ + name: NCT-USDT + precision: 0.00001 + minimum_margin: None + initial_margin: None + minimum_order_size: 1 + maximum_order_size: None + margin: False + """ name: str = "NCT-USDT" precision: int = 0.00001 minimum_margin: float = None @@ -8301,11 +11555,20 @@ def __call__(self): return "NCT-USDT" -NCT_USDT = NCT_USDT() +NEAR_USD = NEAR_USD() @dataclass(slots=True, frozen=True) class NEAR_USD: + """ + name: NEAR-USD + precision: 0.001 + minimum_margin: None + initial_margin: None + minimum_order_size: 1 + maximum_order_size: None + margin: False + """ name: str = "NEAR-USD" precision: int = 0.001 minimum_margin: float = None @@ -8324,11 +11587,20 @@ def __call__(self): return "NEAR-USD" -NEAR_USD = NEAR_USD() +NEAR_USDT = NEAR_USDT() @dataclass(slots=True, frozen=True) class NEAR_USDT: + """ + name: NEAR-USDT + precision: 0.001 + minimum_margin: None + initial_margin: None + minimum_order_size: 1 + maximum_order_size: None + margin: False + """ name: str = "NEAR-USDT" precision: int = 0.001 minimum_margin: float = None @@ -8347,11 +11619,20 @@ def __call__(self): return "NEAR-USDT" -NEAR_USDT = NEAR_USDT() +NEST_USD = NEST_USD() @dataclass(slots=True, frozen=True) class NEST_USD: + """ + name: NEST-USD + precision: 0.00001 + minimum_margin: None + initial_margin: None + minimum_order_size: 1 + maximum_order_size: None + margin: False + """ name: str = "NEST-USD" precision: int = 0.00001 minimum_margin: float = None @@ -8370,11 +11651,20 @@ def __call__(self): return "NEST-USD" -NEST_USD = NEST_USD() +NEST_USDT = NEST_USDT() @dataclass(slots=True, frozen=True) class NEST_USDT: + """ + name: NEST-USDT + precision: 0.00001 + minimum_margin: None + initial_margin: None + minimum_order_size: 1 + maximum_order_size: None + margin: False + """ name: str = "NEST-USDT" precision: int = 0.00001 minimum_margin: float = None @@ -8393,11 +11683,20 @@ def __call__(self): return "NEST-USDT" -NEST_USDT = NEST_USDT() +NKN_BTC = NKN_BTC() @dataclass(slots=True, frozen=True) class NKN_BTC: + """ + name: NKN-BTC + precision: 0.00000001 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.000016 + maximum_order_size: None + margin: False + """ name: str = "NKN-BTC" precision: int = 0.00000001 minimum_margin: float = None @@ -8416,11 +11715,20 @@ def __call__(self): return "NKN-BTC" -NKN_BTC = NKN_BTC() +NKN_EUR = NKN_EUR() @dataclass(slots=True, frozen=True) class NKN_EUR: + """ + name: NKN-EUR + precision: 0.0001 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.84 + maximum_order_size: None + margin: False + """ name: str = "NKN-EUR" precision: int = 0.0001 minimum_margin: float = None @@ -8439,11 +11747,20 @@ def __call__(self): return "NKN-EUR" -NKN_EUR = NKN_EUR() +NKN_GBP = NKN_GBP() @dataclass(slots=True, frozen=True) class NKN_GBP: + """ + name: NKN-GBP + precision: 0.0001 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.72 + maximum_order_size: None + margin: False + """ name: str = "NKN-GBP" precision: int = 0.0001 minimum_margin: float = None @@ -8462,11 +11779,20 @@ def __call__(self): return "NKN-GBP" -NKN_GBP = NKN_GBP() +NKN_USD = NKN_USD() @dataclass(slots=True, frozen=True) class NKN_USD: + """ + name: NKN-USD + precision: 0.0001 + minimum_margin: None + initial_margin: None + minimum_order_size: 1 + maximum_order_size: None + margin: False + """ name: str = "NKN-USD" precision: int = 0.0001 minimum_margin: float = None @@ -8485,11 +11811,20 @@ def __call__(self): return "NKN-USD" -NKN_USD = NKN_USD() +NMR_BTC = NMR_BTC() @dataclass(slots=True, frozen=True) class NMR_BTC: + """ + name: NMR-BTC + precision: 0.0000001 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.000016 + maximum_order_size: None + margin: False + """ name: str = "NMR-BTC" precision: int = 0.0000001 minimum_margin: float = None @@ -8508,11 +11843,20 @@ def __call__(self): return "NMR-BTC" -NMR_BTC = NMR_BTC() +NMR_EUR = NMR_EUR() @dataclass(slots=True, frozen=True) class NMR_EUR: + """ + name: NMR-EUR + precision: 0.01 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.84 + maximum_order_size: None + margin: False + """ name: str = "NMR-EUR" precision: int = 0.01 minimum_margin: float = None @@ -8531,11 +11875,20 @@ def __call__(self): return "NMR-EUR" -NMR_EUR = NMR_EUR() +NMR_GBP = NMR_GBP() @dataclass(slots=True, frozen=True) class NMR_GBP: + """ + name: NMR-GBP + precision: 0.01 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.72 + maximum_order_size: None + margin: False + """ name: str = "NMR-GBP" precision: int = 0.01 minimum_margin: float = None @@ -8554,11 +11907,20 @@ def __call__(self): return "NMR-GBP" -NMR_GBP = NMR_GBP() +NMR_USD = NMR_USD() @dataclass(slots=True, frozen=True) class NMR_USD: + """ + name: NMR-USD + precision: 0.01 + minimum_margin: None + initial_margin: None + minimum_order_size: 1 + maximum_order_size: None + margin: False + """ name: str = "NMR-USD" precision: int = 0.01 minimum_margin: float = None @@ -8577,11 +11939,20 @@ def __call__(self): return "NMR-USD" -NMR_USD = NMR_USD() +NU_BTC = NU_BTC() @dataclass(slots=True, frozen=True) class NU_BTC: + """ + name: NU-BTC + precision: 0.00000001 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.000016 + maximum_order_size: None + margin: False + """ name: str = "NU-BTC" precision: int = 0.00000001 minimum_margin: float = None @@ -8600,11 +11971,20 @@ def __call__(self): return "NU-BTC" -NU_BTC = NU_BTC() +NU_EUR = NU_EUR() @dataclass(slots=True, frozen=True) class NU_EUR: + """ + name: NU-EUR + precision: 0.0001 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.84 + maximum_order_size: None + margin: False + """ name: str = "NU-EUR" precision: int = 0.0001 minimum_margin: float = None @@ -8623,11 +12003,20 @@ def __call__(self): return "NU-EUR" -NU_EUR = NU_EUR() +NU_GBP = NU_GBP() @dataclass(slots=True, frozen=True) class NU_GBP: + """ + name: NU-GBP + precision: 0.0001 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.72 + maximum_order_size: None + margin: False + """ name: str = "NU-GBP" precision: int = 0.0001 minimum_margin: float = None @@ -8646,11 +12035,20 @@ def __call__(self): return "NU-GBP" -NU_GBP = NU_GBP() +NU_USD = NU_USD() @dataclass(slots=True, frozen=True) class NU_USD: + """ + name: NU-USD + precision: 0.0001 + minimum_margin: None + initial_margin: None + minimum_order_size: 1 + maximum_order_size: None + margin: False + """ name: str = "NU-USD" precision: int = 0.0001 minimum_margin: float = None @@ -8669,11 +12067,20 @@ def __call__(self): return "NU-USD" -NU_USD = NU_USD() +OCEAN_USD = OCEAN_USD() @dataclass(slots=True, frozen=True) class OCEAN_USD: + """ + name: OCEAN-USD + precision: 0.0001 + minimum_margin: None + initial_margin: None + minimum_order_size: 1 + maximum_order_size: None + margin: False + """ name: str = "OCEAN-USD" precision: int = 0.0001 minimum_margin: float = None @@ -8692,11 +12099,20 @@ def __call__(self): return "OCEAN-USD" -OCEAN_USD = OCEAN_USD() +OGN_BTC = OGN_BTC() @dataclass(slots=True, frozen=True) class OGN_BTC: + """ + name: OGN-BTC + precision: 0.00000001 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.000016 + maximum_order_size: None + margin: False + """ name: str = "OGN-BTC" precision: int = 0.00000001 minimum_margin: float = None @@ -8715,11 +12131,20 @@ def __call__(self): return "OGN-BTC" -OGN_BTC = OGN_BTC() +OGN_USD = OGN_USD() @dataclass(slots=True, frozen=True) class OGN_USD: + """ + name: OGN-USD + precision: 0.00001 + minimum_margin: None + initial_margin: None + minimum_order_size: 1 + maximum_order_size: None + margin: False + """ name: str = "OGN-USD" precision: int = 0.00001 minimum_margin: float = None @@ -8738,11 +12163,20 @@ def __call__(self): return "OGN-USD" -OGN_USD = OGN_USD() +OMG_BTC = OMG_BTC() @dataclass(slots=True, frozen=True) class OMG_BTC: + """ + name: OMG-BTC + precision: 0.00000001 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.000016 + maximum_order_size: None + margin: False + """ name: str = "OMG-BTC" precision: int = 0.00000001 minimum_margin: float = None @@ -8761,11 +12195,20 @@ def __call__(self): return "OMG-BTC" -OMG_BTC = OMG_BTC() +OMG_EUR = OMG_EUR() @dataclass(slots=True, frozen=True) class OMG_EUR: + """ + name: OMG-EUR + precision: 0.0001 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.84 + maximum_order_size: None + margin: False + """ name: str = "OMG-EUR" precision: int = 0.0001 minimum_margin: float = None @@ -8784,11 +12227,20 @@ def __call__(self): return "OMG-EUR" -OMG_EUR = OMG_EUR() +OMG_GBP = OMG_GBP() @dataclass(slots=True, frozen=True) class OMG_GBP: + """ + name: OMG-GBP + precision: 0.0001 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.72 + maximum_order_size: None + margin: False + """ name: str = "OMG-GBP" precision: int = 0.0001 minimum_margin: float = None @@ -8807,11 +12259,20 @@ def __call__(self): return "OMG-GBP" -OMG_GBP = OMG_GBP() +OMG_USD = OMG_USD() @dataclass(slots=True, frozen=True) class OMG_USD: + """ + name: OMG-USD + precision: 0.0001 + minimum_margin: None + initial_margin: None + minimum_order_size: 1 + maximum_order_size: None + margin: False + """ name: str = "OMG-USD" precision: int = 0.0001 minimum_margin: float = None @@ -8830,11 +12291,20 @@ def __call__(self): return "OMG-USD" -OMG_USD = OMG_USD() +OOKI_USD = OOKI_USD() @dataclass(slots=True, frozen=True) class OOKI_USD: + """ + name: OOKI-USD + precision: 0.000001 + minimum_margin: None + initial_margin: None + minimum_order_size: 1 + maximum_order_size: None + margin: False + """ name: str = "OOKI-USD" precision: int = 0.000001 minimum_margin: float = None @@ -8853,11 +12323,20 @@ def __call__(self): return "OOKI-USD" -OOKI_USD = OOKI_USD() +OP_USD = OP_USD() @dataclass(slots=True, frozen=True) class OP_USD: + """ + name: OP-USD + precision: 0.001 + minimum_margin: None + initial_margin: None + minimum_order_size: 1 + maximum_order_size: None + margin: False + """ name: str = "OP-USD" precision: int = 0.001 minimum_margin: float = None @@ -8876,11 +12355,20 @@ def __call__(self): return "OP-USD" -OP_USD = OP_USD() +OP_USDT = OP_USDT() @dataclass(slots=True, frozen=True) class OP_USDT: + """ + name: OP-USDT + precision: 0.001 + minimum_margin: None + initial_margin: None + minimum_order_size: 1 + maximum_order_size: None + margin: False + """ name: str = "OP-USDT" precision: int = 0.001 minimum_margin: float = None @@ -8899,11 +12387,20 @@ def __call__(self): return "OP-USDT" -OP_USDT = OP_USDT() +ORCA_USD = ORCA_USD() @dataclass(slots=True, frozen=True) class ORCA_USD: + """ + name: ORCA-USD + precision: 0.0001 + minimum_margin: None + initial_margin: None + minimum_order_size: 1 + maximum_order_size: None + margin: False + """ name: str = "ORCA-USD" precision: int = 0.0001 minimum_margin: float = None @@ -8922,11 +12419,20 @@ def __call__(self): return "ORCA-USD" -ORCA_USD = ORCA_USD() +ORN_BTC = ORN_BTC() @dataclass(slots=True, frozen=True) class ORN_BTC: + """ + name: ORN-BTC + precision: 0.0000001 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.000016 + maximum_order_size: None + margin: False + """ name: str = "ORN-BTC" precision: int = 0.0000001 minimum_margin: float = None @@ -8945,11 +12451,20 @@ def __call__(self): return "ORN-BTC" -ORN_BTC = ORN_BTC() +ORN_USD = ORN_USD() @dataclass(slots=True, frozen=True) class ORN_USD: + """ + name: ORN-USD + precision: 0.001 + minimum_margin: None + initial_margin: None + minimum_order_size: 1 + maximum_order_size: None + margin: False + """ name: str = "ORN-USD" precision: int = 0.001 minimum_margin: float = None @@ -8968,11 +12483,20 @@ def __call__(self): return "ORN-USD" -ORN_USD = ORN_USD() +ORN_USDT = ORN_USDT() @dataclass(slots=True, frozen=True) class ORN_USDT: + """ + name: ORN-USDT + precision: 0.001 + minimum_margin: None + initial_margin: None + minimum_order_size: 1 + maximum_order_size: None + margin: False + """ name: str = "ORN-USDT" precision: int = 0.001 minimum_margin: float = None @@ -8991,11 +12515,20 @@ def __call__(self): return "ORN-USDT" -ORN_USDT = ORN_USDT() +OXT_USD = OXT_USD() @dataclass(slots=True, frozen=True) class OXT_USD: + """ + name: OXT-USD + precision: 0.0001 + minimum_margin: None + initial_margin: None + minimum_order_size: 1 + maximum_order_size: None + margin: False + """ name: str = "OXT-USD" precision: int = 0.0001 minimum_margin: float = None @@ -9014,11 +12547,20 @@ def __call__(self): return "OXT-USD" -OXT_USD = OXT_USD() +PAX_USD = PAX_USD() @dataclass(slots=True, frozen=True) class PAX_USD: + """ + name: PAX-USD + precision: 0.0001 + minimum_margin: None + initial_margin: None + minimum_order_size: 1 + maximum_order_size: None + margin: False + """ name: str = "PAX-USD" precision: int = 0.0001 minimum_margin: float = None @@ -9037,11 +12579,20 @@ def __call__(self): return "PAX-USD" -PAX_USD = PAX_USD() +PAX_USDT = PAX_USDT() @dataclass(slots=True, frozen=True) class PAX_USDT: + """ + name: PAX-USDT + precision: 0.0001 + minimum_margin: None + initial_margin: None + minimum_order_size: 1 + maximum_order_size: None + margin: False + """ name: str = "PAX-USDT" precision: int = 0.0001 minimum_margin: float = None @@ -9060,11 +12611,20 @@ def __call__(self): return "PAX-USDT" -PAX_USDT = PAX_USDT() +PERP_EUR = PERP_EUR() @dataclass(slots=True, frozen=True) class PERP_EUR: + """ + name: PERP-EUR + precision: 0.0001 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.84 + maximum_order_size: None + margin: False + """ name: str = "PERP-EUR" precision: int = 0.0001 minimum_margin: float = None @@ -9083,11 +12643,20 @@ def __call__(self): return "PERP-EUR" -PERP_EUR = PERP_EUR() +PERP_USD = PERP_USD() @dataclass(slots=True, frozen=True) class PERP_USD: + """ + name: PERP-USD + precision: 0.0001 + minimum_margin: None + initial_margin: None + minimum_order_size: 1 + maximum_order_size: None + margin: False + """ name: str = "PERP-USD" precision: int = 0.0001 minimum_margin: float = None @@ -9106,11 +12675,20 @@ def __call__(self): return "PERP-USD" -PERP_USD = PERP_USD() +PERP_USDT = PERP_USDT() @dataclass(slots=True, frozen=True) class PERP_USDT: + """ + name: PERP-USDT + precision: 0.0001 + minimum_margin: None + initial_margin: None + minimum_order_size: 1 + maximum_order_size: None + margin: False + """ name: str = "PERP-USDT" precision: int = 0.0001 minimum_margin: float = None @@ -9129,11 +12707,20 @@ def __call__(self): return "PERP-USDT" -PERP_USDT = PERP_USDT() +PLA_USD = PLA_USD() @dataclass(slots=True, frozen=True) class PLA_USD: + """ + name: PLA-USD + precision: 0.0001 + minimum_margin: None + initial_margin: None + minimum_order_size: 1 + maximum_order_size: None + margin: False + """ name: str = "PLA-USD" precision: int = 0.0001 minimum_margin: float = None @@ -9152,11 +12739,20 @@ def __call__(self): return "PLA-USD" -PLA_USD = PLA_USD() +PLU_USD = PLU_USD() @dataclass(slots=True, frozen=True) class PLU_USD: + """ + name: PLU-USD + precision: 0.01 + minimum_margin: None + initial_margin: None + minimum_order_size: 1 + maximum_order_size: None + margin: False + """ name: str = "PLU-USD" precision: int = 0.01 minimum_margin: float = None @@ -9175,11 +12771,20 @@ def __call__(self): return "PLU-USD" -PLU_USD = PLU_USD() +PNG_USD = PNG_USD() @dataclass(slots=True, frozen=True) class PNG_USD: + """ + name: PNG-USD + precision: 0.00001 + minimum_margin: None + initial_margin: None + minimum_order_size: 1 + maximum_order_size: None + margin: False + """ name: str = "PNG-USD" precision: int = 0.00001 minimum_margin: float = None @@ -9198,11 +12803,20 @@ def __call__(self): return "PNG-USD" -PNG_USD = PNG_USD() +POLS_USD = POLS_USD() @dataclass(slots=True, frozen=True) class POLS_USD: + """ + name: POLS-USD + precision: 0.0001 + minimum_margin: None + initial_margin: None + minimum_order_size: 1 + maximum_order_size: None + margin: False + """ name: str = "POLS-USD" precision: int = 0.0001 minimum_margin: float = None @@ -9221,11 +12835,20 @@ def __call__(self): return "POLS-USD" -POLS_USD = POLS_USD() +POLS_USDT = POLS_USDT() @dataclass(slots=True, frozen=True) class POLS_USDT: + """ + name: POLS-USDT + precision: 0.0001 + minimum_margin: None + initial_margin: None + minimum_order_size: 1 + maximum_order_size: None + margin: False + """ name: str = "POLS-USDT" precision: int = 0.0001 minimum_margin: float = None @@ -9244,11 +12867,20 @@ def __call__(self): return "POLS-USDT" -POLS_USDT = POLS_USDT() +POLY_USD = POLY_USD() @dataclass(slots=True, frozen=True) class POLY_USD: + """ + name: POLY-USD + precision: 0.0001 + minimum_margin: None + initial_margin: None + minimum_order_size: 1 + maximum_order_size: None + margin: False + """ name: str = "POLY-USD" precision: int = 0.0001 minimum_margin: float = None @@ -9267,11 +12899,20 @@ def __call__(self): return "POLY-USD" -POLY_USD = POLY_USD() +POLY_USDT = POLY_USDT() @dataclass(slots=True, frozen=True) class POLY_USDT: + """ + name: POLY-USDT + precision: 0.0001 + minimum_margin: None + initial_margin: None + minimum_order_size: 1 + maximum_order_size: None + margin: False + """ name: str = "POLY-USDT" precision: int = 0.0001 minimum_margin: float = None @@ -9290,11 +12931,20 @@ def __call__(self): return "POLY-USDT" -POLY_USDT = POLY_USDT() +POND_USD = POND_USD() @dataclass(slots=True, frozen=True) class POND_USD: + """ + name: POND-USD + precision: 0.00001 + minimum_margin: None + initial_margin: None + minimum_order_size: 1 + maximum_order_size: None + margin: False + """ name: str = "POND-USD" precision: int = 0.00001 minimum_margin: float = None @@ -9313,11 +12963,20 @@ def __call__(self): return "POND-USD" -POND_USD = POND_USD() +POND_USDT = POND_USDT() @dataclass(slots=True, frozen=True) class POND_USDT: + """ + name: POND-USDT + precision: 0.00001 + minimum_margin: None + initial_margin: None + minimum_order_size: 1 + maximum_order_size: None + margin: False + """ name: str = "POND-USDT" precision: int = 0.00001 minimum_margin: float = None @@ -9336,11 +12995,20 @@ def __call__(self): return "POND-USDT" -POND_USDT = POND_USDT() +POWR_EUR = POWR_EUR() @dataclass(slots=True, frozen=True) class POWR_EUR: + """ + name: POWR-EUR + precision: 0.0001 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.84 + maximum_order_size: None + margin: False + """ name: str = "POWR-EUR" precision: int = 0.0001 minimum_margin: float = None @@ -9359,11 +13027,20 @@ def __call__(self): return "POWR-EUR" -POWR_EUR = POWR_EUR() +POWR_USD = POWR_USD() @dataclass(slots=True, frozen=True) class POWR_USD: + """ + name: POWR-USD + precision: 0.0001 + minimum_margin: None + initial_margin: None + minimum_order_size: 1 + maximum_order_size: None + margin: False + """ name: str = "POWR-USD" precision: int = 0.0001 minimum_margin: float = None @@ -9382,11 +13059,20 @@ def __call__(self): return "POWR-USD" -POWR_USD = POWR_USD() +POWR_USDT = POWR_USDT() @dataclass(slots=True, frozen=True) class POWR_USDT: + """ + name: POWR-USDT + precision: 0.0001 + minimum_margin: None + initial_margin: None + minimum_order_size: 1 + maximum_order_size: None + margin: False + """ name: str = "POWR-USDT" precision: int = 0.0001 minimum_margin: float = None @@ -9405,11 +13091,20 @@ def __call__(self): return "POWR-USDT" -POWR_USDT = POWR_USDT() +PRO_USD = PRO_USD() @dataclass(slots=True, frozen=True) class PRO_USD: + """ + name: PRO-USD + precision: 0.0001 + minimum_margin: None + initial_margin: None + minimum_order_size: 1 + maximum_order_size: None + margin: False + """ name: str = "PRO-USD" precision: int = 0.0001 minimum_margin: float = None @@ -9428,11 +13123,20 @@ def __call__(self): return "PRO-USD" -PRO_USD = PRO_USD() +PRQ_USD = PRQ_USD() @dataclass(slots=True, frozen=True) class PRQ_USD: + """ + name: PRQ-USD + precision: 0.0001 + minimum_margin: None + initial_margin: None + minimum_order_size: 1 + maximum_order_size: None + margin: False + """ name: str = "PRQ-USD" precision: int = 0.0001 minimum_margin: float = None @@ -9451,11 +13155,20 @@ def __call__(self): return "PRQ-USD" -PRQ_USD = PRQ_USD() +PRQ_USDT = PRQ_USDT() @dataclass(slots=True, frozen=True) class PRQ_USDT: + """ + name: PRQ-USDT + precision: 0.0001 + minimum_margin: None + initial_margin: None + minimum_order_size: 1 + maximum_order_size: None + margin: False + """ name: str = "PRQ-USDT" precision: int = 0.0001 minimum_margin: float = None @@ -9474,11 +13187,20 @@ def __call__(self): return "PRQ-USDT" -PRQ_USDT = PRQ_USDT() +PUNDIX_USD = PUNDIX_USD() @dataclass(slots=True, frozen=True) class PUNDIX_USD: + """ + name: PUNDIX-USD + precision: 0.0001 + minimum_margin: None + initial_margin: None + minimum_order_size: 1 + maximum_order_size: None + margin: False + """ name: str = "PUNDIX-USD" precision: int = 0.0001 minimum_margin: float = None @@ -9497,11 +13219,20 @@ def __call__(self): return "PUNDIX-USD" -PUNDIX_USD = PUNDIX_USD() +PYR_USD = PYR_USD() @dataclass(slots=True, frozen=True) class PYR_USD: + """ + name: PYR-USD + precision: 0.001 + minimum_margin: None + initial_margin: None + minimum_order_size: 1 + maximum_order_size: None + margin: False + """ name: str = "PYR-USD" precision: int = 0.001 minimum_margin: float = None @@ -9520,11 +13251,20 @@ def __call__(self): return "PYR-USD" -PYR_USD = PYR_USD() +QI_USD = QI_USD() @dataclass(slots=True, frozen=True) class QI_USD: + """ + name: QI-USD + precision: 0.000001 + minimum_margin: None + initial_margin: None + minimum_order_size: 1 + maximum_order_size: None + margin: False + """ name: str = "QI-USD" precision: int = 0.000001 minimum_margin: float = None @@ -9543,11 +13283,20 @@ def __call__(self): return "QI-USD" -QI_USD = QI_USD() +QNT_USD = QNT_USD() @dataclass(slots=True, frozen=True) class QNT_USD: + """ + name: QNT-USD + precision: 0.01 + minimum_margin: None + initial_margin: None + minimum_order_size: 1 + maximum_order_size: None + margin: False + """ name: str = "QNT-USD" precision: int = 0.01 minimum_margin: float = None @@ -9566,11 +13315,20 @@ def __call__(self): return "QNT-USD" -QNT_USD = QNT_USD() +QNT_USDT = QNT_USDT() @dataclass(slots=True, frozen=True) class QNT_USDT: + """ + name: QNT-USDT + precision: 0.01 + minimum_margin: None + initial_margin: None + minimum_order_size: 1 + maximum_order_size: None + margin: False + """ name: str = "QNT-USDT" precision: int = 0.01 minimum_margin: float = None @@ -9589,11 +13347,20 @@ def __call__(self): return "QNT-USDT" -QNT_USDT = QNT_USDT() +QSP_USD = QSP_USD() @dataclass(slots=True, frozen=True) class QSP_USD: + """ + name: QSP-USD + precision: 0.00001 + minimum_margin: None + initial_margin: None + minimum_order_size: 1 + maximum_order_size: None + margin: False + """ name: str = "QSP-USD" precision: int = 0.00001 minimum_margin: float = None @@ -9612,11 +13379,20 @@ def __call__(self): return "QSP-USD" -QSP_USD = QSP_USD() +QSP_USDT = QSP_USDT() @dataclass(slots=True, frozen=True) class QSP_USDT: + """ + name: QSP-USDT + precision: 0.00001 + minimum_margin: None + initial_margin: None + minimum_order_size: 1 + maximum_order_size: None + margin: False + """ name: str = "QSP-USDT" precision: int = 0.00001 minimum_margin: float = None @@ -9635,11 +13411,20 @@ def __call__(self): return "QSP-USDT" -QSP_USDT = QSP_USDT() +QUICK_USD = QUICK_USD() @dataclass(slots=True, frozen=True) class QUICK_USD: + """ + name: QUICK-USD + precision: 0.01 + minimum_margin: None + initial_margin: None + minimum_order_size: 1 + maximum_order_size: None + margin: False + """ name: str = "QUICK-USD" precision: int = 0.01 minimum_margin: float = None @@ -9658,11 +13443,20 @@ def __call__(self): return "QUICK-USD" -QUICK_USD = QUICK_USD() +RAD_BTC = RAD_BTC() @dataclass(slots=True, frozen=True) class RAD_BTC: + """ + name: RAD-BTC + precision: 0.0000001 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.000016 + maximum_order_size: None + margin: False + """ name: str = "RAD-BTC" precision: int = 0.0000001 minimum_margin: float = None @@ -9681,11 +13475,20 @@ def __call__(self): return "RAD-BTC" -RAD_BTC = RAD_BTC() +RAD_EUR = RAD_EUR() @dataclass(slots=True, frozen=True) class RAD_EUR: + """ + name: RAD-EUR + precision: 0.001 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.84 + maximum_order_size: None + margin: False + """ name: str = "RAD-EUR" precision: int = 0.001 minimum_margin: float = None @@ -9704,11 +13507,20 @@ def __call__(self): return "RAD-EUR" -RAD_EUR = RAD_EUR() +RAD_GBP = RAD_GBP() @dataclass(slots=True, frozen=True) class RAD_GBP: + """ + name: RAD-GBP + precision: 0.001 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.72 + maximum_order_size: None + margin: False + """ name: str = "RAD-GBP" precision: int = 0.001 minimum_margin: float = None @@ -9727,11 +13539,20 @@ def __call__(self): return "RAD-GBP" -RAD_GBP = RAD_GBP() +RAD_USD = RAD_USD() @dataclass(slots=True, frozen=True) class RAD_USD: + """ + name: RAD-USD + precision: 0.01 + minimum_margin: None + initial_margin: None + minimum_order_size: 1 + maximum_order_size: None + margin: False + """ name: str = "RAD-USD" precision: int = 0.01 minimum_margin: float = None @@ -9750,11 +13571,20 @@ def __call__(self): return "RAD-USD" -RAD_USD = RAD_USD() +RAD_USDT = RAD_USDT() @dataclass(slots=True, frozen=True) class RAD_USDT: + """ + name: RAD-USDT + precision: 0.01 + minimum_margin: None + initial_margin: None + minimum_order_size: 1 + maximum_order_size: None + margin: False + """ name: str = "RAD-USDT" precision: int = 0.01 minimum_margin: float = None @@ -9773,11 +13603,20 @@ def __call__(self): return "RAD-USDT" -RAD_USDT = RAD_USDT() +RAI_USD = RAI_USD() @dataclass(slots=True, frozen=True) class RAI_USD: + """ + name: RAI-USD + precision: 0.01 + minimum_margin: None + initial_margin: None + minimum_order_size: 1 + maximum_order_size: None + margin: False + """ name: str = "RAI-USD" precision: int = 0.01 minimum_margin: float = None @@ -9796,11 +13635,20 @@ def __call__(self): return "RAI-USD" -RAI_USD = RAI_USD() +RARE_USD = RARE_USD() @dataclass(slots=True, frozen=True) class RARE_USD: + """ + name: RARE-USD + precision: 0.0001 + minimum_margin: None + initial_margin: None + minimum_order_size: 1 + maximum_order_size: None + margin: False + """ name: str = "RARE-USD" precision: int = 0.0001 minimum_margin: float = None @@ -9819,11 +13667,20 @@ def __call__(self): return "RARE-USD" -RARE_USD = RARE_USD() +RARI_USD = RARI_USD() @dataclass(slots=True, frozen=True) class RARI_USD: + """ + name: RARI-USD + precision: 0.01 + minimum_margin: None + initial_margin: None + minimum_order_size: 1 + maximum_order_size: None + margin: False + """ name: str = "RARI-USD" precision: int = 0.01 minimum_margin: float = None @@ -9842,11 +13699,20 @@ def __call__(self): return "RARI-USD" -RARI_USD = RARI_USD() +RBN_USD = RBN_USD() @dataclass(slots=True, frozen=True) class RBN_USD: + """ + name: RBN-USD + precision: 0.00001 + minimum_margin: None + initial_margin: None + minimum_order_size: 1 + maximum_order_size: None + margin: False + """ name: str = "RBN-USD" precision: int = 0.00001 minimum_margin: float = None @@ -9865,11 +13731,20 @@ def __call__(self): return "RBN-USD" -RBN_USD = RBN_USD() +REN_BTC = REN_BTC() @dataclass(slots=True, frozen=True) class REN_BTC: + """ + name: REN-BTC + precision: 0.00000001 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.000016 + maximum_order_size: None + margin: False + """ name: str = "REN-BTC" precision: int = 0.00000001 minimum_margin: float = None @@ -9888,11 +13763,20 @@ def __call__(self): return "REN-BTC" -REN_BTC = REN_BTC() +REN_USD = REN_USD() @dataclass(slots=True, frozen=True) class REN_USD: + """ + name: REN-USD + precision: 0.0001 + minimum_margin: None + initial_margin: None + minimum_order_size: 1 + maximum_order_size: None + margin: False + """ name: str = "REN-USD" precision: int = 0.0001 minimum_margin: float = None @@ -9911,11 +13795,20 @@ def __call__(self): return "REN-USD" -REN_USD = REN_USD() +REP_BTC = REP_BTC() @dataclass(slots=True, frozen=True) class REP_BTC: + """ + name: REP-BTC + precision: 0.0000001 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.000016 + maximum_order_size: None + margin: False + """ name: str = "REP-BTC" precision: int = 0.0000001 minimum_margin: float = None @@ -9934,11 +13827,20 @@ def __call__(self): return "REP-BTC" -REP_BTC = REP_BTC() +REP_USD = REP_USD() @dataclass(slots=True, frozen=True) class REP_USD: + """ + name: REP-USD + precision: 0.01 + minimum_margin: None + initial_margin: None + minimum_order_size: 1 + maximum_order_size: None + margin: False + """ name: str = "REP-USD" precision: int = 0.01 minimum_margin: float = None @@ -9957,11 +13859,20 @@ def __call__(self): return "REP-USD" -REP_USD = REP_USD() +REQ_BTC = REQ_BTC() @dataclass(slots=True, frozen=True) class REQ_BTC: + """ + name: REQ-BTC + precision: 0.00000001 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.000016 + maximum_order_size: None + margin: False + """ name: str = "REQ-BTC" precision: int = 0.00000001 minimum_margin: float = None @@ -9980,11 +13891,20 @@ def __call__(self): return "REQ-BTC" -REQ_BTC = REQ_BTC() +REQ_EUR = REQ_EUR() @dataclass(slots=True, frozen=True) class REQ_EUR: + """ + name: REQ-EUR + precision: 0.00001 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.84 + maximum_order_size: None + margin: False + """ name: str = "REQ-EUR" precision: int = 0.00001 minimum_margin: float = None @@ -10003,11 +13923,20 @@ def __call__(self): return "REQ-EUR" -REQ_EUR = REQ_EUR() +REQ_GBP = REQ_GBP() @dataclass(slots=True, frozen=True) class REQ_GBP: + """ + name: REQ-GBP + precision: 0.0001 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.72 + maximum_order_size: None + margin: False + """ name: str = "REQ-GBP" precision: int = 0.0001 minimum_margin: float = None @@ -10026,11 +13955,20 @@ def __call__(self): return "REQ-GBP" -REQ_GBP = REQ_GBP() +REQ_USD = REQ_USD() @dataclass(slots=True, frozen=True) class REQ_USD: + """ + name: REQ-USD + precision: 0.0001 + minimum_margin: None + initial_margin: None + minimum_order_size: 1 + maximum_order_size: None + margin: False + """ name: str = "REQ-USD" precision: int = 0.0001 minimum_margin: float = None @@ -10049,11 +13987,20 @@ def __call__(self): return "REQ-USD" -REQ_USD = REQ_USD() +REQ_USDT = REQ_USDT() @dataclass(slots=True, frozen=True) class REQ_USDT: + """ + name: REQ-USDT + precision: 0.0001 + minimum_margin: None + initial_margin: None + minimum_order_size: 1 + maximum_order_size: None + margin: False + """ name: str = "REQ-USDT" precision: int = 0.0001 minimum_margin: float = None @@ -10072,11 +14019,20 @@ def __call__(self): return "REQ-USDT" -REQ_USDT = REQ_USDT() +RGT_USD = RGT_USD() @dataclass(slots=True, frozen=True) class RGT_USD: + """ + name: RGT-USD + precision: 0.01 + minimum_margin: None + initial_margin: None + minimum_order_size: 1 + maximum_order_size: None + margin: False + """ name: str = "RGT-USD" precision: int = 0.01 minimum_margin: float = None @@ -10095,11 +14051,20 @@ def __call__(self): return "RGT-USD" -RGT_USD = RGT_USD() +RLC_BTC = RLC_BTC() @dataclass(slots=True, frozen=True) class RLC_BTC: + """ + name: RLC-BTC + precision: 0.0000001 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.000016 + maximum_order_size: None + margin: False + """ name: str = "RLC-BTC" precision: int = 0.0000001 minimum_margin: float = None @@ -10118,11 +14083,20 @@ def __call__(self): return "RLC-BTC" -RLC_BTC = RLC_BTC() +RLC_USD = RLC_USD() @dataclass(slots=True, frozen=True) class RLC_USD: + """ + name: RLC-USD + precision: 0.0001 + minimum_margin: None + initial_margin: None + minimum_order_size: 1 + maximum_order_size: None + margin: False + """ name: str = "RLC-USD" precision: int = 0.0001 minimum_margin: float = None @@ -10141,11 +14115,20 @@ def __call__(self): return "RLC-USD" -RLC_USD = RLC_USD() +RLY_EUR = RLY_EUR() @dataclass(slots=True, frozen=True) class RLY_EUR: + """ + name: RLY-EUR + precision: 0.0001 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.84 + maximum_order_size: None + margin: False + """ name: str = "RLY-EUR" precision: int = 0.0001 minimum_margin: float = None @@ -10164,11 +14147,20 @@ def __call__(self): return "RLY-EUR" -RLY_EUR = RLY_EUR() +RLY_GBP = RLY_GBP() @dataclass(slots=True, frozen=True) class RLY_GBP: + """ + name: RLY-GBP + precision: 0.0001 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.72 + maximum_order_size: None + margin: False + """ name: str = "RLY-GBP" precision: int = 0.0001 minimum_margin: float = None @@ -10187,11 +14179,20 @@ def __call__(self): return "RLY-GBP" -RLY_GBP = RLY_GBP() +RLY_USD = RLY_USD() @dataclass(slots=True, frozen=True) class RLY_USD: + """ + name: RLY-USD + precision: 0.0001 + minimum_margin: None + initial_margin: None + minimum_order_size: 1 + maximum_order_size: None + margin: False + """ name: str = "RLY-USD" precision: int = 0.0001 minimum_margin: float = None @@ -10210,11 +14211,20 @@ def __call__(self): return "RLY-USD" -RLY_USD = RLY_USD() +RLY_USDT = RLY_USDT() @dataclass(slots=True, frozen=True) class RLY_USDT: + """ + name: RLY-USDT + precision: 0.0001 + minimum_margin: None + initial_margin: None + minimum_order_size: 1 + maximum_order_size: None + margin: False + """ name: str = "RLY-USDT" precision: int = 0.0001 minimum_margin: float = None @@ -10233,11 +14243,20 @@ def __call__(self): return "RLY-USDT" -RLY_USDT = RLY_USDT() +RNDR_EUR = RNDR_EUR() @dataclass(slots=True, frozen=True) class RNDR_EUR: + """ + name: RNDR-EUR + precision: 0.0001 + minimum_margin: None + initial_margin: None + minimum_order_size: 1 + maximum_order_size: None + margin: False + """ name: str = "RNDR-EUR" precision: int = 0.0001 minimum_margin: float = None @@ -10256,11 +14275,20 @@ def __call__(self): return "RNDR-EUR" -RNDR_EUR = RNDR_EUR() +RNDR_USD = RNDR_USD() @dataclass(slots=True, frozen=True) class RNDR_USD: + """ + name: RNDR-USD + precision: 0.0001 + minimum_margin: None + initial_margin: None + minimum_order_size: 1 + maximum_order_size: None + margin: False + """ name: str = "RNDR-USD" precision: int = 0.0001 minimum_margin: float = None @@ -10279,11 +14307,20 @@ def __call__(self): return "RNDR-USD" -RNDR_USD = RNDR_USD() +RNDR_USDT = RNDR_USDT() @dataclass(slots=True, frozen=True) class RNDR_USDT: + """ + name: RNDR-USDT + precision: 0.0001 + minimum_margin: None + initial_margin: None + minimum_order_size: 1 + maximum_order_size: None + margin: False + """ name: str = "RNDR-USDT" precision: int = 0.0001 minimum_margin: float = None @@ -10302,11 +14339,20 @@ def __call__(self): return "RNDR-USDT" -RNDR_USDT = RNDR_USDT() +ROSE_USD = ROSE_USD() @dataclass(slots=True, frozen=True) class ROSE_USD: + """ + name: ROSE-USD + precision: 0.00001 + minimum_margin: None + initial_margin: None + minimum_order_size: 1 + maximum_order_size: None + margin: False + """ name: str = "ROSE-USD" precision: int = 0.00001 minimum_margin: float = None @@ -10325,11 +14371,20 @@ def __call__(self): return "ROSE-USD" -ROSE_USD = ROSE_USD() +ROSE_USDT = ROSE_USDT() @dataclass(slots=True, frozen=True) class ROSE_USDT: + """ + name: ROSE-USDT + precision: 0.0001 + minimum_margin: None + initial_margin: None + minimum_order_size: 1 + maximum_order_size: None + margin: False + """ name: str = "ROSE-USDT" precision: int = 0.0001 minimum_margin: float = None @@ -10348,11 +14403,20 @@ def __call__(self): return "ROSE-USDT" -ROSE_USDT = ROSE_USDT() +RPL_USD = RPL_USD() @dataclass(slots=True, frozen=True) class RPL_USD: + """ + name: RPL-USD + precision: 0.01 + minimum_margin: None + initial_margin: None + minimum_order_size: 1 + maximum_order_size: None + margin: False + """ name: str = "RPL-USD" precision: int = 0.01 minimum_margin: float = None @@ -10371,11 +14435,20 @@ def __call__(self): return "RPL-USD" -RPL_USD = RPL_USD() +SAND_USD = SAND_USD() @dataclass(slots=True, frozen=True) class SAND_USD: + """ + name: SAND-USD + precision: 0.0001 + minimum_margin: None + initial_margin: None + minimum_order_size: 1 + maximum_order_size: None + margin: False + """ name: str = "SAND-USD" precision: int = 0.0001 minimum_margin: float = None @@ -10394,11 +14467,20 @@ def __call__(self): return "SAND-USD" -SAND_USD = SAND_USD() +SAND_USDT = SAND_USDT() @dataclass(slots=True, frozen=True) class SAND_USDT: + """ + name: SAND-USDT + precision: 0.001 + minimum_margin: None + initial_margin: None + minimum_order_size: 1 + maximum_order_size: None + margin: False + """ name: str = "SAND-USDT" precision: int = 0.001 minimum_margin: float = None @@ -10417,11 +14499,20 @@ def __call__(self): return "SAND-USDT" -SAND_USDT = SAND_USDT() +SHIB_EUR = SHIB_EUR() @dataclass(slots=True, frozen=True) class SHIB_EUR: + """ + name: SHIB-EUR + precision: 0.00000001 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.84 + maximum_order_size: None + margin: False + """ name: str = "SHIB-EUR" precision: int = 0.00000001 minimum_margin: float = None @@ -10440,11 +14531,20 @@ def __call__(self): return "SHIB-EUR" -SHIB_EUR = SHIB_EUR() +SHIB_GBP = SHIB_GBP() @dataclass(slots=True, frozen=True) class SHIB_GBP: + """ + name: SHIB-GBP + precision: 0.00000001 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.72 + maximum_order_size: None + margin: False + """ name: str = "SHIB-GBP" precision: int = 0.00000001 minimum_margin: float = None @@ -10463,11 +14563,20 @@ def __call__(self): return "SHIB-GBP" -SHIB_GBP = SHIB_GBP() +SHIB_USD = SHIB_USD() @dataclass(slots=True, frozen=True) class SHIB_USD: + """ + name: SHIB-USD + precision: 0.00000001 + minimum_margin: None + initial_margin: None + minimum_order_size: 1 + maximum_order_size: None + margin: False + """ name: str = "SHIB-USD" precision: int = 0.00000001 minimum_margin: float = None @@ -10486,11 +14595,20 @@ def __call__(self): return "SHIB-USD" -SHIB_USD = SHIB_USD() +SHIB_USDT = SHIB_USDT() @dataclass(slots=True, frozen=True) class SHIB_USDT: + """ + name: SHIB-USDT + precision: 0.0000001 + minimum_margin: None + initial_margin: None + minimum_order_size: 1 + maximum_order_size: None + margin: False + """ name: str = "SHIB-USDT" precision: int = 0.0000001 minimum_margin: float = None @@ -10509,11 +14627,20 @@ def __call__(self): return "SHIB-USDT" -SHIB_USDT = SHIB_USDT() +SHPING_EUR = SHPING_EUR() @dataclass(slots=True, frozen=True) class SHPING_EUR: + """ + name: SHPING-EUR + precision: 0.000001 + minimum_margin: None + initial_margin: None + minimum_order_size: 1 + maximum_order_size: None + margin: False + """ name: str = "SHPING-EUR" precision: int = 0.000001 minimum_margin: float = None @@ -10532,11 +14659,20 @@ def __call__(self): return "SHPING-EUR" -SHPING_EUR = SHPING_EUR() +SHPING_USD = SHPING_USD() @dataclass(slots=True, frozen=True) class SHPING_USD: + """ + name: SHPING-USD + precision: 0.000001 + minimum_margin: None + initial_margin: None + minimum_order_size: 1 + maximum_order_size: None + margin: False + """ name: str = "SHPING-USD" precision: int = 0.000001 minimum_margin: float = None @@ -10555,11 +14691,20 @@ def __call__(self): return "SHPING-USD" -SHPING_USD = SHPING_USD() +SHPING_USDT = SHPING_USDT() @dataclass(slots=True, frozen=True) class SHPING_USDT: + """ + name: SHPING-USDT + precision: 0.000001 + minimum_margin: None + initial_margin: None + minimum_order_size: 1 + maximum_order_size: None + margin: False + """ name: str = "SHPING-USDT" precision: int = 0.000001 minimum_margin: float = None @@ -10578,11 +14723,20 @@ def __call__(self): return "SHPING-USDT" -SHPING_USDT = SHPING_USDT() +SKL_BTC = SKL_BTC() @dataclass(slots=True, frozen=True) class SKL_BTC: + """ + name: SKL-BTC + precision: 0.00000001 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.000016 + maximum_order_size: None + margin: False + """ name: str = "SKL-BTC" precision: int = 0.00000001 minimum_margin: float = None @@ -10601,11 +14755,20 @@ def __call__(self): return "SKL-BTC" -SKL_BTC = SKL_BTC() +SKL_EUR = SKL_EUR() @dataclass(slots=True, frozen=True) class SKL_EUR: + """ + name: SKL-EUR + precision: 0.0001 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.84 + maximum_order_size: None + margin: False + """ name: str = "SKL-EUR" precision: int = 0.0001 minimum_margin: float = None @@ -10624,11 +14787,20 @@ def __call__(self): return "SKL-EUR" -SKL_EUR = SKL_EUR() +SKL_GBP = SKL_GBP() @dataclass(slots=True, frozen=True) class SKL_GBP: + """ + name: SKL-GBP + precision: 0.0001 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.72 + maximum_order_size: None + margin: False + """ name: str = "SKL-GBP" precision: int = 0.0001 minimum_margin: float = None @@ -10647,11 +14819,20 @@ def __call__(self): return "SKL-GBP" -SKL_GBP = SKL_GBP() +SKL_USD = SKL_USD() @dataclass(slots=True, frozen=True) class SKL_USD: + """ + name: SKL-USD + precision: 0.0001 + minimum_margin: None + initial_margin: None + minimum_order_size: 1 + maximum_order_size: None + margin: False + """ name: str = "SKL-USD" precision: int = 0.0001 minimum_margin: float = None @@ -10670,11 +14851,20 @@ def __call__(self): return "SKL-USD" -SKL_USD = SKL_USD() +SNT_USD = SNT_USD() @dataclass(slots=True, frozen=True) class SNT_USD: + """ + name: SNT-USD + precision: 0.00001 + minimum_margin: None + initial_margin: None + minimum_order_size: 1 + maximum_order_size: None + margin: False + """ name: str = "SNT-USD" precision: int = 0.00001 minimum_margin: float = None @@ -10693,11 +14883,20 @@ def __call__(self): return "SNT-USD" -SNT_USD = SNT_USD() +SNX_BTC = SNX_BTC() @dataclass(slots=True, frozen=True) class SNX_BTC: + """ + name: SNX-BTC + precision: 0.0000001 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.000016 + maximum_order_size: None + margin: False + """ name: str = "SNX-BTC" precision: int = 0.0000001 minimum_margin: float = None @@ -10716,11 +14915,20 @@ def __call__(self): return "SNX-BTC" -SNX_BTC = SNX_BTC() +SNX_EUR = SNX_EUR() @dataclass(slots=True, frozen=True) class SNX_EUR: + """ + name: SNX-EUR + precision: 0.001 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.84 + maximum_order_size: None + margin: False + """ name: str = "SNX-EUR" precision: int = 0.001 minimum_margin: float = None @@ -10739,11 +14947,20 @@ def __call__(self): return "SNX-EUR" -SNX_EUR = SNX_EUR() +SNX_GBP = SNX_GBP() @dataclass(slots=True, frozen=True) class SNX_GBP: + """ + name: SNX-GBP + precision: 0.001 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.72 + maximum_order_size: None + margin: False + """ name: str = "SNX-GBP" precision: int = 0.001 minimum_margin: float = None @@ -10762,11 +14979,20 @@ def __call__(self): return "SNX-GBP" -SNX_GBP = SNX_GBP() +SNX_USD = SNX_USD() @dataclass(slots=True, frozen=True) class SNX_USD: + """ + name: SNX-USD + precision: 0.001 + minimum_margin: None + initial_margin: None + minimum_order_size: 1 + maximum_order_size: None + margin: False + """ name: str = "SNX-USD" precision: int = 0.001 minimum_margin: float = None @@ -10785,11 +15011,20 @@ def __call__(self): return "SNX-USD" -SNX_USD = SNX_USD() +SOL_BTC = SOL_BTC() @dataclass(slots=True, frozen=True) class SOL_BTC: + """ + name: SOL-BTC + precision: 0.0000001 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.000016 + maximum_order_size: None + margin: False + """ name: str = "SOL-BTC" precision: int = 0.0000001 minimum_margin: float = None @@ -10808,11 +15043,20 @@ def __call__(self): return "SOL-BTC" -SOL_BTC = SOL_BTC() +SOL_ETH = SOL_ETH() @dataclass(slots=True, frozen=True) class SOL_ETH: + """ + name: SOL-ETH + precision: 0.00001 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.00022 + maximum_order_size: None + margin: False + """ name: str = "SOL-ETH" precision: int = 0.00001 minimum_margin: float = None @@ -10831,11 +15075,20 @@ def __call__(self): return "SOL-ETH" -SOL_ETH = SOL_ETH() +SOL_EUR = SOL_EUR() @dataclass(slots=True, frozen=True) class SOL_EUR: + """ + name: SOL-EUR + precision: 0.01 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.84 + maximum_order_size: None + margin: False + """ name: str = "SOL-EUR" precision: int = 0.01 minimum_margin: float = None @@ -10854,11 +15107,20 @@ def __call__(self): return "SOL-EUR" -SOL_EUR = SOL_EUR() +SOL_GBP = SOL_GBP() @dataclass(slots=True, frozen=True) class SOL_GBP: + """ + name: SOL-GBP + precision: 0.01 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.72 + maximum_order_size: None + margin: False + """ name: str = "SOL-GBP" precision: int = 0.01 minimum_margin: float = None @@ -10877,11 +15139,20 @@ def __call__(self): return "SOL-GBP" -SOL_GBP = SOL_GBP() +SOL_USD = SOL_USD() @dataclass(slots=True, frozen=True) class SOL_USD: + """ + name: SOL-USD + precision: 0.01 + minimum_margin: None + initial_margin: None + minimum_order_size: 1 + maximum_order_size: None + margin: False + """ name: str = "SOL-USD" precision: int = 0.01 minimum_margin: float = None @@ -10900,11 +15171,20 @@ def __call__(self): return "SOL-USD" -SOL_USD = SOL_USD() +SOL_USDT = SOL_USDT() @dataclass(slots=True, frozen=True) class SOL_USDT: + """ + name: SOL-USDT + precision: 0.01 + minimum_margin: None + initial_margin: None + minimum_order_size: 1 + maximum_order_size: None + margin: False + """ name: str = "SOL-USDT" precision: int = 0.01 minimum_margin: float = None @@ -10923,11 +15203,20 @@ def __call__(self): return "SOL-USDT" -SOL_USDT = SOL_USDT() +SPELL_USD = SPELL_USD() @dataclass(slots=True, frozen=True) class SPELL_USD: + """ + name: SPELL-USD + precision: 0.0000001 + minimum_margin: None + initial_margin: None + minimum_order_size: 1 + maximum_order_size: None + margin: False + """ name: str = "SPELL-USD" precision: int = 0.0000001 minimum_margin: float = None @@ -10946,11 +15235,20 @@ def __call__(self): return "SPELL-USD" -SPELL_USD = SPELL_USD() +SPELL_USDT = SPELL_USDT() @dataclass(slots=True, frozen=True) class SPELL_USDT: + """ + name: SPELL-USDT + precision: 0.0000001 + minimum_margin: None + initial_margin: None + minimum_order_size: 1 + maximum_order_size: None + margin: False + """ name: str = "SPELL-USDT" precision: int = 0.0000001 minimum_margin: float = None @@ -10969,11 +15267,20 @@ def __call__(self): return "SPELL-USDT" -SPELL_USDT = SPELL_USDT() +STG_USD = STG_USD() @dataclass(slots=True, frozen=True) class STG_USD: + """ + name: STG-USD + precision: 0.0001 + minimum_margin: None + initial_margin: None + minimum_order_size: 1 + maximum_order_size: None + margin: False + """ name: str = "STG-USD" precision: int = 0.0001 minimum_margin: float = None @@ -10992,11 +15299,20 @@ def __call__(self): return "STG-USD" -STG_USD = STG_USD() +STG_USDT = STG_USDT() @dataclass(slots=True, frozen=True) class STG_USDT: + """ + name: STG-USDT + precision: 0.0001 + minimum_margin: None + initial_margin: None + minimum_order_size: 1 + maximum_order_size: None + margin: False + """ name: str = "STG-USDT" precision: int = 0.0001 minimum_margin: float = None @@ -11015,11 +15331,20 @@ def __call__(self): return "STG-USDT" -STG_USDT = STG_USDT() +STORJ_BTC = STORJ_BTC() @dataclass(slots=True, frozen=True) class STORJ_BTC: + """ + name: STORJ-BTC + precision: 0.00000001 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.000016 + maximum_order_size: None + margin: False + """ name: str = "STORJ-BTC" precision: int = 0.00000001 minimum_margin: float = None @@ -11038,11 +15363,20 @@ def __call__(self): return "STORJ-BTC" -STORJ_BTC = STORJ_BTC() +STORJ_USD = STORJ_USD() @dataclass(slots=True, frozen=True) class STORJ_USD: + """ + name: STORJ-USD + precision: 0.0001 + minimum_margin: None + initial_margin: None + minimum_order_size: 1 + maximum_order_size: None + margin: False + """ name: str = "STORJ-USD" precision: int = 0.0001 minimum_margin: float = None @@ -11061,11 +15395,20 @@ def __call__(self): return "STORJ-USD" -STORJ_USD = STORJ_USD() +STX_USD = STX_USD() @dataclass(slots=True, frozen=True) class STX_USD: + """ + name: STX-USD + precision: 0.0001 + minimum_margin: None + initial_margin: None + minimum_order_size: 1 + maximum_order_size: None + margin: False + """ name: str = "STX-USD" precision: int = 0.0001 minimum_margin: float = None @@ -11084,11 +15427,20 @@ def __call__(self): return "STX-USD" -STX_USD = STX_USD() +STX_USDT = STX_USDT() @dataclass(slots=True, frozen=True) class STX_USDT: + """ + name: STX-USDT + precision: 0.0001 + minimum_margin: None + initial_margin: None + minimum_order_size: 1 + maximum_order_size: None + margin: False + """ name: str = "STX-USDT" precision: int = 0.0001 minimum_margin: float = None @@ -11107,11 +15459,20 @@ def __call__(self): return "STX-USDT" -STX_USDT = STX_USDT() +SUKU_EUR = SUKU_EUR() @dataclass(slots=True, frozen=True) class SUKU_EUR: + """ + name: SUKU-EUR + precision: 0.0001 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.84 + maximum_order_size: None + margin: False + """ name: str = "SUKU-EUR" precision: int = 0.0001 minimum_margin: float = None @@ -11130,11 +15491,20 @@ def __call__(self): return "SUKU-EUR" -SUKU_EUR = SUKU_EUR() +SUKU_USD = SUKU_USD() @dataclass(slots=True, frozen=True) class SUKU_USD: + """ + name: SUKU-USD + precision: 0.0001 + minimum_margin: None + initial_margin: None + minimum_order_size: 1 + maximum_order_size: None + margin: False + """ name: str = "SUKU-USD" precision: int = 0.0001 minimum_margin: float = None @@ -11153,11 +15523,20 @@ def __call__(self): return "SUKU-USD" -SUKU_USD = SUKU_USD() +SUKU_USDT = SUKU_USDT() @dataclass(slots=True, frozen=True) class SUKU_USDT: + """ + name: SUKU-USDT + precision: 0.0001 + minimum_margin: None + initial_margin: None + minimum_order_size: 1 + maximum_order_size: None + margin: False + """ name: str = "SUKU-USDT" precision: int = 0.0001 minimum_margin: float = None @@ -11176,11 +15555,20 @@ def __call__(self): return "SUKU-USDT" -SUKU_USDT = SUKU_USDT() +SUPER_USD = SUPER_USD() @dataclass(slots=True, frozen=True) class SUPER_USD: + """ + name: SUPER-USD + precision: 0.00001 + minimum_margin: None + initial_margin: None + minimum_order_size: 1 + maximum_order_size: None + margin: False + """ name: str = "SUPER-USD" precision: int = 0.00001 minimum_margin: float = None @@ -11199,11 +15587,20 @@ def __call__(self): return "SUPER-USD" -SUPER_USD = SUPER_USD() +SUPER_USDT = SUPER_USDT() @dataclass(slots=True, frozen=True) class SUPER_USDT: + """ + name: SUPER-USDT + precision: 0.00001 + minimum_margin: None + initial_margin: None + minimum_order_size: 1 + maximum_order_size: None + margin: False + """ name: str = "SUPER-USDT" precision: int = 0.00001 minimum_margin: float = None @@ -11222,11 +15619,20 @@ def __call__(self): return "SUPER-USDT" -SUPER_USDT = SUPER_USDT() +SUSHI_BTC = SUSHI_BTC() @dataclass(slots=True, frozen=True) class SUSHI_BTC: + """ + name: SUSHI-BTC + precision: 0.00000001 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.000016 + maximum_order_size: None + margin: False + """ name: str = "SUSHI-BTC" precision: int = 0.00000001 minimum_margin: float = None @@ -11245,11 +15651,20 @@ def __call__(self): return "SUSHI-BTC" -SUSHI_BTC = SUSHI_BTC() +SUSHI_ETH = SUSHI_ETH() @dataclass(slots=True, frozen=True) class SUSHI_ETH: + """ + name: SUSHI-ETH + precision: 0.0000001 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.00022 + maximum_order_size: None + margin: False + """ name: str = "SUSHI-ETH" precision: int = 0.0000001 minimum_margin: float = None @@ -11268,11 +15683,20 @@ def __call__(self): return "SUSHI-ETH" -SUSHI_ETH = SUSHI_ETH() +SUSHI_EUR = SUSHI_EUR() @dataclass(slots=True, frozen=True) class SUSHI_EUR: + """ + name: SUSHI-EUR + precision: 0.0001 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.84 + maximum_order_size: None + margin: False + """ name: str = "SUSHI-EUR" precision: int = 0.0001 minimum_margin: float = None @@ -11291,11 +15715,20 @@ def __call__(self): return "SUSHI-EUR" -SUSHI_EUR = SUSHI_EUR() +SUSHI_GBP = SUSHI_GBP() @dataclass(slots=True, frozen=True) class SUSHI_GBP: + """ + name: SUSHI-GBP + precision: 0.0001 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.72 + maximum_order_size: None + margin: False + """ name: str = "SUSHI-GBP" precision: int = 0.0001 minimum_margin: float = None @@ -11314,11 +15747,20 @@ def __call__(self): return "SUSHI-GBP" -SUSHI_GBP = SUSHI_GBP() +SUSHI_USD = SUSHI_USD() @dataclass(slots=True, frozen=True) class SUSHI_USD: + """ + name: SUSHI-USD + precision: 0.0001 + minimum_margin: None + initial_margin: None + minimum_order_size: 1 + maximum_order_size: None + margin: False + """ name: str = "SUSHI-USD" precision: int = 0.0001 minimum_margin: float = None @@ -11337,11 +15779,20 @@ def __call__(self): return "SUSHI-USD" -SUSHI_USD = SUSHI_USD() +SWFTC_USD = SWFTC_USD() @dataclass(slots=True, frozen=True) class SWFTC_USD: + """ + name: SWFTC-USD + precision: 0.000001 + minimum_margin: None + initial_margin: None + minimum_order_size: 1 + maximum_order_size: None + margin: False + """ name: str = "SWFTC-USD" precision: int = 0.000001 minimum_margin: float = None @@ -11360,11 +15811,20 @@ def __call__(self): return "SWFTC-USD" -SWFTC_USD = SWFTC_USD() +SYLO_USD = SYLO_USD() @dataclass(slots=True, frozen=True) class SYLO_USD: + """ + name: SYLO-USD + precision: 0.000001 + minimum_margin: None + initial_margin: None + minimum_order_size: 1 + maximum_order_size: None + margin: False + """ name: str = "SYLO-USD" precision: int = 0.000001 minimum_margin: float = None @@ -11383,11 +15843,20 @@ def __call__(self): return "SYLO-USD" -SYLO_USD = SYLO_USD() +SYLO_USDT = SYLO_USDT() @dataclass(slots=True, frozen=True) class SYLO_USDT: + """ + name: SYLO-USDT + precision: 0.000001 + minimum_margin: None + initial_margin: None + minimum_order_size: 1 + maximum_order_size: None + margin: False + """ name: str = "SYLO-USDT" precision: int = 0.000001 minimum_margin: float = None @@ -11406,11 +15875,20 @@ def __call__(self): return "SYLO-USDT" -SYLO_USDT = SYLO_USDT() +SYN_USD = SYN_USD() @dataclass(slots=True, frozen=True) class SYN_USD: + """ + name: SYN-USD + precision: 0.001 + minimum_margin: None + initial_margin: None + minimum_order_size: 1 + maximum_order_size: None + margin: False + """ name: str = "SYN-USD" precision: int = 0.001 minimum_margin: float = None @@ -11429,11 +15907,20 @@ def __call__(self): return "SYN-USD" -SYN_USD = SYN_USD() +TIME_USD = TIME_USD() @dataclass(slots=True, frozen=True) class TIME_USD: + """ + name: TIME-USD + precision: 0.01 + minimum_margin: None + initial_margin: None + minimum_order_size: 1 + maximum_order_size: None + margin: False + """ name: str = "TIME-USD" precision: int = 0.01 minimum_margin: float = None @@ -11452,11 +15939,20 @@ def __call__(self): return "TIME-USD" -TIME_USD = TIME_USD() +TIME_USDT = TIME_USDT() @dataclass(slots=True, frozen=True) class TIME_USDT: + """ + name: TIME-USDT + precision: 0.01 + minimum_margin: None + initial_margin: None + minimum_order_size: 1 + maximum_order_size: None + margin: False + """ name: str = "TIME-USDT" precision: int = 0.01 minimum_margin: float = None @@ -11475,11 +15971,20 @@ def __call__(self): return "TIME-USDT" -TIME_USDT = TIME_USDT() +TONE_USD = TONE_USD() @dataclass(slots=True, frozen=True) class TONE_USD: + """ + name: TONE-USD + precision: 0.00001 + minimum_margin: None + initial_margin: None + minimum_order_size: 1 + maximum_order_size: None + margin: False + """ name: str = "TONE-USD" precision: int = 0.00001 minimum_margin: float = None @@ -11498,11 +16003,20 @@ def __call__(self): return "TONE-USD" -TONE_USD = TONE_USD() +TRAC_EUR = TRAC_EUR() @dataclass(slots=True, frozen=True) class TRAC_EUR: + """ + name: TRAC-EUR + precision: 0.0001 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.84 + maximum_order_size: None + margin: False + """ name: str = "TRAC-EUR" precision: int = 0.0001 minimum_margin: float = None @@ -11521,11 +16035,20 @@ def __call__(self): return "TRAC-EUR" -TRAC_EUR = TRAC_EUR() +TRAC_USD = TRAC_USD() @dataclass(slots=True, frozen=True) class TRAC_USD: + """ + name: TRAC-USD + precision: 0.0001 + minimum_margin: None + initial_margin: None + minimum_order_size: 1 + maximum_order_size: None + margin: False + """ name: str = "TRAC-USD" precision: int = 0.0001 minimum_margin: float = None @@ -11544,11 +16067,20 @@ def __call__(self): return "TRAC-USD" -TRAC_USD = TRAC_USD() +TRAC_USDT = TRAC_USDT() @dataclass(slots=True, frozen=True) class TRAC_USDT: + """ + name: TRAC-USDT + precision: 0.0001 + minimum_margin: None + initial_margin: None + minimum_order_size: 1 + maximum_order_size: None + margin: False + """ name: str = "TRAC-USDT" precision: int = 0.0001 minimum_margin: float = None @@ -11567,11 +16099,20 @@ def __call__(self): return "TRAC-USDT" -TRAC_USDT = TRAC_USDT() +TRB_BTC = TRB_BTC() @dataclass(slots=True, frozen=True) class TRB_BTC: + """ + name: TRB-BTC + precision: 0.0000001 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.000016 + maximum_order_size: None + margin: False + """ name: str = "TRB-BTC" precision: int = 0.0000001 minimum_margin: float = None @@ -11590,11 +16131,20 @@ def __call__(self): return "TRB-BTC" -TRB_BTC = TRB_BTC() +TRB_USD = TRB_USD() @dataclass(slots=True, frozen=True) class TRB_USD: + """ + name: TRB-USD + precision: 0.01 + minimum_margin: None + initial_margin: None + minimum_order_size: 1 + maximum_order_size: None + margin: False + """ name: str = "TRB-USD" precision: int = 0.01 minimum_margin: float = None @@ -11613,11 +16163,20 @@ def __call__(self): return "TRB-USD" -TRB_USD = TRB_USD() +TRIBE_USD = TRIBE_USD() @dataclass(slots=True, frozen=True) class TRIBE_USD: + """ + name: TRIBE-USD + precision: 0.0001 + minimum_margin: None + initial_margin: None + minimum_order_size: 1 + maximum_order_size: None + margin: False + """ name: str = "TRIBE-USD" precision: int = 0.0001 minimum_margin: float = None @@ -11636,11 +16195,20 @@ def __call__(self): return "TRIBE-USD" -TRIBE_USD = TRIBE_USD() +TRU_BTC = TRU_BTC() @dataclass(slots=True, frozen=True) class TRU_BTC: + """ + name: TRU-BTC + precision: 0.00000001 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.000016 + maximum_order_size: None + margin: False + """ name: str = "TRU-BTC" precision: int = 0.00000001 minimum_margin: float = None @@ -11659,11 +16227,20 @@ def __call__(self): return "TRU-BTC" -TRU_BTC = TRU_BTC() +TRU_EUR = TRU_EUR() @dataclass(slots=True, frozen=True) class TRU_EUR: + """ + name: TRU-EUR + precision: 0.0001 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.84 + maximum_order_size: None + margin: False + """ name: str = "TRU-EUR" precision: int = 0.0001 minimum_margin: float = None @@ -11682,11 +16259,20 @@ def __call__(self): return "TRU-EUR" -TRU_EUR = TRU_EUR() +TRU_USD = TRU_USD() @dataclass(slots=True, frozen=True) class TRU_USD: + """ + name: TRU-USD + precision: 0.0001 + minimum_margin: None + initial_margin: None + minimum_order_size: 1 + maximum_order_size: None + margin: False + """ name: str = "TRU-USD" precision: int = 0.0001 minimum_margin: float = None @@ -11705,11 +16291,20 @@ def __call__(self): return "TRU-USD" -TRU_USD = TRU_USD() +TRU_USDT = TRU_USDT() @dataclass(slots=True, frozen=True) class TRU_USDT: + """ + name: TRU-USDT + precision: 0.0001 + minimum_margin: None + initial_margin: None + minimum_order_size: 1 + maximum_order_size: None + margin: False + """ name: str = "TRU-USDT" precision: int = 0.0001 minimum_margin: float = None @@ -11728,11 +16323,20 @@ def __call__(self): return "TRU-USDT" -TRU_USDT = TRU_USDT() +UMA_BTC = UMA_BTC() @dataclass(slots=True, frozen=True) class UMA_BTC: + """ + name: UMA-BTC + precision: 0.00000001 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.000016 + maximum_order_size: None + margin: False + """ name: str = "UMA-BTC" precision: int = 0.00000001 minimum_margin: float = None @@ -11751,11 +16355,20 @@ def __call__(self): return "UMA-BTC" -UMA_BTC = UMA_BTC() +UMA_EUR = UMA_EUR() @dataclass(slots=True, frozen=True) class UMA_EUR: + """ + name: UMA-EUR + precision: 0.001 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.84 + maximum_order_size: None + margin: False + """ name: str = "UMA-EUR" precision: int = 0.001 minimum_margin: float = None @@ -11774,11 +16387,20 @@ def __call__(self): return "UMA-EUR" -UMA_EUR = UMA_EUR() +UMA_GBP = UMA_GBP() @dataclass(slots=True, frozen=True) class UMA_GBP: + """ + name: UMA-GBP + precision: 0.01 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.72 + maximum_order_size: None + margin: False + """ name: str = "UMA-GBP" precision: int = 0.01 minimum_margin: float = None @@ -11797,11 +16419,20 @@ def __call__(self): return "UMA-GBP" -UMA_GBP = UMA_GBP() +UMA_USD = UMA_USD() @dataclass(slots=True, frozen=True) class UMA_USD: + """ + name: UMA-USD + precision: 0.001 + minimum_margin: None + initial_margin: None + minimum_order_size: 1 + maximum_order_size: None + margin: False + """ name: str = "UMA-USD" precision: int = 0.001 minimum_margin: float = None @@ -11820,11 +16451,20 @@ def __call__(self): return "UMA-USD" -UMA_USD = UMA_USD() +UNFI_USD = UNFI_USD() @dataclass(slots=True, frozen=True) class UNFI_USD: + """ + name: UNFI-USD + precision: 0.01 + minimum_margin: None + initial_margin: None + minimum_order_size: 1 + maximum_order_size: None + margin: False + """ name: str = "UNFI-USD" precision: int = 0.01 minimum_margin: float = None @@ -11843,11 +16483,20 @@ def __call__(self): return "UNFI-USD" -UNFI_USD = UNFI_USD() +UNI_BTC = UNI_BTC() @dataclass(slots=True, frozen=True) class UNI_BTC: + """ + name: UNI-BTC + precision: 0.0000001 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.000016 + maximum_order_size: None + margin: False + """ name: str = "UNI-BTC" precision: int = 0.0000001 minimum_margin: float = None @@ -11866,11 +16515,20 @@ def __call__(self): return "UNI-BTC" -UNI_BTC = UNI_BTC() +UNI_EUR = UNI_EUR() @dataclass(slots=True, frozen=True) class UNI_EUR: + """ + name: UNI-EUR + precision: 0.01 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.84 + maximum_order_size: None + margin: False + """ name: str = "UNI-EUR" precision: int = 0.01 minimum_margin: float = None @@ -11889,11 +16547,20 @@ def __call__(self): return "UNI-EUR" -UNI_EUR = UNI_EUR() +UNI_GBP = UNI_GBP() @dataclass(slots=True, frozen=True) class UNI_GBP: + """ + name: UNI-GBP + precision: 0.01 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.72 + maximum_order_size: None + margin: False + """ name: str = "UNI-GBP" precision: int = 0.01 minimum_margin: float = None @@ -11912,11 +16579,20 @@ def __call__(self): return "UNI-GBP" -UNI_GBP = UNI_GBP() +UNI_USD = UNI_USD() @dataclass(slots=True, frozen=True) class UNI_USD: + """ + name: UNI-USD + precision: 0.001 + minimum_margin: None + initial_margin: None + minimum_order_size: 1 + maximum_order_size: None + margin: False + """ name: str = "UNI-USD" precision: int = 0.001 minimum_margin: float = None @@ -11935,11 +16611,20 @@ def __call__(self): return "UNI-USD" -UNI_USD = UNI_USD() +UPI_USD = UPI_USD() @dataclass(slots=True, frozen=True) class UPI_USD: + """ + name: UPI-USD + precision: 0.00001 + minimum_margin: None + initial_margin: None + minimum_order_size: 1 + maximum_order_size: None + margin: False + """ name: str = "UPI-USD" precision: int = 0.00001 minimum_margin: float = None @@ -11958,11 +16643,20 @@ def __call__(self): return "UPI-USD" -UPI_USD = UPI_USD() +UPI_USDT = UPI_USDT() @dataclass(slots=True, frozen=True) class UPI_USDT: + """ + name: UPI-USDT + precision: 0.00001 + minimum_margin: None + initial_margin: None + minimum_order_size: 1 + maximum_order_size: None + margin: False + """ name: str = "UPI-USDT" precision: int = 0.00001 minimum_margin: float = None @@ -11981,11 +16675,20 @@ def __call__(self): return "UPI-USDT" -UPI_USDT = UPI_USDT() +USDC_EUR = USDC_EUR() @dataclass(slots=True, frozen=True) class USDC_EUR: + """ + name: USDC-EUR + precision: 0.0001 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.84 + maximum_order_size: None + margin: False + """ name: str = "USDC-EUR" precision: int = 0.0001 minimum_margin: float = None @@ -12004,11 +16707,20 @@ def __call__(self): return "USDC-EUR" -USDC_EUR = USDC_EUR() +USDC_GBP = USDC_GBP() @dataclass(slots=True, frozen=True) class USDC_GBP: + """ + name: USDC-GBP + precision: 0.0001 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.72 + maximum_order_size: None + margin: False + """ name: str = "USDC-GBP" precision: int = 0.0001 minimum_margin: float = None @@ -12027,11 +16739,20 @@ def __call__(self): return "USDC-GBP" -USDC_GBP = USDC_GBP() +USDT_EUR = USDT_EUR() @dataclass(slots=True, frozen=True) class USDT_EUR: + """ + name: USDT-EUR + precision: 0.00001 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.84 + maximum_order_size: None + margin: False + """ name: str = "USDT-EUR" precision: int = 0.00001 minimum_margin: float = None @@ -12050,11 +16771,20 @@ def __call__(self): return "USDT-EUR" -USDT_EUR = USDT_EUR() +USDT_GBP = USDT_GBP() @dataclass(slots=True, frozen=True) class USDT_GBP: + """ + name: USDT-GBP + precision: 0.0001 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.72 + maximum_order_size: None + margin: False + """ name: str = "USDT-GBP" precision: int = 0.0001 minimum_margin: float = None @@ -12073,11 +16803,20 @@ def __call__(self): return "USDT-GBP" -USDT_GBP = USDT_GBP() +USDT_USD = USDT_USD() @dataclass(slots=True, frozen=True) class USDT_USD: + """ + name: USDT-USD + precision: 0.00001 + minimum_margin: None + initial_margin: None + minimum_order_size: 1 + maximum_order_size: None + margin: False + """ name: str = "USDT-USD" precision: int = 0.00001 minimum_margin: float = None @@ -12096,11 +16835,20 @@ def __call__(self): return "USDT-USD" -USDT_USD = USDT_USD() +USDT_USDC = USDT_USDC() @dataclass(slots=True, frozen=True) class USDT_USDC: + """ + name: USDT-USDC + precision: 0.0001 + minimum_margin: None + initial_margin: None + minimum_order_size: 1 + maximum_order_size: None + margin: False + """ name: str = "USDT-USDC" precision: int = 0.0001 minimum_margin: float = None @@ -12119,11 +16867,20 @@ def __call__(self): return "USDT-USDC" -USDT_USDC = USDT_USDC() +UST_EUR = UST_EUR() @dataclass(slots=True, frozen=True) class UST_EUR: + """ + name: UST-EUR + precision: 0.00001 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.84 + maximum_order_size: None + margin: False + """ name: str = "UST-EUR" precision: int = 0.00001 minimum_margin: float = None @@ -12142,11 +16899,20 @@ def __call__(self): return "UST-EUR" -UST_EUR = UST_EUR() +UST_USD = UST_USD() @dataclass(slots=True, frozen=True) class UST_USD: + """ + name: UST-USD + precision: 0.00001 + minimum_margin: None + initial_margin: None + minimum_order_size: 1 + maximum_order_size: None + margin: False + """ name: str = "UST-USD" precision: int = 0.00001 minimum_margin: float = None @@ -12165,11 +16931,20 @@ def __call__(self): return "UST-USD" -UST_USD = UST_USD() +UST_USDT = UST_USDT() @dataclass(slots=True, frozen=True) class UST_USDT: + """ + name: UST-USDT + precision: 0.00001 + minimum_margin: None + initial_margin: None + minimum_order_size: 1 + maximum_order_size: None + margin: False + """ name: str = "UST-USDT" precision: int = 0.00001 minimum_margin: float = None @@ -12188,11 +16963,20 @@ def __call__(self): return "UST-USDT" -UST_USDT = UST_USDT() +VGX_EUR = VGX_EUR() @dataclass(slots=True, frozen=True) class VGX_EUR: + """ + name: VGX-EUR + precision: 0.0001 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.84 + maximum_order_size: None + margin: False + """ name: str = "VGX-EUR" precision: int = 0.0001 minimum_margin: float = None @@ -12211,11 +16995,20 @@ def __call__(self): return "VGX-EUR" -VGX_EUR = VGX_EUR() +VGX_USD = VGX_USD() @dataclass(slots=True, frozen=True) class VGX_USD: + """ + name: VGX-USD + precision: 0.0001 + minimum_margin: None + initial_margin: None + minimum_order_size: 1 + maximum_order_size: None + margin: False + """ name: str = "VGX-USD" precision: int = 0.0001 minimum_margin: float = None @@ -12234,11 +17027,20 @@ def __call__(self): return "VGX-USD" -VGX_USD = VGX_USD() +VGX_USDT = VGX_USDT() @dataclass(slots=True, frozen=True) class VGX_USDT: + """ + name: VGX-USDT + precision: 0.0001 + minimum_margin: None + initial_margin: None + minimum_order_size: 1 + maximum_order_size: None + margin: False + """ name: str = "VGX-USDT" precision: int = 0.0001 minimum_margin: float = None @@ -12257,11 +17059,20 @@ def __call__(self): return "VGX-USDT" -VGX_USDT = VGX_USDT() +WAMPL_USD = WAMPL_USD() @dataclass(slots=True, frozen=True) class WAMPL_USD: + """ + name: WAMPL-USD + precision: 0.01 + minimum_margin: None + initial_margin: None + minimum_order_size: 1 + maximum_order_size: None + margin: False + """ name: str = "WAMPL-USD" precision: int = 0.01 minimum_margin: float = None @@ -12280,11 +17091,20 @@ def __call__(self): return "WAMPL-USD" -WAMPL_USD = WAMPL_USD() +WAMPL_USDT = WAMPL_USDT() @dataclass(slots=True, frozen=True) class WAMPL_USDT: + """ + name: WAMPL-USDT + precision: 0.01 + minimum_margin: None + initial_margin: None + minimum_order_size: 1 + maximum_order_size: None + margin: False + """ name: str = "WAMPL-USDT" precision: int = 0.01 minimum_margin: float = None @@ -12303,11 +17123,20 @@ def __call__(self): return "WAMPL-USDT" -WAMPL_USDT = WAMPL_USDT() +WAXL_USD = WAXL_USD() @dataclass(slots=True, frozen=True) class WAXL_USD: + """ + name: WAXL-USD + precision: 0.0001 + minimum_margin: None + initial_margin: None + minimum_order_size: 1 + maximum_order_size: None + margin: False + """ name: str = "WAXL-USD" precision: int = 0.0001 minimum_margin: float = None @@ -12326,11 +17155,20 @@ def __call__(self): return "WAXL-USD" -WAXL_USD = WAXL_USD() +WBTC_BTC = WBTC_BTC() @dataclass(slots=True, frozen=True) class WBTC_BTC: + """ + name: WBTC-BTC + precision: 0.0001 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.0001 + maximum_order_size: None + margin: False + """ name: str = "WBTC-BTC" precision: int = 0.0001 minimum_margin: float = None @@ -12349,11 +17187,20 @@ def __call__(self): return "WBTC-BTC" -WBTC_BTC = WBTC_BTC() +WBTC_USD = WBTC_USD() @dataclass(slots=True, frozen=True) class WBTC_USD: + """ + name: WBTC-USD + precision: 0.01 + minimum_margin: None + initial_margin: None + minimum_order_size: 1 + maximum_order_size: None + margin: False + """ name: str = "WBTC-USD" precision: int = 0.01 minimum_margin: float = None @@ -12372,11 +17219,20 @@ def __call__(self): return "WBTC-USD" -WBTC_USD = WBTC_USD() +WCFG_BTC = WCFG_BTC() @dataclass(slots=True, frozen=True) class WCFG_BTC: + """ + name: WCFG-BTC + precision: 0.00000001 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.000016 + maximum_order_size: None + margin: False + """ name: str = "WCFG-BTC" precision: int = 0.00000001 minimum_margin: float = None @@ -12395,11 +17251,20 @@ def __call__(self): return "WCFG-BTC" -WCFG_BTC = WCFG_BTC() +WCFG_EUR = WCFG_EUR() @dataclass(slots=True, frozen=True) class WCFG_EUR: + """ + name: WCFG-EUR + precision: 0.0001 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.84 + maximum_order_size: None + margin: False + """ name: str = "WCFG-EUR" precision: int = 0.0001 minimum_margin: float = None @@ -12418,11 +17283,20 @@ def __call__(self): return "WCFG-EUR" -WCFG_EUR = WCFG_EUR() +WCFG_USD = WCFG_USD() @dataclass(slots=True, frozen=True) class WCFG_USD: + """ + name: WCFG-USD + precision: 0.001 + minimum_margin: None + initial_margin: None + minimum_order_size: 1 + maximum_order_size: None + margin: False + """ name: str = "WCFG-USD" precision: int = 0.001 minimum_margin: float = None @@ -12441,11 +17315,20 @@ def __call__(self): return "WCFG-USD" -WCFG_USD = WCFG_USD() +WCFG_USDT = WCFG_USDT() @dataclass(slots=True, frozen=True) class WCFG_USDT: + """ + name: WCFG-USDT + precision: 0.00001 + minimum_margin: None + initial_margin: None + minimum_order_size: 1 + maximum_order_size: None + margin: False + """ name: str = "WCFG-USDT" precision: int = 0.00001 minimum_margin: float = None @@ -12464,11 +17347,20 @@ def __call__(self): return "WCFG-USDT" -WCFG_USDT = WCFG_USDT() +WLUNA_EUR = WLUNA_EUR() @dataclass(slots=True, frozen=True) class WLUNA_EUR: + """ + name: WLUNA-EUR + precision: 0.00000001 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.84 + maximum_order_size: None + margin: False + """ name: str = "WLUNA-EUR" precision: int = 0.00000001 minimum_margin: float = None @@ -12487,11 +17379,20 @@ def __call__(self): return "WLUNA-EUR" -WLUNA_EUR = WLUNA_EUR() +WLUNA_GBP = WLUNA_GBP() @dataclass(slots=True, frozen=True) class WLUNA_GBP: + """ + name: WLUNA-GBP + precision: 0.00000001 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.72 + maximum_order_size: None + margin: False + """ name: str = "WLUNA-GBP" precision: int = 0.00000001 minimum_margin: float = None @@ -12510,11 +17411,20 @@ def __call__(self): return "WLUNA-GBP" -WLUNA_GBP = WLUNA_GBP() +WLUNA_USD = WLUNA_USD() @dataclass(slots=True, frozen=True) class WLUNA_USD: + """ + name: WLUNA-USD + precision: 0.00000001 + minimum_margin: None + initial_margin: None + minimum_order_size: 1 + maximum_order_size: None + margin: False + """ name: str = "WLUNA-USD" precision: int = 0.00000001 minimum_margin: float = None @@ -12533,11 +17443,20 @@ def __call__(self): return "WLUNA-USD" -WLUNA_USD = WLUNA_USD() +WLUNA_USDT = WLUNA_USDT() @dataclass(slots=True, frozen=True) class WLUNA_USDT: + """ + name: WLUNA-USDT + precision: 0.00000001 + minimum_margin: None + initial_margin: None + minimum_order_size: 1 + maximum_order_size: None + margin: False + """ name: str = "WLUNA-USDT" precision: int = 0.00000001 minimum_margin: float = None @@ -12556,11 +17475,20 @@ def __call__(self): return "WLUNA-USDT" -WLUNA_USDT = WLUNA_USDT() +XCN_USD = XCN_USD() @dataclass(slots=True, frozen=True) class XCN_USD: + """ + name: XCN-USD + precision: 0.00001 + minimum_margin: None + initial_margin: None + minimum_order_size: 1 + maximum_order_size: None + margin: False + """ name: str = "XCN-USD" precision: int = 0.00001 minimum_margin: float = None @@ -12579,11 +17507,20 @@ def __call__(self): return "XCN-USD" -XCN_USD = XCN_USD() +XCN_USDT = XCN_USDT() @dataclass(slots=True, frozen=True) class XCN_USDT: + """ + name: XCN-USDT + precision: 0.00001 + minimum_margin: None + initial_margin: None + minimum_order_size: 1 + maximum_order_size: None + margin: False + """ name: str = "XCN-USDT" precision: int = 0.00001 minimum_margin: float = None @@ -12602,11 +17539,20 @@ def __call__(self): return "XCN-USDT" -XCN_USDT = XCN_USDT() +XLM_BTC = XLM_BTC() @dataclass(slots=True, frozen=True) class XLM_BTC: + """ + name: XLM-BTC + precision: 0.00000001 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.000016 + maximum_order_size: None + margin: False + """ name: str = "XLM-BTC" precision: int = 0.00000001 minimum_margin: float = None @@ -12625,11 +17571,20 @@ def __call__(self): return "XLM-BTC" -XLM_BTC = XLM_BTC() +XLM_EUR = XLM_EUR() @dataclass(slots=True, frozen=True) class XLM_EUR: + """ + name: XLM-EUR + precision: 0.000001 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.84 + maximum_order_size: None + margin: False + """ name: str = "XLM-EUR" precision: int = 0.000001 minimum_margin: float = None @@ -12648,11 +17603,20 @@ def __call__(self): return "XLM-EUR" -XLM_EUR = XLM_EUR() +XLM_USD = XLM_USD() @dataclass(slots=True, frozen=True) class XLM_USD: + """ + name: XLM-USD + precision: 0.000001 + minimum_margin: None + initial_margin: None + minimum_order_size: 1 + maximum_order_size: None + margin: False + """ name: str = "XLM-USD" precision: int = 0.000001 minimum_margin: float = None @@ -12671,11 +17635,20 @@ def __call__(self): return "XLM-USD" -XLM_USD = XLM_USD() +XLM_USDT = XLM_USDT() @dataclass(slots=True, frozen=True) class XLM_USDT: + """ + name: XLM-USDT + precision: 0.0001 + minimum_margin: None + initial_margin: None + minimum_order_size: 1 + maximum_order_size: None + margin: False + """ name: str = "XLM-USDT" precision: int = 0.0001 minimum_margin: float = None @@ -12694,11 +17667,20 @@ def __call__(self): return "XLM-USDT" -XLM_USDT = XLM_USDT() +XRP_BTC = XRP_BTC() @dataclass(slots=True, frozen=True) class XRP_BTC: + """ + name: XRP-BTC + precision: 0.00000001 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.001 + maximum_order_size: None + margin: False + """ name: str = "XRP-BTC" precision: int = 0.00000001 minimum_margin: float = None @@ -12717,11 +17699,20 @@ def __call__(self): return "XRP-BTC" -XRP_BTC = XRP_BTC() +XRP_EUR = XRP_EUR() @dataclass(slots=True, frozen=True) class XRP_EUR: + """ + name: XRP-EUR + precision: 0.0001 + minimum_margin: None + initial_margin: None + minimum_order_size: 10 + maximum_order_size: None + margin: False + """ name: str = "XRP-EUR" precision: int = 0.0001 minimum_margin: float = None @@ -12740,11 +17731,20 @@ def __call__(self): return "XRP-EUR" -XRP_EUR = XRP_EUR() +XRP_GBP = XRP_GBP() @dataclass(slots=True, frozen=True) class XRP_GBP: + """ + name: XRP-GBP + precision: 0.0001 + minimum_margin: None + initial_margin: None + minimum_order_size: 10 + maximum_order_size: None + margin: False + """ name: str = "XRP-GBP" precision: int = 0.0001 minimum_margin: float = None @@ -12763,11 +17763,20 @@ def __call__(self): return "XRP-GBP" -XRP_GBP = XRP_GBP() +XRP_USD = XRP_USD() @dataclass(slots=True, frozen=True) class XRP_USD: + """ + name: XRP-USD + precision: 0.0001 + minimum_margin: None + initial_margin: None + minimum_order_size: 10 + maximum_order_size: None + margin: False + """ name: str = "XRP-USD" precision: int = 0.0001 minimum_margin: float = None @@ -12786,11 +17795,20 @@ def __call__(self): return "XRP-USD" -XRP_USD = XRP_USD() +XTZ_BTC = XTZ_BTC() @dataclass(slots=True, frozen=True) class XTZ_BTC: + """ + name: XTZ-BTC + precision: 0.00000001 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.000016 + maximum_order_size: None + margin: False + """ name: str = "XTZ-BTC" precision: int = 0.00000001 minimum_margin: float = None @@ -12809,11 +17827,20 @@ def __call__(self): return "XTZ-BTC" -XTZ_BTC = XTZ_BTC() +XTZ_EUR = XTZ_EUR() @dataclass(slots=True, frozen=True) class XTZ_EUR: + """ + name: XTZ-EUR + precision: 0.01 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.84 + maximum_order_size: None + margin: False + """ name: str = "XTZ-EUR" precision: int = 0.01 minimum_margin: float = None @@ -12832,11 +17859,20 @@ def __call__(self): return "XTZ-EUR" -XTZ_EUR = XTZ_EUR() +XTZ_GBP = XTZ_GBP() @dataclass(slots=True, frozen=True) class XTZ_GBP: + """ + name: XTZ-GBP + precision: 0.001 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.72 + maximum_order_size: None + margin: False + """ name: str = "XTZ-GBP" precision: int = 0.001 minimum_margin: float = None @@ -12855,11 +17891,20 @@ def __call__(self): return "XTZ-GBP" -XTZ_GBP = XTZ_GBP() +XTZ_USD = XTZ_USD() @dataclass(slots=True, frozen=True) class XTZ_USD: + """ + name: XTZ-USD + precision: 0.001 + minimum_margin: None + initial_margin: None + minimum_order_size: 1 + maximum_order_size: None + margin: False + """ name: str = "XTZ-USD" precision: int = 0.001 minimum_margin: float = None @@ -12878,11 +17923,20 @@ def __call__(self): return "XTZ-USD" -XTZ_USD = XTZ_USD() +XYO_BTC = XYO_BTC() @dataclass(slots=True, frozen=True) class XYO_BTC: + """ + name: XYO-BTC + precision: 0.00000001 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.000016 + maximum_order_size: None + margin: False + """ name: str = "XYO-BTC" precision: int = 0.00000001 minimum_margin: float = None @@ -12901,11 +17955,20 @@ def __call__(self): return "XYO-BTC" -XYO_BTC = XYO_BTC() +XYO_EUR = XYO_EUR() @dataclass(slots=True, frozen=True) class XYO_EUR: + """ + name: XYO-EUR + precision: 0.000001 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.84 + maximum_order_size: None + margin: False + """ name: str = "XYO-EUR" precision: int = 0.000001 minimum_margin: float = None @@ -12924,11 +17987,20 @@ def __call__(self): return "XYO-EUR" -XYO_EUR = XYO_EUR() +XYO_USD = XYO_USD() @dataclass(slots=True, frozen=True) class XYO_USD: + """ + name: XYO-USD + precision: 0.00001 + minimum_margin: None + initial_margin: None + minimum_order_size: 1 + maximum_order_size: None + margin: False + """ name: str = "XYO-USD" precision: int = 0.00001 minimum_margin: float = None @@ -12947,11 +18019,20 @@ def __call__(self): return "XYO-USD" -XYO_USD = XYO_USD() +XYO_USDT = XYO_USDT() @dataclass(slots=True, frozen=True) class XYO_USDT: + """ + name: XYO-USDT + precision: 0.00001 + minimum_margin: None + initial_margin: None + minimum_order_size: 1 + maximum_order_size: None + margin: False + """ name: str = "XYO-USDT" precision: int = 0.00001 minimum_margin: float = None @@ -12970,11 +18051,20 @@ def __call__(self): return "XYO-USDT" -XYO_USDT = XYO_USDT() +YFI_BTC = YFI_BTC() @dataclass(slots=True, frozen=True) class YFI_BTC: + """ + name: YFI-BTC + precision: 0.0001 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.00001 + maximum_order_size: None + margin: False + """ name: str = "YFI-BTC" precision: int = 0.0001 minimum_margin: float = None @@ -12993,11 +18083,20 @@ def __call__(self): return "YFI-BTC" -YFI_BTC = YFI_BTC() +YFI_USD = YFI_USD() @dataclass(slots=True, frozen=True) class YFI_USD: + """ + name: YFI-USD + precision: 0.01 + minimum_margin: None + initial_margin: None + minimum_order_size: 1 + maximum_order_size: None + margin: False + """ name: str = "YFI-USD" precision: int = 0.01 minimum_margin: float = None @@ -13016,11 +18115,20 @@ def __call__(self): return "YFI-USD" -YFI_USD = YFI_USD() +YFII_USD = YFII_USD() @dataclass(slots=True, frozen=True) class YFII_USD: + """ + name: YFII-USD + precision: 0.01 + minimum_margin: None + initial_margin: None + minimum_order_size: 1 + maximum_order_size: None + margin: False + """ name: str = "YFII-USD" precision: int = 0.01 minimum_margin: float = None @@ -13039,11 +18147,20 @@ def __call__(self): return "YFII-USD" -YFII_USD = YFII_USD() +ZEC_BTC = ZEC_BTC() @dataclass(slots=True, frozen=True) class ZEC_BTC: + """ + name: ZEC-BTC + precision: 0.000001 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.000016 + maximum_order_size: None + margin: False + """ name: str = "ZEC-BTC" precision: int = 0.000001 minimum_margin: float = None @@ -13062,11 +18179,20 @@ def __call__(self): return "ZEC-BTC" -ZEC_BTC = ZEC_BTC() +ZEC_USD = ZEC_USD() @dataclass(slots=True, frozen=True) class ZEC_USD: + """ + name: ZEC-USD + precision: 0.01 + minimum_margin: None + initial_margin: None + minimum_order_size: 1 + maximum_order_size: None + margin: False + """ name: str = "ZEC-USD" precision: int = 0.01 minimum_margin: float = None @@ -13085,11 +18211,20 @@ def __call__(self): return "ZEC-USD" -ZEC_USD = ZEC_USD() +ZEC_USDC = ZEC_USDC() @dataclass(slots=True, frozen=True) class ZEC_USDC: + """ + name: ZEC-USDC + precision: 0.01 + minimum_margin: None + initial_margin: None + minimum_order_size: 1 + maximum_order_size: None + margin: False + """ name: str = "ZEC-USDC" precision: int = 0.01 minimum_margin: float = None @@ -13108,11 +18243,20 @@ def __call__(self): return "ZEC-USDC" -ZEC_USDC = ZEC_USDC() +ZEN_BTC = ZEN_BTC() @dataclass(slots=True, frozen=True) class ZEN_BTC: + """ + name: ZEN-BTC + precision: 0.0000001 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.000016 + maximum_order_size: None + margin: False + """ name: str = "ZEN-BTC" precision: int = 0.0000001 minimum_margin: float = None @@ -13131,11 +18275,20 @@ def __call__(self): return "ZEN-BTC" -ZEN_BTC = ZEN_BTC() +ZEN_USD = ZEN_USD() @dataclass(slots=True, frozen=True) class ZEN_USD: + """ + name: ZEN-USD + precision: 0.01 + minimum_margin: None + initial_margin: None + minimum_order_size: 1 + maximum_order_size: None + margin: False + """ name: str = "ZEN-USD" precision: int = 0.01 minimum_margin: float = None @@ -13154,11 +18307,20 @@ def __call__(self): return "ZEN-USD" -ZEN_USD = ZEN_USD() +ZEN_USDT = ZEN_USDT() @dataclass(slots=True, frozen=True) class ZEN_USDT: + """ + name: ZEN-USDT + precision: 0.01 + minimum_margin: None + initial_margin: None + minimum_order_size: 1 + maximum_order_size: None + margin: False + """ name: str = "ZEN-USDT" precision: int = 0.01 minimum_margin: float = None @@ -13177,11 +18339,20 @@ def __call__(self): return "ZEN-USDT" -ZEN_USDT = ZEN_USDT() +ZRX_BTC = ZRX_BTC() @dataclass(slots=True, frozen=True) class ZRX_BTC: + """ + name: ZRX-BTC + precision: 0.00000001 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.000016 + maximum_order_size: None + margin: False + """ name: str = "ZRX-BTC" precision: int = 0.00000001 minimum_margin: float = None @@ -13200,11 +18371,20 @@ def __call__(self): return "ZRX-BTC" -ZRX_BTC = ZRX_BTC() +ZRX_EUR = ZRX_EUR() @dataclass(slots=True, frozen=True) class ZRX_EUR: + """ + name: ZRX-EUR + precision: 0.0001 + minimum_margin: None + initial_margin: None + minimum_order_size: 0.84 + maximum_order_size: None + margin: False + """ name: str = "ZRX-EUR" precision: int = 0.0001 minimum_margin: float = None @@ -13223,11 +18403,20 @@ def __call__(self): return "ZRX-EUR" -ZRX_EUR = ZRX_EUR() +ZRX_USD = ZRX_USD() @dataclass(slots=True, frozen=True) class ZRX_USD: + """ + name: ZRX-USD + precision: 0.000001 + minimum_margin: None + initial_margin: None + minimum_order_size: 1 + maximum_order_size: None + margin: False + """ name: str = "ZRX-USD" precision: int = 0.000001 minimum_margin: float = None @@ -13244,8 +18433,3 @@ def __str__(self): def __call__(self): return "ZRX-USD" - - -ZRX_USD = ZRX_USD() - - diff --git a/symbols/mercado_bitcoin.py b/symbols/mercado_bitcoin.py index 08ed9fb..8875d55 100644 --- a/symbols/mercado_bitcoin.py +++ b/symbols/mercado_bitcoin.py @@ -1,33 +1,24 @@ from dataclasses import dataclass -@dataclass(slots=True, frozen=True) -class MBVASCO01_BRL: - name: str = "MBVASCO01-BRL" - precision: int = 0.00000001 - minimum_margin: float = None - initial_margin: float = None - minimum_order_size: float = None - maximum_order_size: float = None - margin: bool = False - - def __repr__(self): - return "MBVASCO01-BRL" - - def __str__(self): - return "MBVASCO01-BRL" - - def __call__(self): - return "MBVASCO01-BRL" -MBVASCO01_BRL = MBVASCO01_BRL() +ILV_BRL = ILV_BRL() @dataclass(slots=True, frozen=True) -class MBCONS01_BRL: - name: str = "MBCONS01-BRL" - precision: int = 0.00000001 +class ILV_BRL: + """ + name: ILV-BRL + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: None + maximum_order_size: None + margin: False + """ + name: str = "ILV-BRL" + precision: int = 8 minimum_margin: float = None initial_margin: float = None minimum_order_size: float = None @@ -35,22 +26,31 @@ class MBCONS01_BRL: margin: bool = False def __repr__(self): - return "MBCONS01-BRL" + return "ILV-BRL" def __str__(self): - return "MBCONS01-BRL" + return "ILV-BRL" def __call__(self): - return "MBCONS01-BRL" + return "ILV-BRL" -MBCONS01_BRL = MBCONS01_BRL() +OPUL_BRL = OPUL_BRL() @dataclass(slots=True, frozen=True) -class MINA_BRL: - name: str = "MINA-BRL" - precision: int = 0.00000001 +class OPUL_BRL: + """ + name: OPUL-BRL + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: None + maximum_order_size: None + margin: False + """ + name: str = "OPUL-BRL" + precision: int = 8 minimum_margin: float = None initial_margin: float = None minimum_order_size: float = None @@ -58,22 +58,31 @@ class MINA_BRL: margin: bool = False def __repr__(self): - return "MINA-BRL" + return "OPUL-BRL" def __str__(self): - return "MINA-BRL" + return "OPUL-BRL" def __call__(self): - return "MINA-BRL" + return "OPUL-BRL" -MINA_BRL = MINA_BRL() +MBFP09_BRL = MBFP09_BRL() @dataclass(slots=True, frozen=True) -class ALPHA_BRL: - name: str = "ALPHA-BRL" - precision: int = 0.00000001 +class MBFP09_BRL: + """ + name: MBFP09-BRL + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: None + maximum_order_size: None + margin: False + """ + name: str = "MBFP09-BRL" + precision: int = 8 minimum_margin: float = None initial_margin: float = None minimum_order_size: float = None @@ -81,22 +90,31 @@ class ALPHA_BRL: margin: bool = False def __repr__(self): - return "ALPHA-BRL" + return "MBFP09-BRL" def __str__(self): - return "ALPHA-BRL" + return "MBFP09-BRL" def __call__(self): - return "ALPHA-BRL" + return "MBFP09-BRL" -ALPHA_BRL = ALPHA_BRL() +MBCCSH04_BRL = MBCCSH04_BRL() @dataclass(slots=True, frozen=True) -class ATLAS_BRL: - name: str = "ATLAS-BRL" - precision: int = 0.00000001 +class MBCCSH04_BRL: + """ + name: MBCCSH04-BRL + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: None + maximum_order_size: None + margin: False + """ + name: str = "MBCCSH04-BRL" + precision: int = 8 minimum_margin: float = None initial_margin: float = None minimum_order_size: float = None @@ -104,22 +122,31 @@ class ATLAS_BRL: margin: bool = False def __repr__(self): - return "ATLAS-BRL" + return "MBCCSH04-BRL" def __str__(self): - return "ATLAS-BRL" + return "MBCCSH04-BRL" def __call__(self): - return "ATLAS-BRL" + return "MBCCSH04-BRL" -ATLAS_BRL = ATLAS_BRL() +MATIC_BRL = MATIC_BRL() @dataclass(slots=True, frozen=True) -class THFT_BRL: - name: str = "THFT-BRL" - precision: int = 0.00000001 +class MATIC_BRL: + """ + name: MATIC-BRL + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: None + maximum_order_size: None + margin: False + """ + name: str = "MATIC-BRL" + precision: int = 8 minimum_margin: float = None initial_margin: float = None minimum_order_size: float = None @@ -127,22 +154,31 @@ class THFT_BRL: margin: bool = False def __repr__(self): - return "THFT-BRL" + return "MATIC-BRL" def __str__(self): - return "THFT-BRL" + return "MATIC-BRL" def __call__(self): - return "THFT-BRL" + return "MATIC-BRL" -THFT_BRL = THFT_BRL() +BTRST_BRL = BTRST_BRL() @dataclass(slots=True, frozen=True) -class ALCX_BRL: - name: str = "ALCX-BRL" - precision: int = 0.00000001 +class BTRST_BRL: + """ + name: BTRST-BRL + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: None + maximum_order_size: None + margin: False + """ + name: str = "BTRST-BRL" + precision: int = 8 minimum_margin: float = None initial_margin: float = None minimum_order_size: float = None @@ -150,22 +186,31 @@ class ALCX_BRL: margin: bool = False def __repr__(self): - return "ALCX-BRL" + return "BTRST-BRL" def __str__(self): - return "ALCX-BRL" + return "BTRST-BRL" def __call__(self): - return "ALCX-BRL" + return "BTRST-BRL" -ALCX_BRL = ALCX_BRL() +CSCONS04_BRL = CSCONS04_BRL() @dataclass(slots=True, frozen=True) -class SDAO_BRL: - name: str = "SDAO-BRL" - precision: int = 0.00000001 +class CSCONS04_BRL: + """ + name: CSCONS04-BRL + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: None + maximum_order_size: None + margin: False + """ + name: str = "CSCONS04-BRL" + precision: int = 8 minimum_margin: float = None initial_margin: float = None minimum_order_size: float = None @@ -173,22 +218,31 @@ class SDAO_BRL: margin: bool = False def __repr__(self): - return "SDAO-BRL" + return "CSCONS04-BRL" def __str__(self): - return "SDAO-BRL" + return "CSCONS04-BRL" def __call__(self): - return "SDAO-BRL" + return "CSCONS04-BRL" -SDAO_BRL = SDAO_BRL() +MKR_BRL = MKR_BRL() @dataclass(slots=True, frozen=True) -class FIL_BRL: - name: str = "FIL-BRL" - precision: int = 0.00000001 +class MKR_BRL: + """ + name: MKR-BRL + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: None + maximum_order_size: None + margin: False + """ + name: str = "MKR-BRL" + precision: int = 8 minimum_margin: float = None initial_margin: float = None minimum_order_size: float = None @@ -196,22 +250,31 @@ class FIL_BRL: margin: bool = False def __repr__(self): - return "FIL-BRL" + return "MKR-BRL" def __str__(self): - return "FIL-BRL" + return "MKR-BRL" def __call__(self): - return "FIL-BRL" + return "MKR-BRL" -FIL_BRL = FIL_BRL() +KEEP_BRL = KEEP_BRL() @dataclass(slots=True, frozen=True) -class STORJ_BRL: - name: str = "STORJ-BRL" - precision: int = 0.00000001 +class KEEP_BRL: + """ + name: KEEP-BRL + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: None + maximum_order_size: None + margin: False + """ + name: str = "KEEP-BRL" + precision: int = 8 minimum_margin: float = None initial_margin: float = None minimum_order_size: float = None @@ -219,22 +282,31 @@ class STORJ_BRL: margin: bool = False def __repr__(self): - return "STORJ-BRL" + return "KEEP-BRL" def __str__(self): - return "STORJ-BRL" + return "KEEP-BRL" def __call__(self): - return "STORJ-BRL" + return "KEEP-BRL" -STORJ_BRL = STORJ_BRL() +MBFP10_BRL = MBFP10_BRL() @dataclass(slots=True, frozen=True) -class COMP_BRL: - name: str = "COMP-BRL" - precision: int = 0.00000001 +class MBFP10_BRL: + """ + name: MBFP10-BRL + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: None + maximum_order_size: None + margin: False + """ + name: str = "MBFP10-BRL" + precision: int = 8 minimum_margin: float = None initial_margin: float = None minimum_order_size: float = None @@ -242,22 +314,31 @@ class COMP_BRL: margin: bool = False def __repr__(self): - return "COMP-BRL" + return "MBFP10-BRL" def __str__(self): - return "COMP-BRL" + return "MBFP10-BRL" def __call__(self): - return "COMP-BRL" + return "MBFP10-BRL" -COMP_BRL = COMP_BRL() +SPFCFT_BRL = SPFCFT_BRL() @dataclass(slots=True, frozen=True) -class MBFP08_BRL: - name: str = "MBFP08-BRL" - precision: int = 0.00000001 +class SPFCFT_BRL: + """ + name: SPFCFT-BRL + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: None + maximum_order_size: None + margin: False + """ + name: str = "SPFCFT-BRL" + precision: int = 8 minimum_margin: float = None initial_margin: float = None minimum_order_size: float = None @@ -265,22 +346,31 @@ class MBFP08_BRL: margin: bool = False def __repr__(self): - return "MBFP08-BRL" + return "SPFCFT-BRL" def __str__(self): - return "MBFP08-BRL" + return "SPFCFT-BRL" def __call__(self): - return "MBFP08-BRL" + return "SPFCFT-BRL" -MBFP08_BRL = MBFP08_BRL() +DG_BRL = DG_BRL() @dataclass(slots=True, frozen=True) -class BADGER_BRL: - name: str = "BADGER-BRL" - precision: int = 0.00000001 +class DG_BRL: + """ + name: DG-BRL + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: None + maximum_order_size: None + margin: False + """ + name: str = "DG-BRL" + precision: int = 8 minimum_margin: float = None initial_margin: float = None minimum_order_size: float = None @@ -288,22 +378,31 @@ class BADGER_BRL: margin: bool = False def __repr__(self): - return "BADGER-BRL" + return "DG-BRL" def __str__(self): - return "BADGER-BRL" + return "DG-BRL" def __call__(self): - return "BADGER-BRL" + return "DG-BRL" -BADGER_BRL = BADGER_BRL() +POLS_BRL = POLS_BRL() @dataclass(slots=True, frozen=True) -class RARE_BRL: - name: str = "RARE-BRL" - precision: int = 0.00000001 +class POLS_BRL: + """ + name: POLS-BRL + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: None + maximum_order_size: None + margin: False + """ + name: str = "POLS-BRL" + precision: int = 8 minimum_margin: float = None initial_margin: float = None minimum_order_size: float = None @@ -311,22 +410,31 @@ class RARE_BRL: margin: bool = False def __repr__(self): - return "RARE-BRL" + return "POLS-BRL" def __str__(self): - return "RARE-BRL" + return "POLS-BRL" def __call__(self): - return "RARE-BRL" + return "POLS-BRL" -RARE_BRL = RARE_BRL() +IMX_BRL = IMX_BRL() @dataclass(slots=True, frozen=True) -class CSCONS02_BRL: - name: str = "CSCONS02-BRL" - precision: int = 0.00000001 +class IMX_BRL: + """ + name: IMX-BRL + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: None + maximum_order_size: None + margin: False + """ + name: str = "IMX-BRL" + precision: int = 8 minimum_margin: float = None initial_margin: float = None minimum_order_size: float = None @@ -334,22 +442,31 @@ class CSCONS02_BRL: margin: bool = False def __repr__(self): - return "CSCONS02-BRL" + return "IMX-BRL" def __str__(self): - return "CSCONS02-BRL" + return "IMX-BRL" def __call__(self): - return "CSCONS02-BRL" + return "IMX-BRL" -CSCONS02_BRL = CSCONS02_BRL() +ZRX_BRL = ZRX_BRL() @dataclass(slots=True, frozen=True) -class DG_BRL: - name: str = "DG-BRL" - precision: int = 0.00000001 +class ZRX_BRL: + """ + name: ZRX-BRL + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: None + maximum_order_size: None + margin: False + """ + name: str = "ZRX-BRL" + precision: int = 8 minimum_margin: float = None initial_margin: float = None minimum_order_size: float = None @@ -357,22 +474,31 @@ class DG_BRL: margin: bool = False def __repr__(self): - return "DG-BRL" + return "ZRX-BRL" def __str__(self): - return "DG-BRL" + return "ZRX-BRL" def __call__(self): - return "DG-BRL" + return "ZRX-BRL" -DG_BRL = DG_BRL() +ABFY_BRL = ABFY_BRL() @dataclass(slots=True, frozen=True) -class ALLFT_BRL: - name: str = "ALLFT-BRL" - precision: int = 0.00000001 +class ABFY_BRL: + """ + name: ABFY-BRL + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: None + maximum_order_size: None + margin: False + """ + name: str = "ABFY-BRL" + precision: int = 8 minimum_margin: float = None initial_margin: float = None minimum_order_size: float = None @@ -380,22 +506,31 @@ class ALLFT_BRL: margin: bool = False def __repr__(self): - return "ALLFT-BRL" + return "ABFY-BRL" def __str__(self): - return "ALLFT-BRL" + return "ABFY-BRL" def __call__(self): - return "ALLFT-BRL" + return "ABFY-BRL" -ALLFT_BRL = ALLFT_BRL() +PORFT_BRL = PORFT_BRL() @dataclass(slots=True, frozen=True) -class PSGFT_BRL: - name: str = "PSGFT-BRL" - precision: int = 0.00000001 +class PORFT_BRL: + """ + name: PORFT-BRL + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: None + maximum_order_size: None + margin: False + """ + name: str = "PORFT-BRL" + precision: int = 8 minimum_margin: float = None initial_margin: float = None minimum_order_size: float = None @@ -403,22 +538,31 @@ class PSGFT_BRL: margin: bool = False def __repr__(self): - return "PSGFT-BRL" + return "PORFT-BRL" def __str__(self): - return "PSGFT-BRL" + return "PORFT-BRL" def __call__(self): - return "PSGFT-BRL" + return "PORFT-BRL" -PSGFT_BRL = PSGFT_BRL() +STX_BRL = STX_BRL() @dataclass(slots=True, frozen=True) -class ENS_BRL: - name: str = "ENS-BRL" - precision: int = 0.00000001 +class STX_BRL: + """ + name: STX-BRL + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: None + maximum_order_size: None + margin: False + """ + name: str = "STX-BRL" + precision: int = 8 minimum_margin: float = None initial_margin: float = None minimum_order_size: float = None @@ -426,22 +570,31 @@ class ENS_BRL: margin: bool = False def __repr__(self): - return "ENS-BRL" + return "STX-BRL" def __str__(self): - return "ENS-BRL" + return "STX-BRL" def __call__(self): - return "ENS-BRL" + return "STX-BRL" -ENS_BRL = ENS_BRL() +AMFT_BRL = AMFT_BRL() @dataclass(slots=True, frozen=True) -class MBPRK07_BRL: - name: str = "MBPRK07-BRL" - precision: int = 0.00000001 +class AMFT_BRL: + """ + name: AMFT-BRL + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: None + maximum_order_size: None + margin: False + """ + name: str = "AMFT-BRL" + precision: int = 8 minimum_margin: float = None initial_margin: float = None minimum_order_size: float = None @@ -449,22 +602,31 @@ class MBPRK07_BRL: margin: bool = False def __repr__(self): - return "MBPRK07-BRL" + return "AMFT-BRL" def __str__(self): - return "MBPRK07-BRL" + return "AMFT-BRL" def __call__(self): - return "MBPRK07-BRL" + return "AMFT-BRL" -MBPRK07_BRL = MBPRK07_BRL() +FET_BRL = FET_BRL() @dataclass(slots=True, frozen=True) -class AGIX_BRL: - name: str = "AGIX-BRL" - precision: int = 0.00000001 +class FET_BRL: + """ + name: FET-BRL + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: None + maximum_order_size: None + margin: False + """ + name: str = "FET-BRL" + precision: int = 8 minimum_margin: float = None initial_margin: float = None minimum_order_size: float = None @@ -472,22 +634,31 @@ class AGIX_BRL: margin: bool = False def __repr__(self): - return "AGIX-BRL" + return "FET-BRL" def __str__(self): - return "AGIX-BRL" + return "FET-BRL" def __call__(self): - return "AGIX-BRL" + return "FET-BRL" -AGIX_BRL = AGIX_BRL() +SOL_BRL = SOL_BRL() @dataclass(slots=True, frozen=True) -class ICP_BRL: - name: str = "ICP-BRL" - precision: int = 0.00000001 +class SOL_BRL: + """ + name: SOL-BRL + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: None + maximum_order_size: None + margin: False + """ + name: str = "SOL-BRL" + precision: int = 8 minimum_margin: float = None initial_margin: float = None minimum_order_size: float = None @@ -495,22 +666,31 @@ class ICP_BRL: margin: bool = False def __repr__(self): - return "ICP-BRL" + return "SOL-BRL" def __str__(self): - return "ICP-BRL" + return "SOL-BRL" def __call__(self): - return "ICP-BRL" + return "SOL-BRL" -ICP_BRL = ICP_BRL() +SKL_BRL = SKL_BRL() @dataclass(slots=True, frozen=True) -class SNX_BRL: - name: str = "SNX-BRL" - precision: int = 0.00000001 +class SKL_BRL: + """ + name: SKL-BRL + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: None + maximum_order_size: None + margin: False + """ + name: str = "SKL-BRL" + precision: int = 8 minimum_margin: float = None initial_margin: float = None minimum_order_size: float = None @@ -518,22 +698,31 @@ class SNX_BRL: margin: bool = False def __repr__(self): - return "SNX-BRL" + return "SKL-BRL" def __str__(self): - return "SNX-BRL" + return "SKL-BRL" def __call__(self): - return "SNX-BRL" + return "SKL-BRL" -SNX_BRL = SNX_BRL() +GODS_BRL = GODS_BRL() @dataclass(slots=True, frozen=True) -class SKL_BRL: - name: str = "SKL-BRL" - precision: int = 0.00000001 +class GODS_BRL: + """ + name: GODS-BRL + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: None + maximum_order_size: None + margin: False + """ + name: str = "GODS-BRL" + precision: int = 8 minimum_margin: float = None initial_margin: float = None minimum_order_size: float = None @@ -541,22 +730,31 @@ class SKL_BRL: margin: bool = False def __repr__(self): - return "SKL-BRL" + return "GODS-BRL" def __str__(self): - return "SKL-BRL" + return "GODS-BRL" def __call__(self): - return "SKL-BRL" + return "GODS-BRL" -SKL_BRL = SKL_BRL() +WBX_BRL = WBX_BRL() @dataclass(slots=True, frozen=True) -class BICO_BRL: - name: str = "BICO-BRL" - precision: int = 0.00000001 +class WBX_BRL: + """ + name: WBX-BRL + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: None + maximum_order_size: None + margin: False + """ + name: str = "WBX-BRL" + precision: int = 8 minimum_margin: float = None initial_margin: float = None minimum_order_size: float = None @@ -564,22 +762,31 @@ class BICO_BRL: margin: bool = False def __repr__(self): - return "BICO-BRL" + return "WBX-BRL" def __str__(self): - return "BICO-BRL" + return "WBX-BRL" def __call__(self): - return "BICO-BRL" + return "WBX-BRL" -BICO_BRL = BICO_BRL() +GHST_BRL = GHST_BRL() @dataclass(slots=True, frozen=True) -class WBTC_BRL: - name: str = "WBTC-BRL" - precision: int = 0.00000001 +class GHST_BRL: + """ + name: GHST-BRL + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: None + maximum_order_size: None + margin: False + """ + name: str = "GHST-BRL" + precision: int = 8 minimum_margin: float = None initial_margin: float = None minimum_order_size: float = None @@ -587,22 +794,31 @@ class WBTC_BRL: margin: bool = False def __repr__(self): - return "WBTC-BRL" + return "GHST-BRL" def __str__(self): - return "WBTC-BRL" + return "GHST-BRL" def __call__(self): - return "WBTC-BRL" + return "GHST-BRL" -WBTC_BRL = WBTC_BRL() +POWR_BRL = POWR_BRL() @dataclass(slots=True, frozen=True) -class LQTY_BRL: - name: str = "LQTY-BRL" - precision: int = 0.00000001 +class POWR_BRL: + """ + name: POWR-BRL + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: None + maximum_order_size: None + margin: False + """ + name: str = "POWR-BRL" + precision: int = 8 minimum_margin: float = None initial_margin: float = None minimum_order_size: float = None @@ -610,22 +826,31 @@ class LQTY_BRL: margin: bool = False def __repr__(self): - return "LQTY-BRL" + return "POWR-BRL" def __str__(self): - return "LQTY-BRL" + return "POWR-BRL" def __call__(self): - return "LQTY-BRL" + return "POWR-BRL" -LQTY_BRL = LQTY_BRL() +JASMY_BRL = JASMY_BRL() @dataclass(slots=True, frozen=True) -class MBRL_BRL: - name: str = "MBRL-BRL" - precision: int = 0.00000001 +class JASMY_BRL: + """ + name: JASMY-BRL + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: None + maximum_order_size: None + margin: False + """ + name: str = "JASMY-BRL" + precision: int = 8 minimum_margin: float = None initial_margin: float = None minimum_order_size: float = None @@ -633,22 +858,31 @@ class MBRL_BRL: margin: bool = False def __repr__(self): - return "MBRL-BRL" + return "JASMY-BRL" def __str__(self): - return "MBRL-BRL" + return "JASMY-BRL" def __call__(self): - return "MBRL-BRL" + return "JASMY-BRL" -MBRL_BRL = MBRL_BRL() +SLP_BRL = SLP_BRL() @dataclass(slots=True, frozen=True) -class LDO_BRL: - name: str = "LDO-BRL" - precision: int = 0.00000001 +class SLP_BRL: + """ + name: SLP-BRL + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: None + maximum_order_size: None + margin: False + """ + name: str = "SLP-BRL" + precision: int = 8 minimum_margin: float = None initial_margin: float = None minimum_order_size: float = None @@ -656,22 +890,31 @@ class LDO_BRL: margin: bool = False def __repr__(self): - return "LDO-BRL" + return "SLP-BRL" def __str__(self): - return "LDO-BRL" + return "SLP-BRL" def __call__(self): - return "LDO-BRL" + return "SLP-BRL" -LDO_BRL = LDO_BRL() +SAND_BRL = SAND_BRL() @dataclass(slots=True, frozen=True) -class MBTKN01_BRL: - name: str = "MBTKN01-BRL" - precision: int = 0.00000001 +class SAND_BRL: + """ + name: SAND-BRL + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: None + maximum_order_size: None + margin: False + """ + name: str = "SAND-BRL" + precision: int = 8 minimum_margin: float = None initial_margin: float = None minimum_order_size: float = None @@ -679,22 +922,31 @@ class MBTKN01_BRL: margin: bool = False def __repr__(self): - return "MBTKN01-BRL" + return "SAND-BRL" def __str__(self): - return "MBTKN01-BRL" + return "SAND-BRL" def __call__(self): - return "MBTKN01-BRL" + return "SAND-BRL" -MBTKN01_BRL = MBTKN01_BRL() +OMG_BRL = OMG_BRL() @dataclass(slots=True, frozen=True) -class LRC_BRL: - name: str = "LRC-BRL" - precision: int = 0.00000001 +class OMG_BRL: + """ + name: OMG-BRL + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: None + maximum_order_size: None + margin: False + """ + name: str = "OMG-BRL" + precision: int = 8 minimum_margin: float = None initial_margin: float = None minimum_order_size: float = None @@ -702,22 +954,31 @@ class LRC_BRL: margin: bool = False def __repr__(self): - return "LRC-BRL" + return "OMG-BRL" def __str__(self): - return "LRC-BRL" + return "OMG-BRL" def __call__(self): - return "LRC-BRL" + return "OMG-BRL" -LRC_BRL = LRC_BRL() +SUSHI_BRL = SUSHI_BRL() @dataclass(slots=True, frozen=True) -class POWR_BRL: - name: str = "POWR-BRL" - precision: int = 0.00000001 +class SUSHI_BRL: + """ + name: SUSHI-BRL + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: None + maximum_order_size: None + margin: False + """ + name: str = "SUSHI-BRL" + precision: int = 8 minimum_margin: float = None initial_margin: float = None minimum_order_size: float = None @@ -725,22 +986,31 @@ class POWR_BRL: margin: bool = False def __repr__(self): - return "POWR-BRL" + return "SUSHI-BRL" def __str__(self): - return "POWR-BRL" + return "SUSHI-BRL" def __call__(self): - return "POWR-BRL" + return "SUSHI-BRL" -POWR_BRL = POWR_BRL() +DAI_BRL = DAI_BRL() @dataclass(slots=True, frozen=True) -class CVC_BRL: - name: str = "CVC-BRL" - precision: int = 0.00000001 +class DAI_BRL: + """ + name: DAI-BRL + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: None + maximum_order_size: None + margin: False + """ + name: str = "DAI-BRL" + precision: int = 8 minimum_margin: float = None initial_margin: float = None minimum_order_size: float = None @@ -748,22 +1018,31 @@ class CVC_BRL: margin: bool = False def __repr__(self): - return "CVC-BRL" + return "DAI-BRL" def __str__(self): - return "CVC-BRL" + return "DAI-BRL" def __call__(self): - return "CVC-BRL" + return "DAI-BRL" -CVC_BRL = CVC_BRL() +ENS_BRL = ENS_BRL() @dataclass(slots=True, frozen=True) -class MCO2_BRL: - name: str = "MCO2-BRL" - precision: int = 0.00000001 +class ENS_BRL: + """ + name: ENS-BRL + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: None + maximum_order_size: None + margin: False + """ + name: str = "ENS-BRL" + precision: int = 8 minimum_margin: float = None initial_margin: float = None minimum_order_size: float = None @@ -771,22 +1050,31 @@ class MCO2_BRL: margin: bool = False def __repr__(self): - return "MCO2-BRL" + return "ENS-BRL" def __str__(self): - return "MCO2-BRL" + return "ENS-BRL" def __call__(self): - return "MCO2-BRL" + return "ENS-BRL" -MCO2_BRL = MCO2_BRL() +TLM_BRL = TLM_BRL() @dataclass(slots=True, frozen=True) -class MBCCSH01_BRL: - name: str = "MBCCSH01-BRL" - precision: int = 0.00000001 +class TLM_BRL: + """ + name: TLM-BRL + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: None + maximum_order_size: None + margin: False + """ + name: str = "TLM-BRL" + precision: int = 8 minimum_margin: float = None initial_margin: float = None minimum_order_size: float = None @@ -794,22 +1082,31 @@ class MBCCSH01_BRL: margin: bool = False def __repr__(self): - return "MBCCSH01-BRL" + return "TLM-BRL" def __str__(self): - return "MBCCSH01-BRL" + return "TLM-BRL" def __call__(self): - return "MBCCSH01-BRL" + return "TLM-BRL" -MBCCSH01_BRL = MBCCSH01_BRL() +MBCCSH09_BRL = MBCCSH09_BRL() @dataclass(slots=True, frozen=True) -class REQ_BRL: - name: str = "REQ-BRL" - precision: int = 0.00000001 +class MBCCSH09_BRL: + """ + name: MBCCSH09-BRL + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: None + maximum_order_size: None + margin: False + """ + name: str = "MBCCSH09-BRL" + precision: int = 8 minimum_margin: float = None initial_margin: float = None minimum_order_size: float = None @@ -817,22 +1114,31 @@ class REQ_BRL: margin: bool = False def __repr__(self): - return "REQ-BRL" + return "MBCCSH09-BRL" def __str__(self): - return "REQ-BRL" + return "MBCCSH09-BRL" def __call__(self): - return "REQ-BRL" + return "MBCCSH09-BRL" -REQ_BRL = REQ_BRL() +MBCCSH13_BRL = MBCCSH13_BRL() @dataclass(slots=True, frozen=True) -class MBCCSH15_BRL: - name: str = "MBCCSH15-BRL" - precision: int = 0.00000001 +class MBCCSH13_BRL: + """ + name: MBCCSH13-BRL + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: None + maximum_order_size: None + margin: False + """ + name: str = "MBCCSH13-BRL" + precision: int = 8 minimum_margin: float = None initial_margin: float = None minimum_order_size: float = None @@ -840,22 +1146,31 @@ class MBCCSH15_BRL: margin: bool = False def __repr__(self): - return "MBCCSH15-BRL" + return "MBCCSH13-BRL" def __str__(self): - return "MBCCSH15-BRL" + return "MBCCSH13-BRL" def __call__(self): - return "MBCCSH15-BRL" + return "MBCCSH13-BRL" -MBCCSH15_BRL = MBCCSH15_BRL() +MBCCSH08_BRL = MBCCSH08_BRL() @dataclass(slots=True, frozen=True) -class TRU_BRL: - name: str = "TRU-BRL" - precision: int = 0.00000001 +class MBCCSH08_BRL: + """ + name: MBCCSH08-BRL + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: None + maximum_order_size: None + margin: False + """ + name: str = "MBCCSH08-BRL" + precision: int = 8 minimum_margin: float = None initial_margin: float = None minimum_order_size: float = None @@ -863,22 +1178,31 @@ class TRU_BRL: margin: bool = False def __repr__(self): - return "TRU-BRL" + return "MBCCSH08-BRL" def __str__(self): - return "TRU-BRL" + return "MBCCSH08-BRL" def __call__(self): - return "TRU-BRL" + return "MBCCSH08-BRL" -TRU_BRL = TRU_BRL() +PSGFT_BRL = PSGFT_BRL() @dataclass(slots=True, frozen=True) -class ABFY_BRL: - name: str = "ABFY-BRL" - precision: int = 0.00000001 +class PSGFT_BRL: + """ + name: PSGFT-BRL + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: None + maximum_order_size: None + margin: False + """ + name: str = "PSGFT-BRL" + precision: int = 8 minimum_margin: float = None initial_margin: float = None minimum_order_size: float = None @@ -886,22 +1210,31 @@ class ABFY_BRL: margin: bool = False def __repr__(self): - return "ABFY-BRL" + return "PSGFT-BRL" def __str__(self): - return "ABFY-BRL" + return "PSGFT-BRL" def __call__(self): - return "ABFY-BRL" + return "PSGFT-BRL" -ABFY_BRL = ABFY_BRL() +DOT_BRL = DOT_BRL() @dataclass(slots=True, frozen=True) -class BLZ_BRL: - name: str = "BLZ-BRL" - precision: int = 0.00000001 +class DOT_BRL: + """ + name: DOT-BRL + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: None + maximum_order_size: None + margin: False + """ + name: str = "DOT-BRL" + precision: int = 8 minimum_margin: float = None initial_margin: float = None minimum_order_size: float = None @@ -909,22 +1242,31 @@ class BLZ_BRL: margin: bool = False def __repr__(self): - return "BLZ-BRL" + return "DOT-BRL" def __str__(self): - return "BLZ-BRL" + return "DOT-BRL" def __call__(self): - return "BLZ-BRL" + return "DOT-BRL" -BLZ_BRL = BLZ_BRL() +ATLAS_BRL = ATLAS_BRL() @dataclass(slots=True, frozen=True) -class OMG_BRL: - name: str = "OMG-BRL" - precision: int = 0.00000001 +class ATLAS_BRL: + """ + name: ATLAS-BRL + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: None + maximum_order_size: None + margin: False + """ + name: str = "ATLAS-BRL" + precision: int = 8 minimum_margin: float = None initial_margin: float = None minimum_order_size: float = None @@ -932,22 +1274,31 @@ class OMG_BRL: margin: bool = False def __repr__(self): - return "OMG-BRL" + return "ATLAS-BRL" def __str__(self): - return "OMG-BRL" + return "ATLAS-BRL" def __call__(self): - return "OMG-BRL" + return "ATLAS-BRL" -OMG_BRL = OMG_BRL() +LRC_BRL = LRC_BRL() @dataclass(slots=True, frozen=True) -class SCCPFT_BRL: - name: str = "SCCPFT-BRL" - precision: int = 0.00000001 +class LRC_BRL: + """ + name: LRC-BRL + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: None + maximum_order_size: None + margin: False + """ + name: str = "LRC-BRL" + precision: int = 8 minimum_margin: float = None initial_margin: float = None minimum_order_size: float = None @@ -955,22 +1306,31 @@ class SCCPFT_BRL: margin: bool = False def __repr__(self): - return "SCCPFT-BRL" + return "LRC-BRL" def __str__(self): - return "SCCPFT-BRL" + return "LRC-BRL" def __call__(self): - return "SCCPFT-BRL" + return "LRC-BRL" -SCCPFT_BRL = SCCPFT_BRL() +AGIX_BRL = AGIX_BRL() @dataclass(slots=True, frozen=True) -class ANKR_BRL: - name: str = "ANKR-BRL" - precision: int = 0.00000001 +class AGIX_BRL: + """ + name: AGIX-BRL + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: None + maximum_order_size: None + margin: False + """ + name: str = "AGIX-BRL" + precision: int = 8 minimum_margin: float = None initial_margin: float = None minimum_order_size: float = None @@ -978,22 +1338,31 @@ class ANKR_BRL: margin: bool = False def __repr__(self): - return "ANKR-BRL" + return "AGIX-BRL" def __str__(self): - return "ANKR-BRL" + return "AGIX-BRL" def __call__(self): - return "ANKR-BRL" + return "AGIX-BRL" -ANKR_BRL = ANKR_BRL() +CEEK_BRL = CEEK_BRL() @dataclass(slots=True, frozen=True) -class LINK_BRL: - name: str = "LINK-BRL" - precision: int = 0.00000001 +class CEEK_BRL: + """ + name: CEEK-BRL + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: None + maximum_order_size: None + margin: False + """ + name: str = "CEEK-BRL" + precision: int = 8 minimum_margin: float = None initial_margin: float = None minimum_order_size: float = None @@ -1001,22 +1370,31 @@ class LINK_BRL: margin: bool = False def __repr__(self): - return "LINK-BRL" + return "CEEK-BRL" def __str__(self): - return "LINK-BRL" + return "CEEK-BRL" def __call__(self): - return "LINK-BRL" + return "CEEK-BRL" -LINK_BRL = LINK_BRL() +UFCFT_BRL = UFCFT_BRL() @dataclass(slots=True, frozen=True) -class AMFT_BRL: - name: str = "AMFT-BRL" - precision: int = 0.00000001 +class UFCFT_BRL: + """ + name: UFCFT-BRL + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: None + maximum_order_size: None + margin: False + """ + name: str = "UFCFT-BRL" + precision: int = 8 minimum_margin: float = None initial_margin: float = None minimum_order_size: float = None @@ -1024,22 +1402,31 @@ class AMFT_BRL: margin: bool = False def __repr__(self): - return "AMFT-BRL" + return "UFCFT-BRL" def __str__(self): - return "AMFT-BRL" + return "UFCFT-BRL" def __call__(self): - return "AMFT-BRL" + return "UFCFT-BRL" -AMFT_BRL = AMFT_BRL() +BTC_BRL = BTC_BRL() @dataclass(slots=True, frozen=True) -class GHST_BRL: - name: str = "GHST-BRL" - precision: int = 0.00000001 +class BTC_BRL: + """ + name: BTC-BRL + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: None + maximum_order_size: None + margin: False + """ + name: str = "BTC-BRL" + precision: int = 8 minimum_margin: float = None initial_margin: float = None minimum_order_size: float = None @@ -1047,22 +1434,31 @@ class GHST_BRL: margin: bool = False def __repr__(self): - return "GHST-BRL" + return "BTC-BRL" def __str__(self): - return "GHST-BRL" + return "BTC-BRL" def __call__(self): - return "GHST-BRL" + return "BTC-BRL" -GHST_BRL = GHST_BRL() +LOOKS_BRL = LOOKS_BRL() @dataclass(slots=True, frozen=True) -class STG_BRL: - name: str = "STG-BRL" - precision: int = 0.00000001 +class LOOKS_BRL: + """ + name: LOOKS-BRL + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: None + maximum_order_size: None + margin: False + """ + name: str = "LOOKS-BRL" + precision: int = 8 minimum_margin: float = None initial_margin: float = None minimum_order_size: float = None @@ -1070,22 +1466,31 @@ class STG_BRL: margin: bool = False def __repr__(self): - return "STG-BRL" + return "LOOKS-BRL" def __str__(self): - return "STG-BRL" + return "LOOKS-BRL" def __call__(self): - return "STG-BRL" + return "LOOKS-BRL" -STG_BRL = STG_BRL() +GALFT_BRL = GALFT_BRL() @dataclass(slots=True, frozen=True) -class JASMY_BRL: - name: str = "JASMY-BRL" - precision: int = 0.00000001 +class GALFT_BRL: + """ + name: GALFT-BRL + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: None + maximum_order_size: None + margin: False + """ + name: str = "GALFT-BRL" + precision: int = 8 minimum_margin: float = None initial_margin: float = None minimum_order_size: float = None @@ -1093,22 +1498,31 @@ class JASMY_BRL: margin: bool = False def __repr__(self): - return "JASMY-BRL" + return "GALFT-BRL" def __str__(self): - return "JASMY-BRL" + return "GALFT-BRL" def __call__(self): - return "JASMY-BRL" + return "GALFT-BRL" -JASMY_BRL = JASMY_BRL() +DOGE_BRL = DOGE_BRL() @dataclass(slots=True, frozen=True) -class AAVE_BRL: - name: str = "AAVE-BRL" - precision: int = 0.00000001 +class DOGE_BRL: + """ + name: DOGE-BRL + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: None + maximum_order_size: None + margin: False + """ + name: str = "DOGE-BRL" + precision: int = 8 minimum_margin: float = None initial_margin: float = None minimum_order_size: float = None @@ -1116,22 +1530,31 @@ class AAVE_BRL: margin: bool = False def __repr__(self): - return "AAVE-BRL" + return "DOGE-BRL" def __str__(self): - return "AAVE-BRL" + return "DOGE-BRL" def __call__(self): - return "AAVE-BRL" + return "DOGE-BRL" -AAVE_BRL = AAVE_BRL() +MBCCSH01_BRL = MBCCSH01_BRL() @dataclass(slots=True, frozen=True) -class CONS01_BRL: - name: str = "CONS01-BRL" - precision: int = 0.00000001 +class MBCCSH01_BRL: + """ + name: MBCCSH01-BRL + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: None + maximum_order_size: None + margin: False + """ + name: str = "MBCCSH01-BRL" + precision: int = 8 minimum_margin: float = None initial_margin: float = None minimum_order_size: float = None @@ -1139,22 +1562,31 @@ class CONS01_BRL: margin: bool = False def __repr__(self): - return "CONS01-BRL" + return "MBCCSH01-BRL" def __str__(self): - return "CONS01-BRL" + return "MBCCSH01-BRL" def __call__(self): - return "CONS01-BRL" + return "MBCCSH01-BRL" -CONS01_BRL = CONS01_BRL() +MBPRK03_BRL = MBPRK03_BRL() @dataclass(slots=True, frozen=True) -class CLV_BRL: - name: str = "CLV-BRL" - precision: int = 0.00000001 +class MBPRK03_BRL: + """ + name: MBPRK03-BRL + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: None + maximum_order_size: None + margin: False + """ + name: str = "MBPRK03-BRL" + precision: int = 8 minimum_margin: float = None initial_margin: float = None minimum_order_size: float = None @@ -1162,22 +1594,31 @@ class CLV_BRL: margin: bool = False def __repr__(self): - return "CLV-BRL" + return "MBPRK03-BRL" def __str__(self): - return "CLV-BRL" + return "MBPRK03-BRL" def __call__(self): - return "CLV-BRL" + return "MBPRK03-BRL" -CLV_BRL = CLV_BRL() +MVI_BRL = MVI_BRL() @dataclass(slots=True, frozen=True) -class NODL_BRL: - name: str = "NODL-BRL" - precision: int = 0.00000001 +class MVI_BRL: + """ + name: MVI-BRL + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: None + maximum_order_size: None + margin: False + """ + name: str = "MVI-BRL" + precision: int = 8 minimum_margin: float = None initial_margin: float = None minimum_order_size: float = None @@ -1185,22 +1626,31 @@ class NODL_BRL: margin: bool = False def __repr__(self): - return "NODL-BRL" + return "MVI-BRL" def __str__(self): - return "NODL-BRL" + return "MVI-BRL" def __call__(self): - return "NODL-BRL" + return "MVI-BRL" -NODL_BRL = NODL_BRL() +MBCCSH16_BRL = MBCCSH16_BRL() @dataclass(slots=True, frozen=True) -class SYN_BRL: - name: str = "SYN-BRL" - precision: int = 0.00000001 +class MBCCSH16_BRL: + """ + name: MBCCSH16-BRL + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: None + maximum_order_size: None + margin: False + """ + name: str = "MBCCSH16-BRL" + precision: int = 8 minimum_margin: float = None initial_margin: float = None minimum_order_size: float = None @@ -1208,22 +1658,31 @@ class SYN_BRL: margin: bool = False def __repr__(self): - return "SYN-BRL" + return "MBCCSH16-BRL" def __str__(self): - return "SYN-BRL" + return "MBCCSH16-BRL" def __call__(self): - return "SYN-BRL" + return "MBCCSH16-BRL" -SYN_BRL = SYN_BRL() +SCCPFT_BRL = SCCPFT_BRL() @dataclass(slots=True, frozen=True) -class OGN_BRL: - name: str = "OGN-BRL" - precision: int = 0.00000001 +class SCCPFT_BRL: + """ + name: SCCPFT-BRL + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: None + maximum_order_size: None + margin: False + """ + name: str = "SCCPFT-BRL" + precision: int = 8 minimum_margin: float = None initial_margin: float = None minimum_order_size: float = None @@ -1231,22 +1690,31 @@ class OGN_BRL: margin: bool = False def __repr__(self): - return "OGN-BRL" + return "SCCPFT-BRL" def __str__(self): - return "OGN-BRL" + return "SCCPFT-BRL" def __call__(self): - return "OGN-BRL" + return "SCCPFT-BRL" -OGN_BRL = OGN_BRL() +MBCCSH11_BRL = MBCCSH11_BRL() @dataclass(slots=True, frozen=True) -class CAIFT_BRL: - name: str = "CAIFT-BRL" - precision: int = 0.00000001 +class MBCCSH11_BRL: + """ + name: MBCCSH11-BRL + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: None + maximum_order_size: None + margin: False + """ + name: str = "MBCCSH11-BRL" + precision: int = 8 minimum_margin: float = None initial_margin: float = None minimum_order_size: float = None @@ -1254,22 +1722,31 @@ class CAIFT_BRL: margin: bool = False def __repr__(self): - return "CAIFT-BRL" + return "MBCCSH11-BRL" def __str__(self): - return "CAIFT-BRL" + return "MBCCSH11-BRL" def __call__(self): - return "CAIFT-BRL" + return "MBCCSH11-BRL" -CAIFT_BRL = CAIFT_BRL() +PLA_BRL = PLA_BRL() @dataclass(slots=True, frozen=True) -class BAND_BRL: - name: str = "BAND-BRL" - precision: int = 0.00000001 +class PLA_BRL: + """ + name: PLA-BRL + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: None + maximum_order_size: None + margin: False + """ + name: str = "PLA-BRL" + precision: int = 8 minimum_margin: float = None initial_margin: float = None minimum_order_size: float = None @@ -1277,22 +1754,31 @@ class BAND_BRL: margin: bool = False def __repr__(self): - return "BAND-BRL" + return "PLA-BRL" def __str__(self): - return "BAND-BRL" + return "PLA-BRL" def __call__(self): - return "BAND-BRL" + return "PLA-BRL" -BAND_BRL = BAND_BRL() +MCO2_BRL = MCO2_BRL() @dataclass(slots=True, frozen=True) -class SPFCFT_BRL: - name: str = "SPFCFT-BRL" - precision: int = 0.00000001 +class MCO2_BRL: + """ + name: MCO2-BRL + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: None + maximum_order_size: None + margin: False + """ + name: str = "MCO2-BRL" + precision: int = 8 minimum_margin: float = None initial_margin: float = None minimum_order_size: float = None @@ -1300,22 +1786,31 @@ class SPFCFT_BRL: margin: bool = False def __repr__(self): - return "SPFCFT-BRL" + return "MCO2-BRL" def __str__(self): - return "SPFCFT-BRL" + return "MCO2-BRL" def __call__(self): - return "SPFCFT-BRL" + return "MCO2-BRL" -SPFCFT_BRL = SPFCFT_BRL() +CSCONS01_BRL = CSCONS01_BRL() @dataclass(slots=True, frozen=True) -class SLP_BRL: - name: str = "SLP-BRL" - precision: int = 0.00000001 +class CSCONS01_BRL: + """ + name: CSCONS01-BRL + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: None + maximum_order_size: None + margin: False + """ + name: str = "CSCONS01-BRL" + precision: int = 8 minimum_margin: float = None initial_margin: float = None minimum_order_size: float = None @@ -1323,22 +1818,31 @@ class SLP_BRL: margin: bool = False def __repr__(self): - return "SLP-BRL" + return "CSCONS01-BRL" def __str__(self): - return "SLP-BRL" + return "CSCONS01-BRL" def __call__(self): - return "SLP-BRL" + return "CSCONS01-BRL" -SLP_BRL = SLP_BRL() +TRB_BRL = TRB_BRL() @dataclass(slots=True, frozen=True) -class ZRX_BRL: - name: str = "ZRX-BRL" - precision: int = 0.00000001 +class TRB_BRL: + """ + name: TRB-BRL + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: None + maximum_order_size: None + margin: False + """ + name: str = "TRB-BRL" + precision: int = 8 minimum_margin: float = None initial_margin: float = None minimum_order_size: float = None @@ -1346,22 +1850,31 @@ class ZRX_BRL: margin: bool = False def __repr__(self): - return "ZRX-BRL" + return "TRB-BRL" def __str__(self): - return "ZRX-BRL" + return "TRB-BRL" def __call__(self): - return "ZRX-BRL" + return "TRB-BRL" -ZRX_BRL = ZRX_BRL() +MBRL_BRL = MBRL_BRL() @dataclass(slots=True, frozen=True) -class AVAX_BRL: - name: str = "AVAX-BRL" - precision: int = 0.00000001 +class MBRL_BRL: + """ + name: MBRL-BRL + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: None + maximum_order_size: None + margin: False + """ + name: str = "MBRL-BRL" + precision: int = 8 minimum_margin: float = None initial_margin: float = None minimum_order_size: float = None @@ -1369,22 +1882,31 @@ class AVAX_BRL: margin: bool = False def __repr__(self): - return "AVAX-BRL" + return "MBRL-BRL" def __str__(self): - return "AVAX-BRL" + return "MBRL-BRL" def __call__(self): - return "AVAX-BRL" + return "MBRL-BRL" -AVAX_BRL = AVAX_BRL() +RFDFP16_BRL = RFDFP16_BRL() @dataclass(slots=True, frozen=True) -class BCH_BRL: - name: str = "BCH-BRL" - precision: int = 0.00000001 +class RFDFP16_BRL: + """ + name: RFDFP16-BRL + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: None + maximum_order_size: None + margin: False + """ + name: str = "RFDFP16-BRL" + precision: int = 8 minimum_margin: float = None initial_margin: float = None minimum_order_size: float = None @@ -1392,22 +1914,31 @@ class BCH_BRL: margin: bool = False def __repr__(self): - return "BCH-BRL" + return "RFDFP16-BRL" def __str__(self): - return "BCH-BRL" + return "RFDFP16-BRL" def __call__(self): - return "BCH-BRL" + return "RFDFP16-BRL" -BCH_BRL = BCH_BRL() +ASRFT_BRL = ASRFT_BRL() @dataclass(slots=True, frozen=True) -class UMA_BRL: - name: str = "UMA-BRL" - precision: int = 0.00000001 +class ASRFT_BRL: + """ + name: ASRFT-BRL + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: None + maximum_order_size: None + margin: False + """ + name: str = "ASRFT-BRL" + precision: int = 8 minimum_margin: float = None initial_margin: float = None minimum_order_size: float = None @@ -1415,22 +1946,31 @@ class UMA_BRL: margin: bool = False def __repr__(self): - return "UMA-BRL" + return "ASRFT-BRL" def __str__(self): - return "UMA-BRL" + return "ASRFT-BRL" def __call__(self): - return "UMA-BRL" + return "ASRFT-BRL" -UMA_BRL = UMA_BRL() +ACH_BRL = ACH_BRL() @dataclass(slots=True, frozen=True) -class POLS_BRL: - name: str = "POLS-BRL" - precision: int = 0.00000001 +class ACH_BRL: + """ + name: ACH-BRL + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: None + maximum_order_size: None + margin: False + """ + name: str = "ACH-BRL" + precision: int = 8 minimum_margin: float = None initial_margin: float = None minimum_order_size: float = None @@ -1438,22 +1978,31 @@ class POLS_BRL: margin: bool = False def __repr__(self): - return "POLS-BRL" + return "ACH-BRL" def __str__(self): - return "POLS-BRL" + return "ACH-BRL" def __call__(self): - return "POLS-BRL" + return "ACH-BRL" -POLS_BRL = POLS_BRL() +MBCCSH14_BRL = MBCCSH14_BRL() @dataclass(slots=True, frozen=True) -class MBFP13_BRL: - name: str = "MBFP13-BRL" - precision: int = 0.00000001 +class MBCCSH14_BRL: + """ + name: MBCCSH14-BRL + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: None + maximum_order_size: None + margin: False + """ + name: str = "MBCCSH14-BRL" + precision: int = 8 minimum_margin: float = None initial_margin: float = None minimum_order_size: float = None @@ -1461,22 +2010,31 @@ class MBFP13_BRL: margin: bool = False def __repr__(self): - return "MBFP13-BRL" + return "MBCCSH14-BRL" def __str__(self): - return "MBFP13-BRL" + return "MBCCSH14-BRL" def __call__(self): - return "MBFP13-BRL" + return "MBCCSH14-BRL" -MBFP13_BRL = MBFP13_BRL() +XLM_BRL = XLM_BRL() @dataclass(slots=True, frozen=True) -class MBCCSH16_BRL: - name: str = "MBCCSH16-BRL" - precision: int = 0.00000001 +class XLM_BRL: + """ + name: XLM-BRL + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: None + maximum_order_size: None + margin: False + """ + name: str = "XLM-BRL" + precision: int = 8 minimum_margin: float = None initial_margin: float = None minimum_order_size: float = None @@ -1484,22 +2042,31 @@ class MBCCSH16_BRL: margin: bool = False def __repr__(self): - return "MBCCSH16-BRL" + return "XLM-BRL" def __str__(self): - return "MBCCSH16-BRL" + return "XLM-BRL" def __call__(self): - return "MBCCSH16-BRL" + return "XLM-BRL" -MBCCSH16_BRL = MBCCSH16_BRL() +GALOFT_BRL = GALOFT_BRL() @dataclass(slots=True, frozen=True) -class RAD_BRL: - name: str = "RAD-BRL" - precision: int = 0.00000001 +class GALOFT_BRL: + """ + name: GALOFT-BRL + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: None + maximum_order_size: None + margin: False + """ + name: str = "GALOFT-BRL" + precision: int = 8 minimum_margin: float = None initial_margin: float = None minimum_order_size: float = None @@ -1507,22 +2074,31 @@ class RAD_BRL: margin: bool = False def __repr__(self): - return "RAD-BRL" + return "GALOFT-BRL" def __str__(self): - return "RAD-BRL" + return "GALOFT-BRL" def __call__(self): - return "RAD-BRL" + return "GALOFT-BRL" -RAD_BRL = RAD_BRL() +PERP_BRL = PERP_BRL() @dataclass(slots=True, frozen=True) -class LTC_BRL: - name: str = "LTC-BRL" - precision: int = 0.00000001 +class PERP_BRL: + """ + name: PERP-BRL + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: None + maximum_order_size: None + margin: False + """ + name: str = "PERP-BRL" + precision: int = 8 minimum_margin: float = None initial_margin: float = None minimum_order_size: float = None @@ -1530,22 +2106,31 @@ class LTC_BRL: margin: bool = False def __repr__(self): - return "LTC-BRL" + return "PERP-BRL" def __str__(self): - return "LTC-BRL" + return "PERP-BRL" def __call__(self): - return "LTC-BRL" + return "PERP-BRL" -LTC_BRL = LTC_BRL() +MBTKN01_BRL = MBTKN01_BRL() @dataclass(slots=True, frozen=True) -class KNC_BRL: - name: str = "KNC-BRL" - precision: int = 0.00000001 +class MBTKN01_BRL: + """ + name: MBTKN01-BRL + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: None + maximum_order_size: None + margin: False + """ + name: str = "MBTKN01-BRL" + precision: int = 8 minimum_margin: float = None initial_margin: float = None minimum_order_size: float = None @@ -1553,22 +2138,31 @@ class KNC_BRL: margin: bool = False def __repr__(self): - return "KNC-BRL" + return "MBTKN01-BRL" def __str__(self): - return "KNC-BRL" + return "MBTKN01-BRL" def __call__(self): - return "KNC-BRL" + return "MBTKN01-BRL" -KNC_BRL = KNC_BRL() +AAVE_BRL = AAVE_BRL() @dataclass(slots=True, frozen=True) -class TLM_BRL: - name: str = "TLM-BRL" - precision: int = 0.00000001 +class AAVE_BRL: + """ + name: AAVE-BRL + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: None + maximum_order_size: None + margin: False + """ + name: str = "AAVE-BRL" + precision: int = 8 minimum_margin: float = None initial_margin: float = None minimum_order_size: float = None @@ -1576,22 +2170,31 @@ class TLM_BRL: margin: bool = False def __repr__(self): - return "TLM-BRL" + return "AAVE-BRL" def __str__(self): - return "TLM-BRL" + return "AAVE-BRL" def __call__(self): - return "TLM-BRL" + return "AAVE-BRL" -TLM_BRL = TLM_BRL() +TRU_BRL = TRU_BRL() @dataclass(slots=True, frozen=True) -class MATIC_BRL: - name: str = "MATIC-BRL" - precision: int = 0.00000001 +class TRU_BRL: + """ + name: TRU-BRL + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: None + maximum_order_size: None + margin: False + """ + name: str = "TRU-BRL" + precision: int = 8 minimum_margin: float = None initial_margin: float = None minimum_order_size: float = None @@ -1599,22 +2202,31 @@ class MATIC_BRL: margin: bool = False def __repr__(self): - return "MATIC-BRL" + return "TRU-BRL" def __str__(self): - return "MATIC-BRL" + return "TRU-BRL" def __call__(self): - return "MATIC-BRL" + return "TRU-BRL" -MATIC_BRL = MATIC_BRL() +GST_BRL = GST_BRL() @dataclass(slots=True, frozen=True) -class SOL_BRL: - name: str = "SOL-BRL" - precision: int = 0.00000001 +class GST_BRL: + """ + name: GST-BRL + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: None + maximum_order_size: None + margin: False + """ + name: str = "GST-BRL" + precision: int = 8 minimum_margin: float = None initial_margin: float = None minimum_order_size: float = None @@ -1622,22 +2234,31 @@ class SOL_BRL: margin: bool = False def __repr__(self): - return "SOL-BRL" + return "GST-BRL" def __str__(self): - return "SOL-BRL" + return "GST-BRL" def __call__(self): - return "SOL-BRL" + return "GST-BRL" -SOL_BRL = SOL_BRL() +CSCONS03_BRL = CSCONS03_BRL() @dataclass(slots=True, frozen=True) -class RACA_BRL: - name: str = "RACA-BRL" - precision: int = 0.00000001 +class CSCONS03_BRL: + """ + name: CSCONS03-BRL + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: None + maximum_order_size: None + margin: False + """ + name: str = "CSCONS03-BRL" + precision: int = 8 minimum_margin: float = None initial_margin: float = None minimum_order_size: float = None @@ -1645,22 +2266,31 @@ class RACA_BRL: margin: bool = False def __repr__(self): - return "RACA-BRL" + return "CSCONS03-BRL" def __str__(self): - return "RACA-BRL" + return "CSCONS03-BRL" def __call__(self): - return "RACA-BRL" + return "CSCONS03-BRL" -RACA_BRL = RACA_BRL() +MBFP13_BRL = MBFP13_BRL() @dataclass(slots=True, frozen=True) -class RNDR_BRL: - name: str = "RNDR-BRL" - precision: int = 0.00000001 +class MBFP13_BRL: + """ + name: MBFP13-BRL + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: None + maximum_order_size: None + margin: False + """ + name: str = "MBFP13-BRL" + precision: int = 8 minimum_margin: float = None initial_margin: float = None minimum_order_size: float = None @@ -1668,22 +2298,31 @@ class RNDR_BRL: margin: bool = False def __repr__(self): - return "RNDR-BRL" + return "MBFP13-BRL" def __str__(self): - return "RNDR-BRL" + return "MBFP13-BRL" def __call__(self): - return "RNDR-BRL" + return "MBFP13-BRL" -RNDR_BRL = RNDR_BRL() +CVX_BRL = CVX_BRL() @dataclass(slots=True, frozen=True) -class GODS_BRL: - name: str = "GODS-BRL" - precision: int = 0.00000001 +class CVX_BRL: + """ + name: CVX-BRL + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: None + maximum_order_size: None + margin: False + """ + name: str = "CVX-BRL" + precision: int = 8 minimum_margin: float = None initial_margin: float = None minimum_order_size: float = None @@ -1691,22 +2330,31 @@ class GODS_BRL: margin: bool = False def __repr__(self): - return "GODS-BRL" + return "CVX-BRL" def __str__(self): - return "GODS-BRL" + return "CVX-BRL" def __call__(self): - return "GODS-BRL" + return "CVX-BRL" -GODS_BRL = GODS_BRL() +MINA_BRL = MINA_BRL() @dataclass(slots=True, frozen=True) -class SRM_BRL: - name: str = "SRM-BRL" - precision: int = 0.00000001 +class MINA_BRL: + """ + name: MINA-BRL + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: None + maximum_order_size: None + margin: False + """ + name: str = "MINA-BRL" + precision: int = 8 minimum_margin: float = None initial_margin: float = None minimum_order_size: float = None @@ -1714,22 +2362,31 @@ class SRM_BRL: margin: bool = False def __repr__(self): - return "SRM-BRL" + return "MINA-BRL" def __str__(self): - return "SRM-BRL" + return "MINA-BRL" def __call__(self): - return "SRM-BRL" + return "MINA-BRL" -SRM_BRL = SRM_BRL() +MBCCSH05_BRL = MBCCSH05_BRL() @dataclass(slots=True, frozen=True) -class MBFP14_BRL: - name: str = "MBFP14-BRL" - precision: int = 0.00000001 +class MBCCSH05_BRL: + """ + name: MBCCSH05-BRL + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: None + maximum_order_size: None + margin: False + """ + name: str = "MBCCSH05-BRL" + precision: int = 8 minimum_margin: float = None initial_margin: float = None minimum_order_size: float = None @@ -1737,22 +2394,31 @@ class MBFP14_BRL: margin: bool = False def __repr__(self): - return "MBFP14-BRL" + return "MBCCSH05-BRL" def __str__(self): - return "MBFP14-BRL" + return "MBCCSH05-BRL" def __call__(self): - return "MBFP14-BRL" + return "MBCCSH05-BRL" -MBFP14_BRL = MBFP14_BRL() +MPL_BRL = MPL_BRL() @dataclass(slots=True, frozen=True) -class SHIB_BRL: - name: str = "SHIB-BRL" - precision: int = 0.00000001 +class MPL_BRL: + """ + name: MPL-BRL + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: None + maximum_order_size: None + margin: False + """ + name: str = "MPL-BRL" + precision: int = 8 minimum_margin: float = None initial_margin: float = None minimum_order_size: float = None @@ -1760,22 +2426,31 @@ class SHIB_BRL: margin: bool = False def __repr__(self): - return "SHIB-BRL" + return "MPL-BRL" def __str__(self): - return "SHIB-BRL" + return "MPL-BRL" def __call__(self): - return "SHIB-BRL" + return "MPL-BRL" -SHIB_BRL = SHIB_BRL() +PAXG_BRL = PAXG_BRL() @dataclass(slots=True, frozen=True) -class MBFP09_BRL: - name: str = "MBFP09-BRL" - precision: int = 0.00000001 +class PAXG_BRL: + """ + name: PAXG-BRL + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: None + maximum_order_size: None + margin: False + """ + name: str = "PAXG-BRL" + precision: int = 8 minimum_margin: float = None initial_margin: float = None minimum_order_size: float = None @@ -1783,22 +2458,31 @@ class MBFP09_BRL: margin: bool = False def __repr__(self): - return "MBFP09-BRL" + return "PAXG-BRL" def __str__(self): - return "MBFP09-BRL" + return "PAXG-BRL" def __call__(self): - return "MBFP09-BRL" + return "PAXG-BRL" -MBFP09_BRL = MBFP09_BRL() +BCH_BRL = BCH_BRL() @dataclass(slots=True, frozen=True) -class MBFP15_BRL: - name: str = "MBFP15-BRL" - precision: int = 0.00000001 +class BCH_BRL: + """ + name: BCH-BRL + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: None + maximum_order_size: None + margin: False + """ + name: str = "BCH-BRL" + precision: int = 8 minimum_margin: float = None initial_margin: float = None minimum_order_size: float = None @@ -1806,22 +2490,31 @@ class MBFP15_BRL: margin: bool = False def __repr__(self): - return "MBFP15-BRL" + return "BCH-BRL" def __str__(self): - return "MBFP15-BRL" + return "BCH-BRL" def __call__(self): - return "MBFP15-BRL" + return "BCH-BRL" -MBFP15_BRL = MBFP15_BRL() +VSPRK01_BRL = VSPRK01_BRL() @dataclass(slots=True, frozen=True) -class DPI_BRL: - name: str = "DPI-BRL" - precision: int = 0.00000001 +class VSPRK01_BRL: + """ + name: VSPRK01-BRL + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: None + maximum_order_size: None + margin: False + """ + name: str = "VSPRK01-BRL" + precision: int = 8 minimum_margin: float = None initial_margin: float = None minimum_order_size: float = None @@ -1829,22 +2522,31 @@ class DPI_BRL: margin: bool = False def __repr__(self): - return "DPI-BRL" + return "VSPRK01-BRL" def __str__(self): - return "DPI-BRL" + return "VSPRK01-BRL" def __call__(self): - return "DPI-BRL" + return "VSPRK01-BRL" -DPI_BRL = DPI_BRL() +OGN_BRL = OGN_BRL() @dataclass(slots=True, frozen=True) -class GALA_BRL: - name: str = "GALA-BRL" - precision: int = 0.00000001 +class OGN_BRL: + """ + name: OGN-BRL + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: None + maximum_order_size: None + margin: False + """ + name: str = "OGN-BRL" + precision: int = 8 minimum_margin: float = None initial_margin: float = None minimum_order_size: float = None @@ -1852,22 +2554,31 @@ class GALA_BRL: margin: bool = False def __repr__(self): - return "GALA-BRL" + return "OGN-BRL" def __str__(self): - return "GALA-BRL" + return "OGN-BRL" def __call__(self): - return "GALA-BRL" + return "OGN-BRL" -GALA_BRL = GALA_BRL() +SDAO_BRL = SDAO_BRL() @dataclass(slots=True, frozen=True) -class MBPRK01_BRL: - name: str = "MBPRK01-BRL" - precision: int = 0.00000001 +class SDAO_BRL: + """ + name: SDAO-BRL + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: None + maximum_order_size: None + margin: False + """ + name: str = "SDAO-BRL" + precision: int = 8 minimum_margin: float = None initial_margin: float = None minimum_order_size: float = None @@ -1875,22 +2586,31 @@ class MBPRK01_BRL: margin: bool = False def __repr__(self): - return "MBPRK01-BRL" + return "SDAO-BRL" def __str__(self): - return "MBPRK01-BRL" + return "SDAO-BRL" def __call__(self): - return "MBPRK01-BRL" + return "SDAO-BRL" -MBPRK01_BRL = MBPRK01_BRL() +CONS01_BRL = CONS01_BRL() @dataclass(slots=True, frozen=True) -class MBPRK06_BRL: - name: str = "MBPRK06-BRL" - precision: int = 0.00000001 +class CONS01_BRL: + """ + name: CONS01-BRL + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: None + maximum_order_size: None + margin: False + """ + name: str = "CONS01-BRL" + precision: int = 8 minimum_margin: float = None initial_margin: float = None minimum_order_size: float = None @@ -1898,22 +2618,31 @@ class MBPRK06_BRL: margin: bool = False def __repr__(self): - return "MBPRK06-BRL" + return "CONS01-BRL" def __str__(self): - return "MBPRK06-BRL" + return "CONS01-BRL" def __call__(self): - return "MBPRK06-BRL" + return "CONS01-BRL" -MBPRK06_BRL = MBPRK06_BRL() +GNO_BRL = GNO_BRL() @dataclass(slots=True, frozen=True) -class MBCCSH03_BRL: - name: str = "MBCCSH03-BRL" - precision: int = 0.00000001 +class GNO_BRL: + """ + name: GNO-BRL + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: None + maximum_order_size: None + margin: False + """ + name: str = "GNO-BRL" + precision: int = 8 minimum_margin: float = None initial_margin: float = None minimum_order_size: float = None @@ -1921,22 +2650,31 @@ class MBCCSH03_BRL: margin: bool = False def __repr__(self): - return "MBCCSH03-BRL" + return "GNO-BRL" def __str__(self): - return "MBCCSH03-BRL" + return "GNO-BRL" def __call__(self): - return "MBCCSH03-BRL" + return "GNO-BRL" -MBCCSH03_BRL = MBCCSH03_BRL() +AXS_BRL = AXS_BRL() @dataclass(slots=True, frozen=True) -class ACMFT_BRL: - name: str = "ACMFT-BRL" - precision: int = 0.00000001 +class AXS_BRL: + """ + name: AXS-BRL + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: None + maximum_order_size: None + margin: False + """ + name: str = "AXS-BRL" + precision: int = 8 minimum_margin: float = None initial_margin: float = None minimum_order_size: float = None @@ -1944,22 +2682,31 @@ class ACMFT_BRL: margin: bool = False def __repr__(self): - return "ACMFT-BRL" + return "AXS-BRL" def __str__(self): - return "ACMFT-BRL" + return "AXS-BRL" def __call__(self): - return "ACMFT-BRL" + return "AXS-BRL" -ACMFT_BRL = ACMFT_BRL() +API3_BRL = API3_BRL() @dataclass(slots=True, frozen=True) -class OGFT_BRL: - name: str = "OGFT-BRL" - precision: int = 0.00000001 +class API3_BRL: + """ + name: API3-BRL + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: None + maximum_order_size: None + margin: False + """ + name: str = "API3-BRL" + precision: int = 8 minimum_margin: float = None initial_margin: float = None minimum_order_size: float = None @@ -1967,22 +2714,31 @@ class OGFT_BRL: margin: bool = False def __repr__(self): - return "OGFT-BRL" + return "API3-BRL" def __str__(self): - return "OGFT-BRL" + return "API3-BRL" def __call__(self): - return "OGFT-BRL" + return "API3-BRL" -OGFT_BRL = OGFT_BRL() +CLV_BRL = CLV_BRL() @dataclass(slots=True, frozen=True) -class ILV_BRL: - name: str = "ILV-BRL" - precision: int = 0.00000001 +class CLV_BRL: + """ + name: CLV-BRL + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: None + maximum_order_size: None + margin: False + """ + name: str = "CLV-BRL" + precision: int = 8 minimum_margin: float = None initial_margin: float = None minimum_order_size: float = None @@ -1990,22 +2746,31 @@ class ILV_BRL: margin: bool = False def __repr__(self): - return "ILV-BRL" + return "CLV-BRL" def __str__(self): - return "ILV-BRL" + return "CLV-BRL" def __call__(self): - return "ILV-BRL" + return "CLV-BRL" -ILV_BRL = ILV_BRL() +FLOW_BRL = FLOW_BRL() @dataclass(slots=True, frozen=True) -class COTI_BRL: - name: str = "COTI-BRL" - precision: int = 0.00000001 +class FLOW_BRL: + """ + name: FLOW-BRL + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: None + maximum_order_size: None + margin: False + """ + name: str = "FLOW-BRL" + precision: int = 8 minimum_margin: float = None initial_margin: float = None minimum_order_size: float = None @@ -2013,22 +2778,31 @@ class COTI_BRL: margin: bool = False def __repr__(self): - return "COTI-BRL" + return "FLOW-BRL" def __str__(self): - return "COTI-BRL" + return "FLOW-BRL" def __call__(self): - return "COTI-BRL" + return "FLOW-BRL" -COTI_BRL = COTI_BRL() +MBFP14_BRL = MBFP14_BRL() @dataclass(slots=True, frozen=True) -class FARM_BRL: - name: str = "FARM-BRL" - precision: int = 0.00000001 +class MBFP14_BRL: + """ + name: MBFP14-BRL + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: None + maximum_order_size: None + margin: False + """ + name: str = "MBFP14-BRL" + precision: int = 8 minimum_margin: float = None initial_margin: float = None minimum_order_size: float = None @@ -2036,22 +2810,31 @@ class FARM_BRL: margin: bool = False def __repr__(self): - return "FARM-BRL" + return "MBFP14-BRL" def __str__(self): - return "FARM-BRL" + return "MBFP14-BRL" def __call__(self): - return "FARM-BRL" + return "MBFP14-BRL" -FARM_BRL = FARM_BRL() +WBTC_BRL = WBTC_BRL() @dataclass(slots=True, frozen=True) -class AUDIO_BRL: - name: str = "AUDIO-BRL" - precision: int = 0.00000001 +class WBTC_BRL: + """ + name: WBTC-BRL + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: None + maximum_order_size: None + margin: False + """ + name: str = "WBTC-BRL" + precision: int = 8 minimum_margin: float = None initial_margin: float = None minimum_order_size: float = None @@ -2059,22 +2842,31 @@ class AUDIO_BRL: margin: bool = False def __repr__(self): - return "AUDIO-BRL" + return "WBTC-BRL" def __str__(self): - return "AUDIO-BRL" + return "WBTC-BRL" def __call__(self): - return "AUDIO-BRL" + return "WBTC-BRL" -AUDIO_BRL = AUDIO_BRL() +MBCONS02_BRL = MBCONS02_BRL() @dataclass(slots=True, frozen=True) -class AXS_BRL: - name: str = "AXS-BRL" - precision: int = 0.00000001 +class MBCONS02_BRL: + """ + name: MBCONS02-BRL + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: None + maximum_order_size: None + margin: False + """ + name: str = "MBCONS02-BRL" + precision: int = 8 minimum_margin: float = None initial_margin: float = None minimum_order_size: float = None @@ -2082,22 +2874,31 @@ class AXS_BRL: margin: bool = False def __repr__(self): - return "AXS-BRL" + return "MBCONS02-BRL" def __str__(self): - return "AXS-BRL" + return "MBCONS02-BRL" def __call__(self): - return "AXS-BRL" + return "MBCONS02-BRL" -AXS_BRL = AXS_BRL() +SHIB_BRL = SHIB_BRL() @dataclass(slots=True, frozen=True) -class BAT_BRL: - name: str = "BAT-BRL" - precision: int = 0.00000001 +class SHIB_BRL: + """ + name: SHIB-BRL + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: None + maximum_order_size: None + margin: False + """ + name: str = "SHIB-BRL" + precision: int = 8 minimum_margin: float = None initial_margin: float = None minimum_order_size: float = None @@ -2105,22 +2906,31 @@ class BAT_BRL: margin: bool = False def __repr__(self): - return "BAT-BRL" + return "SHIB-BRL" def __str__(self): - return "BAT-BRL" + return "SHIB-BRL" def __call__(self): - return "BAT-BRL" + return "SHIB-BRL" -BAT_BRL = BAT_BRL() +GALA_BRL = GALA_BRL() @dataclass(slots=True, frozen=True) -class TRB_BRL: - name: str = "TRB-BRL" - precision: int = 0.00000001 +class GALA_BRL: + """ + name: GALA-BRL + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: None + maximum_order_size: None + margin: False + """ + name: str = "GALA-BRL" + precision: int = 8 minimum_margin: float = None initial_margin: float = None minimum_order_size: float = None @@ -2128,22 +2938,31 @@ class TRB_BRL: margin: bool = False def __repr__(self): - return "TRB-BRL" + return "GALA-BRL" def __str__(self): - return "TRB-BRL" + return "GALA-BRL" def __call__(self): - return "TRB-BRL" + return "GALA-BRL" -TRB_BRL = TRB_BRL() +OP_BRL = OP_BRL() @dataclass(slots=True, frozen=True) -class AIOZ_BRL: - name: str = "AIOZ-BRL" - precision: int = 0.00000001 +class OP_BRL: + """ + name: OP-BRL + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: None + maximum_order_size: None + margin: False + """ + name: str = "OP-BRL" + precision: int = 8 minimum_margin: float = None initial_margin: float = None minimum_order_size: float = None @@ -2151,22 +2970,31 @@ class AIOZ_BRL: margin: bool = False def __repr__(self): - return "AIOZ-BRL" + return "OP-BRL" def __str__(self): - return "AIOZ-BRL" + return "OP-BRL" def __call__(self): - return "AIOZ-BRL" + return "OP-BRL" -AIOZ_BRL = AIOZ_BRL() +APT_BRL = APT_BRL() @dataclass(slots=True, frozen=True) -class BARFT_BRL: - name: str = "BARFT-BRL" - precision: int = 0.00000001 +class APT_BRL: + """ + name: APT-BRL + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: None + maximum_order_size: None + margin: False + """ + name: str = "APT-BRL" + precision: int = 8 minimum_margin: float = None initial_margin: float = None minimum_order_size: float = None @@ -2174,22 +3002,31 @@ class BARFT_BRL: margin: bool = False def __repr__(self): - return "BARFT-BRL" + return "APT-BRL" def __str__(self): - return "BARFT-BRL" + return "APT-BRL" def __call__(self): - return "BARFT-BRL" + return "APT-BRL" -BARFT_BRL = BARFT_BRL() +COMP_BRL = COMP_BRL() @dataclass(slots=True, frozen=True) -class UFCFT_BRL: - name: str = "UFCFT-BRL" - precision: int = 0.00000001 +class COMP_BRL: + """ + name: COMP-BRL + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: None + maximum_order_size: None + margin: False + """ + name: str = "COMP-BRL" + precision: int = 8 minimum_margin: float = None initial_margin: float = None minimum_order_size: float = None @@ -2197,22 +3034,31 @@ class UFCFT_BRL: margin: bool = False def __repr__(self): - return "UFCFT-BRL" + return "COMP-BRL" def __str__(self): - return "UFCFT-BRL" + return "COMP-BRL" def __call__(self): - return "UFCFT-BRL" + return "COMP-BRL" -UFCFT_BRL = UFCFT_BRL() +CAIFT_BRL = CAIFT_BRL() @dataclass(slots=True, frozen=True) -class MBCCSH13_BRL: - name: str = "MBCCSH13-BRL" - precision: int = 0.00000001 +class CAIFT_BRL: + """ + name: CAIFT-BRL + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: None + maximum_order_size: None + margin: False + """ + name: str = "CAIFT-BRL" + precision: int = 8 minimum_margin: float = None initial_margin: float = None minimum_order_size: float = None @@ -2220,22 +3066,31 @@ class MBCCSH13_BRL: margin: bool = False def __repr__(self): - return "MBCCSH13-BRL" + return "CAIFT-BRL" def __str__(self): - return "MBCCSH13-BRL" + return "CAIFT-BRL" def __call__(self): - return "MBCCSH13-BRL" + return "CAIFT-BRL" -MBCCSH13_BRL = MBCCSH13_BRL() +POLY_BRL = POLY_BRL() @dataclass(slots=True, frozen=True) -class OXT_BRL: - name: str = "OXT-BRL" - precision: int = 0.00000001 +class POLY_BRL: + """ + name: POLY-BRL + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: None + maximum_order_size: None + margin: False + """ + name: str = "POLY-BRL" + precision: int = 8 minimum_margin: float = None initial_margin: float = None minimum_order_size: float = None @@ -2243,22 +3098,31 @@ class OXT_BRL: margin: bool = False def __repr__(self): - return "OXT-BRL" + return "POLY-BRL" def __str__(self): - return "OXT-BRL" + return "POLY-BRL" def __call__(self): - return "OXT-BRL" + return "POLY-BRL" -OXT_BRL = OXT_BRL() +ACMFT_BRL = ACMFT_BRL() @dataclass(slots=True, frozen=True) -class BTRST_BRL: - name: str = "BTRST-BRL" - precision: int = 0.00000001 +class ACMFT_BRL: + """ + name: ACMFT-BRL + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: None + maximum_order_size: None + margin: False + """ + name: str = "ACMFT-BRL" + precision: int = 8 minimum_margin: float = None initial_margin: float = None minimum_order_size: float = None @@ -2266,22 +3130,31 @@ class BTRST_BRL: margin: bool = False def __repr__(self): - return "BTRST-BRL" + return "ACMFT-BRL" def __str__(self): - return "BTRST-BRL" + return "ACMFT-BRL" def __call__(self): - return "BTRST-BRL" + return "ACMFT-BRL" -BTRST_BRL = BTRST_BRL() +AMP_BRL = AMP_BRL() @dataclass(slots=True, frozen=True) -class PFLFT_BRL: - name: str = "PFLFT-BRL" - precision: int = 0.00000001 +class AMP_BRL: + """ + name: AMP-BRL + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: None + maximum_order_size: None + margin: False + """ + name: str = "AMP-BRL" + precision: int = 8 minimum_margin: float = None initial_margin: float = None minimum_order_size: float = None @@ -2289,22 +3162,31 @@ class PFLFT_BRL: margin: bool = False def __repr__(self): - return "PFLFT-BRL" + return "AMP-BRL" def __str__(self): - return "PFLFT-BRL" + return "AMP-BRL" def __call__(self): - return "PFLFT-BRL" + return "AMP-BRL" -PFLFT_BRL = PFLFT_BRL() +AUDIO_BRL = AUDIO_BRL() @dataclass(slots=True, frozen=True) -class MIR_BRL: - name: str = "MIR-BRL" - precision: int = 0.00000001 +class AUDIO_BRL: + """ + name: AUDIO-BRL + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: None + maximum_order_size: None + margin: False + """ + name: str = "AUDIO-BRL" + precision: int = 8 minimum_margin: float = None initial_margin: float = None minimum_order_size: float = None @@ -2312,22 +3194,31 @@ class MIR_BRL: margin: bool = False def __repr__(self): - return "MIR-BRL" + return "AUDIO-BRL" def __str__(self): - return "MIR-BRL" + return "AUDIO-BRL" def __call__(self): - return "MIR-BRL" + return "AUDIO-BRL" -MIR_BRL = MIR_BRL() +BLZ_BRL = BLZ_BRL() @dataclass(slots=True, frozen=True) -class ANT_BRL: - name: str = "ANT-BRL" - precision: int = 0.00000001 +class BLZ_BRL: + """ + name: BLZ-BRL + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: None + maximum_order_size: None + margin: False + """ + name: str = "BLZ-BRL" + precision: int = 8 minimum_margin: float = None initial_margin: float = None minimum_order_size: float = None @@ -2335,22 +3226,31 @@ class ANT_BRL: margin: bool = False def __repr__(self): - return "ANT-BRL" + return "BLZ-BRL" def __str__(self): - return "ANT-BRL" + return "BLZ-BRL" def __call__(self): - return "ANT-BRL" + return "BLZ-BRL" -ANT_BRL = ANT_BRL() +GMT_BRL = GMT_BRL() @dataclass(slots=True, frozen=True) -class ADS_BRL: - name: str = "ADS-BRL" - precision: int = 0.00000001 +class GMT_BRL: + """ + name: GMT-BRL + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: None + maximum_order_size: None + margin: False + """ + name: str = "GMT-BRL" + precision: int = 8 minimum_margin: float = None initial_margin: float = None minimum_order_size: float = None @@ -2358,22 +3258,31 @@ class ADS_BRL: margin: bool = False def __repr__(self): - return "ADS-BRL" + return "GMT-BRL" def __str__(self): - return "ADS-BRL" + return "GMT-BRL" def __call__(self): - return "ADS-BRL" + return "GMT-BRL" -ADS_BRL = ADS_BRL() +MANA_BRL = MANA_BRL() @dataclass(slots=True, frozen=True) -class API3_BRL: - name: str = "API3-BRL" - precision: int = 0.00000001 +class MANA_BRL: + """ + name: MANA-BRL + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: None + maximum_order_size: None + margin: False + """ + name: str = "MANA-BRL" + precision: int = 8 minimum_margin: float = None initial_margin: float = None minimum_order_size: float = None @@ -2381,22 +3290,31 @@ class API3_BRL: margin: bool = False def __repr__(self): - return "API3-BRL" + return "MANA-BRL" def __str__(self): - return "API3-BRL" + return "MANA-BRL" def __call__(self): - return "API3-BRL" + return "MANA-BRL" -API3_BRL = API3_BRL() +APE_BRL = APE_BRL() @dataclass(slots=True, frozen=True) -class YGG_BRL: - name: str = "YGG-BRL" - precision: int = 0.00000001 +class APE_BRL: + """ + name: APE-BRL + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: None + maximum_order_size: None + margin: False + """ + name: str = "APE-BRL" + precision: int = 8 minimum_margin: float = None initial_margin: float = None minimum_order_size: float = None @@ -2404,22 +3322,31 @@ class YGG_BRL: margin: bool = False def __repr__(self): - return "YGG-BRL" + return "APE-BRL" def __str__(self): - return "YGG-BRL" + return "APE-BRL" def __call__(self): - return "YGG-BRL" + return "APE-BRL" -YGG_BRL = YGG_BRL() +MBCCSH03_BRL = MBCCSH03_BRL() @dataclass(slots=True, frozen=True) -class AMP_BRL: - name: str = "AMP-BRL" - precision: int = 0.00000001 +class MBCCSH03_BRL: + """ + name: MBCCSH03-BRL + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: None + maximum_order_size: None + margin: False + """ + name: str = "MBCCSH03-BRL" + precision: int = 8 minimum_margin: float = None initial_margin: float = None minimum_order_size: float = None @@ -2427,22 +3354,31 @@ class AMP_BRL: margin: bool = False def __repr__(self): - return "AMP-BRL" + return "MBCCSH03-BRL" def __str__(self): - return "AMP-BRL" + return "MBCCSH03-BRL" def __call__(self): - return "AMP-BRL" + return "MBCCSH03-BRL" -AMP_BRL = AMP_BRL() +KNC_BRL = KNC_BRL() @dataclass(slots=True, frozen=True) -class ETH_BRL: - name: str = "ETH-BRL" - precision: int = 0.00000001 +class KNC_BRL: + """ + name: KNC-BRL + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: None + maximum_order_size: None + margin: False + """ + name: str = "KNC-BRL" + precision: int = 8 minimum_margin: float = None initial_margin: float = None minimum_order_size: float = None @@ -2450,22 +3386,31 @@ class ETH_BRL: margin: bool = False def __repr__(self): - return "ETH-BRL" + return "KNC-BRL" def __str__(self): - return "ETH-BRL" + return "KNC-BRL" def __call__(self): - return "ETH-BRL" + return "KNC-BRL" -ETH_BRL = ETH_BRL() +LTC_BRL = LTC_BRL() @dataclass(slots=True, frozen=True) -class GRT_BRL: - name: str = "GRT-BRL" - precision: int = 0.00000001 +class LTC_BRL: + """ + name: LTC-BRL + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: None + maximum_order_size: None + margin: False + """ + name: str = "LTC-BRL" + precision: int = 8 minimum_margin: float = None initial_margin: float = None minimum_order_size: float = None @@ -2473,22 +3418,31 @@ class GRT_BRL: margin: bool = False def __repr__(self): - return "GRT-BRL" + return "LTC-BRL" def __str__(self): - return "GRT-BRL" + return "LTC-BRL" def __call__(self): - return "GRT-BRL" + return "LTC-BRL" -GRT_BRL = GRT_BRL() +ALPHA_BRL = ALPHA_BRL() @dataclass(slots=True, frozen=True) -class CTSI_BRL: - name: str = "CTSI-BRL" - precision: int = 0.00000001 +class ALPHA_BRL: + """ + name: ALPHA-BRL + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: None + maximum_order_size: None + margin: False + """ + name: str = "ALPHA-BRL" + precision: int = 8 minimum_margin: float = None initial_margin: float = None minimum_order_size: float = None @@ -2496,22 +3450,31 @@ class CTSI_BRL: margin: bool = False def __repr__(self): - return "CTSI-BRL" + return "ALPHA-BRL" def __str__(self): - return "CTSI-BRL" + return "ALPHA-BRL" def __call__(self): - return "CTSI-BRL" + return "ALPHA-BRL" -CTSI_BRL = CTSI_BRL() +ENER03_BRL = ENER03_BRL() @dataclass(slots=True, frozen=True) -class MVI_BRL: - name: str = "MVI-BRL" - precision: int = 0.00000001 +class ENER03_BRL: + """ + name: ENER03-BRL + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: None + maximum_order_size: None + margin: False + """ + name: str = "ENER03-BRL" + precision: int = 8 minimum_margin: float = None initial_margin: float = None minimum_order_size: float = None @@ -2519,22 +3482,31 @@ class MVI_BRL: margin: bool = False def __repr__(self): - return "MVI-BRL" + return "ENER03-BRL" def __str__(self): - return "MVI-BRL" + return "ENER03-BRL" def __call__(self): - return "MVI-BRL" + return "ENER03-BRL" -MVI_BRL = MVI_BRL() +BTB10_BRL = BTB10_BRL() @dataclass(slots=True, frozen=True) -class ENER01_BRL: - name: str = "ENER01-BRL" - precision: int = 0.00000001 +class BTB10_BRL: + """ + name: BTB10-BRL + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: None + maximum_order_size: None + margin: False + """ + name: str = "BTB10-BRL" + precision: int = 8 minimum_margin: float = None initial_margin: float = None minimum_order_size: float = None @@ -2542,22 +3514,31 @@ class ENER01_BRL: margin: bool = False def __repr__(self): - return "ENER01-BRL" + return "BTB10-BRL" def __str__(self): - return "ENER01-BRL" + return "BTB10-BRL" def __call__(self): - return "ENER01-BRL" + return "BTB10-BRL" -ENER01_BRL = ENER01_BRL() +MBCCSH12_BRL = MBCCSH12_BRL() @dataclass(slots=True, frozen=True) -class ERN_BRL: - name: str = "ERN-BRL" - precision: int = 0.00000001 +class MBCCSH12_BRL: + """ + name: MBCCSH12-BRL + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: None + maximum_order_size: None + margin: False + """ + name: str = "MBCCSH12-BRL" + precision: int = 8 minimum_margin: float = None initial_margin: float = None minimum_order_size: float = None @@ -2565,22 +3546,31 @@ class ERN_BRL: margin: bool = False def __repr__(self): - return "ERN-BRL" + return "MBCCSH12-BRL" def __str__(self): - return "ERN-BRL" + return "MBCCSH12-BRL" def __call__(self): - return "ERN-BRL" + return "MBCCSH12-BRL" -ERN_BRL = ERN_BRL() +LDO_BRL = LDO_BRL() @dataclass(slots=True, frozen=True) -class USDC_BRL: - name: str = "USDC-BRL" - precision: int = 0.00000001 +class LDO_BRL: + """ + name: LDO-BRL + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: None + maximum_order_size: None + margin: False + """ + name: str = "LDO-BRL" + precision: int = 8 minimum_margin: float = None initial_margin: float = None minimum_order_size: float = None @@ -2588,22 +3578,31 @@ class USDC_BRL: margin: bool = False def __repr__(self): - return "USDC-BRL" + return "LDO-BRL" def __str__(self): - return "USDC-BRL" + return "LDO-BRL" def __call__(self): - return "USDC-BRL" + return "LDO-BRL" -USDC_BRL = USDC_BRL() +LQTY_BRL = LQTY_BRL() @dataclass(slots=True, frozen=True) -class JUVFT_BRL: - name: str = "JUVFT-BRL" - precision: int = 0.00000001 +class LQTY_BRL: + """ + name: LQTY-BRL + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: None + maximum_order_size: None + margin: False + """ + name: str = "LQTY-BRL" + precision: int = 8 minimum_margin: float = None initial_margin: float = None minimum_order_size: float = None @@ -2611,22 +3610,31 @@ class JUVFT_BRL: margin: bool = False def __repr__(self): - return "JUVFT-BRL" + return "LQTY-BRL" def __str__(self): - return "JUVFT-BRL" + return "LQTY-BRL" def __call__(self): - return "JUVFT-BRL" + return "LQTY-BRL" -JUVFT_BRL = JUVFT_BRL() +AIOZ_BRL = AIOZ_BRL() @dataclass(slots=True, frozen=True) -class FLOKI_BRL: - name: str = "FLOKI-BRL" - precision: int = 0.00000001 +class AIOZ_BRL: + """ + name: AIOZ-BRL + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: None + maximum_order_size: None + margin: False + """ + name: str = "AIOZ-BRL" + precision: int = 8 minimum_margin: float = None initial_margin: float = None minimum_order_size: float = None @@ -2634,22 +3642,31 @@ class FLOKI_BRL: margin: bool = False def __repr__(self): - return "FLOKI-BRL" + return "AIOZ-BRL" def __str__(self): - return "FLOKI-BRL" + return "AIOZ-BRL" def __call__(self): - return "FLOKI-BRL" + return "AIOZ-BRL" -FLOKI_BRL = FLOKI_BRL() +MBFP15_BRL = MBFP15_BRL() @dataclass(slots=True, frozen=True) -class MBCCSH04_BRL: - name: str = "MBCCSH04-BRL" - precision: int = 0.00000001 +class MBFP15_BRL: + """ + name: MBFP15-BRL + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: None + maximum_order_size: None + margin: False + """ + name: str = "MBFP15-BRL" + precision: int = 8 minimum_margin: float = None initial_margin: float = None minimum_order_size: float = None @@ -2657,22 +3674,31 @@ class MBCCSH04_BRL: margin: bool = False def __repr__(self): - return "MBCCSH04-BRL" + return "MBFP15-BRL" def __str__(self): - return "MBCCSH04-BRL" + return "MBFP15-BRL" def __call__(self): - return "MBCCSH04-BRL" + return "MBFP15-BRL" -MBCCSH04_BRL = MBCCSH04_BRL() +USDP_BRL = USDP_BRL() @dataclass(slots=True, frozen=True) -class MBCCSH06_BRL: - name: str = "MBCCSH06-BRL" - precision: int = 0.00000001 +class USDP_BRL: + """ + name: USDP-BRL + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: None + maximum_order_size: None + margin: False + """ + name: str = "USDP-BRL" + precision: int = 8 minimum_margin: float = None initial_margin: float = None minimum_order_size: float = None @@ -2680,22 +3706,31 @@ class MBCCSH06_BRL: margin: bool = False def __repr__(self): - return "MBCCSH06-BRL" + return "USDP-BRL" def __str__(self): - return "MBCCSH06-BRL" + return "USDP-BRL" def __call__(self): - return "MBCCSH06-BRL" + return "USDP-BRL" -MBCCSH06_BRL = MBCCSH06_BRL() +ATMFT_BRL = ATMFT_BRL() @dataclass(slots=True, frozen=True) -class DOT_BRL: - name: str = "DOT-BRL" - precision: int = 0.00000001 +class ATMFT_BRL: + """ + name: ATMFT-BRL + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: None + maximum_order_size: None + margin: False + """ + name: str = "ATMFT-BRL" + precision: int = 8 minimum_margin: float = None initial_margin: float = None minimum_order_size: float = None @@ -2703,22 +3738,31 @@ class DOT_BRL: margin: bool = False def __repr__(self): - return "DOT-BRL" + return "ATMFT-BRL" def __str__(self): - return "DOT-BRL" + return "ATMFT-BRL" def __call__(self): - return "DOT-BRL" + return "ATMFT-BRL" -DOT_BRL = DOT_BRL() +RARE_BRL = RARE_BRL() @dataclass(slots=True, frozen=True) -class APE_BRL: - name: str = "APE-BRL" - precision: int = 0.00000001 +class RARE_BRL: + """ + name: RARE-BRL + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: None + maximum_order_size: None + margin: False + """ + name: str = "RARE-BRL" + precision: int = 8 minimum_margin: float = None initial_margin: float = None minimum_order_size: float = None @@ -2726,22 +3770,31 @@ class APE_BRL: margin: bool = False def __repr__(self): - return "APE-BRL" + return "RARE-BRL" def __str__(self): - return "APE-BRL" + return "RARE-BRL" def __call__(self): - return "APE-BRL" + return "RARE-BRL" -APE_BRL = APE_BRL() +THFT_BRL = THFT_BRL() @dataclass(slots=True, frozen=True) -class MBCCSH05_BRL: - name: str = "MBCCSH05-BRL" - precision: int = 0.00000001 +class THFT_BRL: + """ + name: THFT-BRL + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: None + maximum_order_size: None + margin: False + """ + name: str = "THFT-BRL" + precision: int = 8 minimum_margin: float = None initial_margin: float = None minimum_order_size: float = None @@ -2749,22 +3802,31 @@ class MBCCSH05_BRL: margin: bool = False def __repr__(self): - return "MBCCSH05-BRL" + return "THFT-BRL" def __str__(self): - return "MBCCSH05-BRL" + return "THFT-BRL" def __call__(self): - return "MBCCSH05-BRL" + return "THFT-BRL" -MBCCSH05_BRL = MBCCSH05_BRL() +KP3R_BRL = KP3R_BRL() @dataclass(slots=True, frozen=True) -class MC_BRL: - name: str = "MC-BRL" - precision: int = 0.00000001 +class KP3R_BRL: + """ + name: KP3R-BRL + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: None + maximum_order_size: None + margin: False + """ + name: str = "KP3R-BRL" + precision: int = 8 minimum_margin: float = None initial_margin: float = None minimum_order_size: float = None @@ -2772,22 +3834,31 @@ class MC_BRL: margin: bool = False def __repr__(self): - return "MC-BRL" + return "KP3R-BRL" def __str__(self): - return "MC-BRL" + return "KP3R-BRL" def __call__(self): - return "MC-BRL" + return "KP3R-BRL" -MC_BRL = MC_BRL() +YBOFT_BRL = YBOFT_BRL() @dataclass(slots=True, frozen=True) -class BAL_BRL: - name: str = "BAL-BRL" - precision: int = 0.00000001 +class YBOFT_BRL: + """ + name: YBOFT-BRL + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: None + maximum_order_size: None + margin: False + """ + name: str = "YBOFT-BRL" + precision: int = 8 minimum_margin: float = None initial_margin: float = None minimum_order_size: float = None @@ -2795,22 +3866,31 @@ class BAL_BRL: margin: bool = False def __repr__(self): - return "BAL-BRL" + return "YBOFT-BRL" def __str__(self): - return "BAL-BRL" + return "YBOFT-BRL" def __call__(self): - return "BAL-BRL" + return "YBOFT-BRL" -BAL_BRL = BAL_BRL() +XTZ_BRL = XTZ_BRL() @dataclass(slots=True, frozen=True) -class MKR_BRL: - name: str = "MKR-BRL" - precision: int = 0.00000001 +class XTZ_BRL: + """ + name: XTZ-BRL + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: None + maximum_order_size: None + margin: False + """ + name: str = "XTZ-BRL" + precision: int = 8 minimum_margin: float = None initial_margin: float = None minimum_order_size: float = None @@ -2818,22 +3898,31 @@ class MKR_BRL: margin: bool = False def __repr__(self): - return "MKR-BRL" + return "XTZ-BRL" def __str__(self): - return "MKR-BRL" + return "XTZ-BRL" def __call__(self): - return "MKR-BRL" + return "XTZ-BRL" -MKR_BRL = MKR_BRL() +MENGOFT_BRL = MENGOFT_BRL() @dataclass(slots=True, frozen=True) -class SAND_BRL: - name: str = "SAND-BRL" - precision: int = 0.00000001 +class MENGOFT_BRL: + """ + name: MENGOFT-BRL + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: None + maximum_order_size: None + margin: False + """ + name: str = "MENGOFT-BRL" + precision: int = 8 minimum_margin: float = None initial_margin: float = None minimum_order_size: float = None @@ -2841,22 +3930,31 @@ class SAND_BRL: margin: bool = False def __repr__(self): - return "SAND-BRL" + return "MENGOFT-BRL" def __str__(self): - return "SAND-BRL" + return "MENGOFT-BRL" def __call__(self): - return "SAND-BRL" + return "MENGOFT-BRL" -SAND_BRL = SAND_BRL() +SUPER_BRL = SUPER_BRL() @dataclass(slots=True, frozen=True) -class XTZ_BRL: - name: str = "XTZ-BRL" - precision: int = 0.00000001 +class SUPER_BRL: + """ + name: SUPER-BRL + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: None + maximum_order_size: None + margin: False + """ + name: str = "SUPER-BRL" + precision: int = 8 minimum_margin: float = None initial_margin: float = None minimum_order_size: float = None @@ -2864,22 +3962,31 @@ class XTZ_BRL: margin: bool = False def __repr__(self): - return "XTZ-BRL" + return "SUPER-BRL" def __str__(self): - return "XTZ-BRL" + return "SUPER-BRL" def __call__(self): - return "XTZ-BRL" + return "SUPER-BRL" -XTZ_BRL = XTZ_BRL() +MBCCSH02_BRL = MBCCSH02_BRL() @dataclass(slots=True, frozen=True) -class DOGE_BRL: - name: str = "DOGE-BRL" - precision: int = 0.00000001 +class MBCCSH02_BRL: + """ + name: MBCCSH02-BRL + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: None + maximum_order_size: None + margin: False + """ + name: str = "MBCCSH02-BRL" + precision: int = 8 minimum_margin: float = None initial_margin: float = None minimum_order_size: float = None @@ -2887,22 +3994,31 @@ class DOGE_BRL: margin: bool = False def __repr__(self): - return "DOGE-BRL" + return "MBCCSH02-BRL" def __str__(self): - return "DOGE-BRL" + return "MBCCSH02-BRL" def __call__(self): - return "DOGE-BRL" + return "MBCCSH02-BRL" -DOGE_BRL = DOGE_BRL() +OCEAN_BRL = OCEAN_BRL() @dataclass(slots=True, frozen=True) -class CSCONS05_BRL: - name: str = "CSCONS05-BRL" - precision: int = 0.00000001 +class OCEAN_BRL: + """ + name: OCEAN-BRL + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: None + maximum_order_size: None + margin: False + """ + name: str = "OCEAN-BRL" + precision: int = 8 minimum_margin: float = None initial_margin: float = None minimum_order_size: float = None @@ -2910,22 +4026,31 @@ class CSCONS05_BRL: margin: bool = False def __repr__(self): - return "CSCONS05-BRL" + return "OCEAN-BRL" def __str__(self): - return "CSCONS05-BRL" + return "OCEAN-BRL" def __call__(self): - return "CSCONS05-BRL" + return "OCEAN-BRL" -CSCONS05_BRL = CSCONS05_BRL() +REN_BRL = REN_BRL() @dataclass(slots=True, frozen=True) -class MBPRK02_BRL: - name: str = "MBPRK02-BRL" - precision: int = 0.00000001 +class REN_BRL: + """ + name: REN-BRL + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: None + maximum_order_size: None + margin: False + """ + name: str = "REN-BRL" + precision: int = 8 minimum_margin: float = None initial_margin: float = None minimum_order_size: float = None @@ -2933,22 +4058,31 @@ class MBPRK02_BRL: margin: bool = False def __repr__(self): - return "MBPRK02-BRL" + return "REN-BRL" def __str__(self): - return "MBPRK02-BRL" + return "REN-BRL" def __call__(self): - return "MBPRK02-BRL" + return "REN-BRL" -MBPRK02_BRL = MBPRK02_BRL() +LINK_BRL = LINK_BRL() @dataclass(slots=True, frozen=True) -class CHZ_BRL: - name: str = "CHZ-BRL" - precision: int = 0.00000001 +class LINK_BRL: + """ + name: LINK-BRL + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: None + maximum_order_size: None + margin: False + """ + name: str = "LINK-BRL" + precision: int = 8 minimum_margin: float = None initial_margin: float = None minimum_order_size: float = None @@ -2956,22 +4090,31 @@ class CHZ_BRL: margin: bool = False def __repr__(self): - return "CHZ-BRL" + return "LINK-BRL" def __str__(self): - return "CHZ-BRL" + return "LINK-BRL" def __call__(self): - return "CHZ-BRL" + return "LINK-BRL" -CHZ_BRL = CHZ_BRL() +ENER02_BRL = ENER02_BRL() @dataclass(slots=True, frozen=True) -class RARI_BRL: - name: str = "RARI-BRL" - precision: int = 0.00000001 +class ENER02_BRL: + """ + name: ENER02-BRL + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: None + maximum_order_size: None + margin: False + """ + name: str = "ENER02-BRL" + precision: int = 8 minimum_margin: float = None initial_margin: float = None minimum_order_size: float = None @@ -2979,22 +4122,31 @@ class RARI_BRL: margin: bool = False def __repr__(self): - return "RARI-BRL" + return "ENER02-BRL" def __str__(self): - return "RARI-BRL" + return "ENER02-BRL" def __call__(self): - return "RARI-BRL" + return "ENER02-BRL" -RARI_BRL = RARI_BRL() +MBSANTOS01_BRL = MBSANTOS01_BRL() @dataclass(slots=True, frozen=True) -class KEEP_BRL: - name: str = "KEEP-BRL" - precision: int = 0.00000001 +class MBSANTOS01_BRL: + """ + name: MBSANTOS01-BRL + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: None + maximum_order_size: None + margin: False + """ + name: str = "MBSANTOS01-BRL" + precision: int = 8 minimum_margin: float = None initial_margin: float = None minimum_order_size: float = None @@ -3002,22 +4154,31 @@ class KEEP_BRL: margin: bool = False def __repr__(self): - return "KEEP-BRL" + return "MBSANTOS01-BRL" def __str__(self): - return "KEEP-BRL" + return "MBSANTOS01-BRL" def __call__(self): - return "KEEP-BRL" + return "MBSANTOS01-BRL" -KEEP_BRL = KEEP_BRL() +WLUNA_BRL = WLUNA_BRL() @dataclass(slots=True, frozen=True) -class OP_BRL: - name: str = "OP-BRL" - precision: int = 0.00000001 +class WLUNA_BRL: + """ + name: WLUNA-BRL + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: None + maximum_order_size: None + margin: False + """ + name: str = "WLUNA-BRL" + precision: int = 8 minimum_margin: float = None initial_margin: float = None minimum_order_size: float = None @@ -3025,22 +4186,31 @@ class OP_BRL: margin: bool = False def __repr__(self): - return "OP-BRL" + return "WLUNA-BRL" def __str__(self): - return "OP-BRL" + return "WLUNA-BRL" def __call__(self): - return "OP-BRL" + return "WLUNA-BRL" -OP_BRL = OP_BRL() +BICO_BRL = BICO_BRL() @dataclass(slots=True, frozen=True) -class APT_BRL: - name: str = "APT-BRL" - precision: int = 0.00000001 +class BICO_BRL: + """ + name: BICO-BRL + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: None + maximum_order_size: None + margin: False + """ + name: str = "BICO-BRL" + precision: int = 8 minimum_margin: float = None initial_margin: float = None minimum_order_size: float = None @@ -3048,22 +4218,31 @@ class APT_BRL: margin: bool = False def __repr__(self): - return "APT-BRL" + return "BICO-BRL" def __str__(self): - return "APT-BRL" + return "BICO-BRL" def __call__(self): - return "APT-BRL" + return "BICO-BRL" -APT_BRL = APT_BRL() +MBCCSH06_BRL = MBCCSH06_BRL() @dataclass(slots=True, frozen=True) -class VSPRK01_BRL: - name: str = "VSPRK01-BRL" - precision: int = 0.00000001 +class MBCCSH06_BRL: + """ + name: MBCCSH06-BRL + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: None + maximum_order_size: None + margin: False + """ + name: str = "MBCCSH06-BRL" + precision: int = 8 minimum_margin: float = None initial_margin: float = None minimum_order_size: float = None @@ -3071,22 +4250,31 @@ class VSPRK01_BRL: margin: bool = False def __repr__(self): - return "VSPRK01-BRL" + return "MBCCSH06-BRL" def __str__(self): - return "VSPRK01-BRL" + return "MBCCSH06-BRL" def __call__(self): - return "VSPRK01-BRL" + return "MBCCSH06-BRL" -VSPRK01_BRL = VSPRK01_BRL() +MBCCSH15_BRL = MBCCSH15_BRL() @dataclass(slots=True, frozen=True) -class STVFT_BRL: - name: str = "STVFT-BRL" - precision: int = 0.00000001 +class MBCCSH15_BRL: + """ + name: MBCCSH15-BRL + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: None + maximum_order_size: None + margin: False + """ + name: str = "MBCCSH15-BRL" + precision: int = 8 minimum_margin: float = None initial_margin: float = None minimum_order_size: float = None @@ -3094,22 +4282,31 @@ class STVFT_BRL: margin: bool = False def __repr__(self): - return "STVFT-BRL" + return "MBCCSH15-BRL" def __str__(self): - return "STVFT-BRL" + return "MBCCSH15-BRL" def __call__(self): - return "STVFT-BRL" + return "MBCCSH15-BRL" -STVFT_BRL = STVFT_BRL() +OXT_BRL = OXT_BRL() @dataclass(slots=True, frozen=True) -class PAXG_BRL: - name: str = "PAXG-BRL" - precision: int = 0.00000001 +class OXT_BRL: + """ + name: OXT-BRL + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: None + maximum_order_size: None + margin: False + """ + name: str = "OXT-BRL" + precision: int = 8 minimum_margin: float = None initial_margin: float = None minimum_order_size: float = None @@ -3117,22 +4314,31 @@ class PAXG_BRL: margin: bool = False def __repr__(self): - return "PAXG-BRL" + return "OXT-BRL" def __str__(self): - return "PAXG-BRL" + return "OXT-BRL" def __call__(self): - return "PAXG-BRL" + return "OXT-BRL" -PAXG_BRL = PAXG_BRL() +REQ_BRL = REQ_BRL() @dataclass(slots=True, frozen=True) -class HOT_BRL: - name: str = "HOT-BRL" - precision: int = 0.00000001 +class REQ_BRL: + """ + name: REQ-BRL + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: None + maximum_order_size: None + margin: False + """ + name: str = "REQ-BRL" + precision: int = 8 minimum_margin: float = None initial_margin: float = None minimum_order_size: float = None @@ -3140,22 +4346,31 @@ class HOT_BRL: margin: bool = False def __repr__(self): - return "HOT-BRL" + return "REQ-BRL" def __str__(self): - return "HOT-BRL" + return "REQ-BRL" def __call__(self): - return "HOT-BRL" + return "REQ-BRL" -HOT_BRL = HOT_BRL() +CHZ_BRL = CHZ_BRL() -@dataclass(slots=True, frozen=True) -class BTB05_BRL: - name: str = "BTB05-BRL" - precision: int = 0.00000001 +@dataclass(slots=True, frozen=True) +class CHZ_BRL: + """ + name: CHZ-BRL + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: None + maximum_order_size: None + margin: False + """ + name: str = "CHZ-BRL" + precision: int = 8 minimum_margin: float = None initial_margin: float = None minimum_order_size: float = None @@ -3163,22 +4378,31 @@ class BTB05_BRL: margin: bool = False def __repr__(self): - return "BTB05-BRL" + return "CHZ-BRL" def __str__(self): - return "BTB05-BRL" + return "CHZ-BRL" def __call__(self): - return "BTB05-BRL" + return "CHZ-BRL" -BTB05_BRL = BTB05_BRL() +FARM_BRL = FARM_BRL() @dataclass(slots=True, frozen=True) -class YBOFT_BRL: - name: str = "YBOFT-BRL" - precision: int = 0.00000001 +class FARM_BRL: + """ + name: FARM-BRL + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: None + maximum_order_size: None + margin: False + """ + name: str = "FARM-BRL" + precision: int = 8 minimum_margin: float = None initial_margin: float = None minimum_order_size: float = None @@ -3186,22 +4410,31 @@ class YBOFT_BRL: margin: bool = False def __repr__(self): - return "YBOFT-BRL" + return "FARM-BRL" def __str__(self): - return "YBOFT-BRL" + return "FARM-BRL" def __call__(self): - return "YBOFT-BRL" + return "FARM-BRL" -YBOFT_BRL = YBOFT_BRL() +STORJ_BRL = STORJ_BRL() @dataclass(slots=True, frozen=True) -class YFI_BRL: - name: str = "YFI-BRL" - precision: int = 0.00000001 +class STORJ_BRL: + """ + name: STORJ-BRL + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: None + maximum_order_size: None + margin: False + """ + name: str = "STORJ-BRL" + precision: int = 8 minimum_margin: float = None initial_margin: float = None minimum_order_size: float = None @@ -3209,22 +4442,31 @@ class YFI_BRL: margin: bool = False def __repr__(self): - return "YFI-BRL" + return "STORJ-BRL" def __str__(self): - return "YFI-BRL" + return "STORJ-BRL" def __call__(self): - return "YFI-BRL" + return "STORJ-BRL" -YFI_BRL = YFI_BRL() +COTI_BRL = COTI_BRL() @dataclass(slots=True, frozen=True) -class QNT_BRL: - name: str = "QNT-BRL" - precision: int = 0.00000001 +class COTI_BRL: + """ + name: COTI-BRL + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: None + maximum_order_size: None + margin: False + """ + name: str = "COTI-BRL" + precision: int = 8 minimum_margin: float = None initial_margin: float = None minimum_order_size: float = None @@ -3232,22 +4474,31 @@ class QNT_BRL: margin: bool = False def __repr__(self): - return "QNT-BRL" + return "COTI-BRL" def __str__(self): - return "QNT-BRL" + return "COTI-BRL" def __call__(self): - return "QNT-BRL" + return "COTI-BRL" -QNT_BRL = QNT_BRL() +CITYFT_BRL = CITYFT_BRL() @dataclass(slots=True, frozen=True) class CITYFT_BRL: + """ + name: CITYFT-BRL + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: None + maximum_order_size: None + margin: False + """ name: str = "CITYFT-BRL" - precision: int = 0.00000001 + precision: int = 8 minimum_margin: float = None initial_margin: float = None minimum_order_size: float = None @@ -3264,13 +4515,22 @@ def __call__(self): return "CITYFT-BRL" -CITYFT_BRL = CITYFT_BRL() +ATOM_BRL = ATOM_BRL() @dataclass(slots=True, frozen=True) -class GNO_BRL: - name: str = "GNO-BRL" - precision: int = 0.00000001 +class ATOM_BRL: + """ + name: ATOM-BRL + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: None + maximum_order_size: None + margin: False + """ + name: str = "ATOM-BRL" + precision: int = 8 minimum_margin: float = None initial_margin: float = None minimum_order_size: float = None @@ -3278,22 +4538,31 @@ class GNO_BRL: margin: bool = False def __repr__(self): - return "GNO-BRL" + return "ATOM-BRL" def __str__(self): - return "GNO-BRL" + return "ATOM-BRL" def __call__(self): - return "GNO-BRL" + return "ATOM-BRL" -GNO_BRL = GNO_BRL() +YGG_BRL = YGG_BRL() @dataclass(slots=True, frozen=True) -class MBPRK04_BRL: - name: str = "MBPRK04-BRL" - precision: int = 0.00000001 +class YGG_BRL: + """ + name: YGG-BRL + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: None + maximum_order_size: None + margin: False + """ + name: str = "YGG-BRL" + precision: int = 8 minimum_margin: float = None initial_margin: float = None minimum_order_size: float = None @@ -3301,22 +4570,31 @@ class MBPRK04_BRL: margin: bool = False def __repr__(self): - return "MBPRK04-BRL" + return "YGG-BRL" def __str__(self): - return "MBPRK04-BRL" + return "YGG-BRL" def __call__(self): - return "MBPRK04-BRL" + return "YGG-BRL" -MBPRK04_BRL = MBPRK04_BRL() +PFLFT_BRL = PFLFT_BRL() @dataclass(slots=True, frozen=True) -class POLY_BRL: - name: str = "POLY-BRL" - precision: int = 0.00000001 +class PFLFT_BRL: + """ + name: PFLFT-BRL + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: None + maximum_order_size: None + margin: False + """ + name: str = "PFLFT-BRL" + precision: int = 8 minimum_margin: float = None initial_margin: float = None minimum_order_size: float = None @@ -3324,22 +4602,31 @@ class POLY_BRL: margin: bool = False def __repr__(self): - return "POLY-BRL" + return "PFLFT-BRL" def __str__(self): - return "POLY-BRL" + return "PFLFT-BRL" def __call__(self): - return "POLY-BRL" + return "PFLFT-BRL" -POLY_BRL = POLY_BRL() +RNDR_BRL = RNDR_BRL() @dataclass(slots=True, frozen=True) -class MBFP11_BRL: - name: str = "MBFP11-BRL" - precision: int = 0.00000001 +class RNDR_BRL: + """ + name: RNDR-BRL + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: None + maximum_order_size: None + margin: False + """ + name: str = "RNDR-BRL" + precision: int = 8 minimum_margin: float = None initial_margin: float = None minimum_order_size: float = None @@ -3347,22 +4634,31 @@ class MBFP11_BRL: margin: bool = False def __repr__(self): - return "MBFP11-BRL" + return "RNDR-BRL" def __str__(self): - return "MBFP11-BRL" + return "RNDR-BRL" def __call__(self): - return "MBFP11-BRL" + return "RNDR-BRL" -MBFP11_BRL = MBFP11_BRL() +MBPRK06_BRL = MBPRK06_BRL() @dataclass(slots=True, frozen=True) -class NAVIFT_BRL: - name: str = "NAVIFT-BRL" - precision: int = 0.00000001 +class MBPRK06_BRL: + """ + name: MBPRK06-BRL + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: None + maximum_order_size: None + margin: False + """ + name: str = "MBPRK06-BRL" + precision: int = 8 minimum_margin: float = None initial_margin: float = None minimum_order_size: float = None @@ -3370,22 +4666,31 @@ class NAVIFT_BRL: margin: bool = False def __repr__(self): - return "NAVIFT-BRL" + return "MBPRK06-BRL" def __str__(self): - return "NAVIFT-BRL" + return "MBPRK06-BRL" def __call__(self): - return "NAVIFT-BRL" + return "MBPRK06-BRL" -NAVIFT_BRL = NAVIFT_BRL() +ALICE_BRL = ALICE_BRL() @dataclass(slots=True, frozen=True) -class ARGFT_BRL: - name: str = "ARGFT-BRL" - precision: int = 0.00000001 +class ALICE_BRL: + """ + name: ALICE-BRL + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: None + maximum_order_size: None + margin: False + """ + name: str = "ALICE-BRL" + precision: int = 8 minimum_margin: float = None initial_margin: float = None minimum_order_size: float = None @@ -3393,22 +4698,31 @@ class ARGFT_BRL: margin: bool = False def __repr__(self): - return "ARGFT-BRL" + return "ALICE-BRL" def __str__(self): - return "ARGFT-BRL" + return "ALICE-BRL" def __call__(self): - return "ARGFT-BRL" + return "ALICE-BRL" -ARGFT_BRL = ARGFT_BRL() +QNT_BRL = QNT_BRL() @dataclass(slots=True, frozen=True) -class MANA_BRL: - name: str = "MANA-BRL" - precision: int = 0.00000001 +class QNT_BRL: + """ + name: QNT-BRL + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: None + maximum_order_size: None + margin: False + """ + name: str = "QNT-BRL" + precision: int = 8 minimum_margin: float = None initial_margin: float = None minimum_order_size: float = None @@ -3416,22 +4730,31 @@ class MANA_BRL: margin: bool = False def __repr__(self): - return "MANA-BRL" + return "QNT-BRL" def __str__(self): - return "MANA-BRL" + return "QNT-BRL" def __call__(self): - return "MANA-BRL" + return "QNT-BRL" -MANA_BRL = MANA_BRL() +MBCONS01_BRL = MBCONS01_BRL() @dataclass(slots=True, frozen=True) -class XRP_BRL: - name: str = "XRP-BRL" - precision: int = 0.00000001 +class MBCONS01_BRL: + """ + name: MBCONS01-BRL + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: None + maximum_order_size: None + margin: False + """ + name: str = "MBCONS01-BRL" + precision: int = 8 minimum_margin: float = None initial_margin: float = None minimum_order_size: float = None @@ -3439,22 +4762,31 @@ class XRP_BRL: margin: bool = False def __repr__(self): - return "XRP-BRL" + return "MBCONS01-BRL" def __str__(self): - return "XRP-BRL" + return "MBCONS01-BRL" def __call__(self): - return "XRP-BRL" + return "MBCONS01-BRL" -XRP_BRL = XRP_BRL() +HIGH_BRL = HIGH_BRL() @dataclass(slots=True, frozen=True) -class MBFP07_BRL: - name: str = "MBFP07-BRL" - precision: int = 0.00000001 +class HIGH_BRL: + """ + name: HIGH-BRL + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: None + maximum_order_size: None + margin: False + """ + name: str = "HIGH-BRL" + precision: int = 8 minimum_margin: float = None initial_margin: float = None minimum_order_size: float = None @@ -3462,22 +4794,31 @@ class MBFP07_BRL: margin: bool = False def __repr__(self): - return "MBFP07-BRL" + return "HIGH-BRL" def __str__(self): - return "MBFP07-BRL" + return "HIGH-BRL" def __call__(self): - return "MBFP07-BRL" + return "HIGH-BRL" -MBFP07_BRL = MBFP07_BRL() +RAD_BRL = RAD_BRL() @dataclass(slots=True, frozen=True) -class CSCONS03_BRL: - name: str = "CSCONS03-BRL" - precision: int = 0.00000001 +class RAD_BRL: + """ + name: RAD-BRL + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: None + maximum_order_size: None + margin: False + """ + name: str = "RAD-BRL" + precision: int = 8 minimum_margin: float = None initial_margin: float = None minimum_order_size: float = None @@ -3485,22 +4826,31 @@ class CSCONS03_BRL: margin: bool = False def __repr__(self): - return "CSCONS03-BRL" + return "RAD-BRL" def __str__(self): - return "CSCONS03-BRL" + return "RAD-BRL" def __call__(self): - return "CSCONS03-BRL" + return "RAD-BRL" -CSCONS03_BRL = CSCONS03_BRL() +NAVIFT_BRL = NAVIFT_BRL() @dataclass(slots=True, frozen=True) -class ALGO_BRL: - name: str = "ALGO-BRL" - precision: int = 0.00000001 +class NAVIFT_BRL: + """ + name: NAVIFT-BRL + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: None + maximum_order_size: None + margin: False + """ + name: str = "NAVIFT-BRL" + precision: int = 8 minimum_margin: float = None initial_margin: float = None minimum_order_size: float = None @@ -3508,22 +4858,31 @@ class ALGO_BRL: margin: bool = False def __repr__(self): - return "ALGO-BRL" + return "NAVIFT-BRL" def __str__(self): - return "ALGO-BRL" + return "NAVIFT-BRL" def __call__(self): - return "ALGO-BRL" + return "NAVIFT-BRL" -ALGO_BRL = ALGO_BRL() +INTERFT_BRL = INTERFT_BRL() @dataclass(slots=True, frozen=True) class INTERFT_BRL: + """ + name: INTERFT-BRL + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: None + maximum_order_size: None + margin: False + """ name: str = "INTERFT-BRL" - precision: int = 0.00000001 + precision: int = 8 minimum_margin: float = None initial_margin: float = None minimum_order_size: float = None @@ -3540,13 +4899,22 @@ def __call__(self): return "INTERFT-BRL" -INTERFT_BRL = INTERFT_BRL() +BAT_BRL = BAT_BRL() @dataclass(slots=True, frozen=True) -class GALFT_BRL: - name: str = "GALFT-BRL" - precision: int = 0.00000001 +class BAT_BRL: + """ + name: BAT-BRL + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: None + maximum_order_size: None + margin: False + """ + name: str = "BAT-BRL" + precision: int = 8 minimum_margin: float = None initial_margin: float = None minimum_order_size: float = None @@ -3554,22 +4922,31 @@ class GALFT_BRL: margin: bool = False def __repr__(self): - return "GALFT-BRL" + return "BAT-BRL" def __str__(self): - return "GALFT-BRL" + return "BAT-BRL" def __call__(self): - return "GALFT-BRL" + return "BAT-BRL" -GALFT_BRL = GALFT_BRL() +LPT_BRL = LPT_BRL() @dataclass(slots=True, frozen=True) -class MBFP10_BRL: - name: str = "MBFP10-BRL" - precision: int = 0.00000001 +class LPT_BRL: + """ + name: LPT-BRL + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: None + maximum_order_size: None + margin: False + """ + name: str = "LPT-BRL" + precision: int = 8 minimum_margin: float = None initial_margin: float = None minimum_order_size: float = None @@ -3577,22 +4954,31 @@ class MBFP10_BRL: margin: bool = False def __repr__(self): - return "MBFP10-BRL" + return "LPT-BRL" def __str__(self): - return "MBFP10-BRL" + return "LPT-BRL" def __call__(self): - return "MBFP10-BRL" + return "LPT-BRL" -MBFP10_BRL = MBFP10_BRL() +BAND_BRL = BAND_BRL() @dataclass(slots=True, frozen=True) -class MBCCSH11_BRL: - name: str = "MBCCSH11-BRL" - precision: int = 0.00000001 +class BAND_BRL: + """ + name: BAND-BRL + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: None + maximum_order_size: None + margin: False + """ + name: str = "BAND-BRL" + precision: int = 8 minimum_margin: float = None initial_margin: float = None minimum_order_size: float = None @@ -3600,22 +4986,31 @@ class MBCCSH11_BRL: margin: bool = False def __repr__(self): - return "MBCCSH11-BRL" + return "BAND-BRL" def __str__(self): - return "MBCCSH11-BRL" + return "BAND-BRL" def __call__(self): - return "MBCCSH11-BRL" + return "BAND-BRL" -MBCCSH11_BRL = MBCCSH11_BRL() +ALLFT_BRL = ALLFT_BRL() @dataclass(slots=True, frozen=True) -class DYDX_BRL: - name: str = "DYDX-BRL" - precision: int = 0.00000001 +class ALLFT_BRL: + """ + name: ALLFT-BRL + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: None + maximum_order_size: None + margin: False + """ + name: str = "ALLFT-BRL" + precision: int = 8 minimum_margin: float = None initial_margin: float = None minimum_order_size: float = None @@ -3623,22 +5018,63 @@ class DYDX_BRL: margin: bool = False def __repr__(self): - return "DYDX-BRL" + return "ALLFT-BRL" def __str__(self): - return "DYDX-BRL" + return "ALLFT-BRL" def __call__(self): - return "DYDX-BRL" + return "ALLFT-BRL" -DYDX_BRL = DYDX_BRL() +ARGFT_BRL = ARGFT_BRL() @dataclass(slots=True, frozen=True) -class MBPRK05_BRL: - name: str = "MBPRK05-BRL" - precision: int = 0.00000001 +class ARGFT_BRL: + """ + name: ARGFT-BRL + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: None + maximum_order_size: None + margin: False + """ + name: str = "ARGFT-BRL" + precision: int = 8 + minimum_margin: float = None + initial_margin: float = None + minimum_order_size: float = None + maximum_order_size: float = None + margin: bool = False + + def __repr__(self): + return "ARGFT-BRL" + + def __str__(self): + return "ARGFT-BRL" + + def __call__(self): + return "ARGFT-BRL" + + +METIS_BRL = METIS_BRL() + + +@dataclass(slots=True, frozen=True) +class METIS_BRL: + """ + name: METIS-BRL + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: None + maximum_order_size: None + margin: False + """ + name: str = "METIS-BRL" + precision: int = 8 minimum_margin: float = None initial_margin: float = None minimum_order_size: float = None @@ -3646,22 +5082,31 @@ class MBPRK05_BRL: margin: bool = False def __repr__(self): - return "MBPRK05-BRL" + return "METIS-BRL" def __str__(self): - return "MBPRK05-BRL" + return "METIS-BRL" def __call__(self): - return "MBPRK05-BRL" + return "METIS-BRL" -MBPRK05_BRL = MBPRK05_BRL() +BADGER_BRL = BADGER_BRL() @dataclass(slots=True, frozen=True) -class MBCONS02_BRL: - name: str = "MBCONS02-BRL" - precision: int = 0.00000001 +class BADGER_BRL: + """ + name: BADGER-BRL + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: None + maximum_order_size: None + margin: False + """ + name: str = "BADGER-BRL" + precision: int = 8 minimum_margin: float = None initial_margin: float = None minimum_order_size: float = None @@ -3669,22 +5114,31 @@ class MBCONS02_BRL: margin: bool = False def __repr__(self): - return "MBCONS02-BRL" + return "BADGER-BRL" def __str__(self): - return "MBCONS02-BRL" + return "BADGER-BRL" def __call__(self): - return "MBCONS02-BRL" + return "BADGER-BRL" -MBCONS02_BRL = MBCONS02_BRL() +HOT_BRL = HOT_BRL() @dataclass(slots=True, frozen=True) -class OCEAN_BRL: - name: str = "OCEAN-BRL" - precision: int = 0.00000001 +class HOT_BRL: + """ + name: HOT-BRL + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: None + maximum_order_size: None + margin: False + """ + name: str = "HOT-BRL" + precision: int = 8 minimum_margin: float = None initial_margin: float = None minimum_order_size: float = None @@ -3692,22 +5146,31 @@ class OCEAN_BRL: margin: bool = False def __repr__(self): - return "OCEAN-BRL" + return "HOT-BRL" def __str__(self): - return "OCEAN-BRL" + return "HOT-BRL" def __call__(self): - return "OCEAN-BRL" + return "HOT-BRL" -OCEAN_BRL = OCEAN_BRL() +KSM_BRL = KSM_BRL() @dataclass(slots=True, frozen=True) -class METIS_BRL: - name: str = "METIS-BRL" - precision: int = 0.00000001 +class KSM_BRL: + """ + name: KSM-BRL + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: None + maximum_order_size: None + margin: False + """ + name: str = "KSM-BRL" + precision: int = 8 minimum_margin: float = None initial_margin: float = None minimum_order_size: float = None @@ -3715,22 +5178,31 @@ class METIS_BRL: margin: bool = False def __repr__(self): - return "METIS-BRL" + return "KSM-BRL" def __str__(self): - return "METIS-BRL" + return "KSM-BRL" def __call__(self): - return "METIS-BRL" + return "KSM-BRL" -METIS_BRL = METIS_BRL() +ERN_BRL = ERN_BRL() @dataclass(slots=True, frozen=True) -class MBCCSH02_BRL: - name: str = "MBCCSH02-BRL" - precision: int = 0.00000001 +class ERN_BRL: + """ + name: ERN-BRL + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: None + maximum_order_size: None + margin: False + """ + name: str = "ERN-BRL" + precision: int = 8 minimum_margin: float = None initial_margin: float = None minimum_order_size: float = None @@ -3738,22 +5210,31 @@ class MBCCSH02_BRL: margin: bool = False def __repr__(self): - return "MBCCSH02-BRL" + return "ERN-BRL" def __str__(self): - return "MBCCSH02-BRL" + return "ERN-BRL" def __call__(self): - return "MBCCSH02-BRL" + return "ERN-BRL" -MBCCSH02_BRL = MBCCSH02_BRL() +JUVFT_BRL = JUVFT_BRL() @dataclass(slots=True, frozen=True) -class DIA_BRL: - name: str = "DIA-BRL" - precision: int = 0.00000001 +class JUVFT_BRL: + """ + name: JUVFT-BRL + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: None + maximum_order_size: None + margin: False + """ + name: str = "JUVFT-BRL" + precision: int = 8 minimum_margin: float = None initial_margin: float = None minimum_order_size: float = None @@ -3761,22 +5242,31 @@ class DIA_BRL: margin: bool = False def __repr__(self): - return "DIA-BRL" + return "JUVFT-BRL" def __str__(self): - return "DIA-BRL" + return "JUVFT-BRL" def __call__(self): - return "DIA-BRL" + return "JUVFT-BRL" -DIA_BRL = DIA_BRL() +SRM_BRL = SRM_BRL() @dataclass(slots=True, frozen=True) -class ENER03_BRL: - name: str = "ENER03-BRL" - precision: int = 0.00000001 +class SRM_BRL: + """ + name: SRM-BRL + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: None + maximum_order_size: None + margin: False + """ + name: str = "SRM-BRL" + precision: int = 8 minimum_margin: float = None initial_margin: float = None minimum_order_size: float = None @@ -3784,22 +5274,31 @@ class ENER03_BRL: margin: bool = False def __repr__(self): - return "ENER03-BRL" + return "SRM-BRL" def __str__(self): - return "ENER03-BRL" + return "SRM-BRL" def __call__(self): - return "ENER03-BRL" + return "SRM-BRL" -ENER03_BRL = ENER03_BRL() +MBFP12_BRL = MBFP12_BRL() @dataclass(slots=True, frozen=True) -class MENGOFT_BRL: - name: str = "MENGOFT-BRL" - precision: int = 0.00000001 +class MBFP12_BRL: + """ + name: MBFP12-BRL + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: None + maximum_order_size: None + margin: False + """ + name: str = "MBFP12-BRL" + precision: int = 8 minimum_margin: float = None initial_margin: float = None minimum_order_size: float = None @@ -3807,22 +5306,31 @@ class MENGOFT_BRL: margin: bool = False def __repr__(self): - return "MENGOFT-BRL" + return "MBFP12-BRL" def __str__(self): - return "MENGOFT-BRL" + return "MBFP12-BRL" def __call__(self): - return "MENGOFT-BRL" + return "MBFP12-BRL" -MENGOFT_BRL = MENGOFT_BRL() +CTSI_BRL = CTSI_BRL() @dataclass(slots=True, frozen=True) -class DAI_BRL: - name: str = "DAI-BRL" - precision: int = 0.00000001 +class CTSI_BRL: + """ + name: CTSI-BRL + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: None + maximum_order_size: None + margin: False + """ + name: str = "CTSI-BRL" + precision: int = 8 minimum_margin: float = None initial_margin: float = None minimum_order_size: float = None @@ -3830,22 +5338,31 @@ class DAI_BRL: margin: bool = False def __repr__(self): - return "DAI-BRL" + return "CTSI-BRL" def __str__(self): - return "DAI-BRL" + return "CTSI-BRL" def __call__(self): - return "DAI-BRL" + return "CTSI-BRL" -DAI_BRL = DAI_BRL() +UNI_BRL = UNI_BRL() @dataclass(slots=True, frozen=True) -class MBCCSH14_BRL: - name: str = "MBCCSH14-BRL" - precision: int = 0.00000001 +class UNI_BRL: + """ + name: UNI-BRL + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: None + maximum_order_size: None + margin: False + """ + name: str = "UNI-BRL" + precision: int = 8 minimum_margin: float = None initial_margin: float = None minimum_order_size: float = None @@ -3853,22 +5370,31 @@ class MBCCSH14_BRL: margin: bool = False def __repr__(self): - return "MBCCSH14-BRL" + return "UNI-BRL" def __str__(self): - return "MBCCSH14-BRL" + return "UNI-BRL" def __call__(self): - return "MBCCSH14-BRL" + return "UNI-BRL" -MBCCSH14_BRL = MBCCSH14_BRL() +MBPRK02_BRL = MBPRK02_BRL() @dataclass(slots=True, frozen=True) -class SUPER_BRL: - name: str = "SUPER-BRL" - precision: int = 0.00000001 +class MBPRK02_BRL: + """ + name: MBPRK02-BRL + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: None + maximum_order_size: None + margin: False + """ + name: str = "MBPRK02-BRL" + precision: int = 8 minimum_margin: float = None initial_margin: float = None minimum_order_size: float = None @@ -3876,22 +5402,31 @@ class SUPER_BRL: margin: bool = False def __repr__(self): - return "SUPER-BRL" + return "MBPRK02-BRL" def __str__(self): - return "SUPER-BRL" + return "MBPRK02-BRL" def __call__(self): - return "SUPER-BRL" + return "MBPRK02-BRL" -SUPER_BRL = SUPER_BRL() +MC_BRL = MC_BRL() @dataclass(slots=True, frozen=True) -class ENJ_BRL: - name: str = "ENJ-BRL" - precision: int = 0.00000001 +class MC_BRL: + """ + name: MC-BRL + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: None + maximum_order_size: None + margin: False + """ + name: str = "MC-BRL" + precision: int = 8 minimum_margin: float = None initial_margin: float = None minimum_order_size: float = None @@ -3899,22 +5434,31 @@ class ENJ_BRL: margin: bool = False def __repr__(self): - return "ENJ-BRL" + return "MC-BRL" def __str__(self): - return "ENJ-BRL" + return "MC-BRL" def __call__(self): - return "ENJ-BRL" + return "MC-BRL" -ENJ_BRL = ENJ_BRL() +ETH_BRL = ETH_BRL() @dataclass(slots=True, frozen=True) -class SAUBERFT_BRL: - name: str = "SAUBERFT-BRL" - precision: int = 0.00000001 +class ETH_BRL: + """ + name: ETH-BRL + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: None + maximum_order_size: None + margin: False + """ + name: str = "ETH-BRL" + precision: int = 8 minimum_margin: float = None initial_margin: float = None minimum_order_size: float = None @@ -3922,22 +5466,31 @@ class SAUBERFT_BRL: margin: bool = False def __repr__(self): - return "SAUBERFT-BRL" + return "ETH-BRL" def __str__(self): - return "SAUBERFT-BRL" + return "ETH-BRL" def __call__(self): - return "SAUBERFT-BRL" + return "ETH-BRL" -SAUBERFT_BRL = SAUBERFT_BRL() +RLY_BRL = RLY_BRL() @dataclass(slots=True, frozen=True) -class PLA_BRL: - name: str = "PLA-BRL" - precision: int = 0.00000001 +class RLY_BRL: + """ + name: RLY-BRL + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: None + maximum_order_size: None + margin: False + """ + name: str = "RLY-BRL" + precision: int = 8 minimum_margin: float = None initial_margin: float = None minimum_order_size: float = None @@ -3945,22 +5498,31 @@ class PLA_BRL: margin: bool = False def __repr__(self): - return "PLA-BRL" + return "RLY-BRL" def __str__(self): - return "PLA-BRL" + return "RLY-BRL" def __call__(self): - return "PLA-BRL" + return "RLY-BRL" -PLA_BRL = PLA_BRL() +FIL_BRL = FIL_BRL() @dataclass(slots=True, frozen=True) -class XLM_BRL: - name: str = "XLM-BRL" - precision: int = 0.00000001 +class FIL_BRL: + """ + name: FIL-BRL + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: None + maximum_order_size: None + margin: False + """ + name: str = "FIL-BRL" + precision: int = 8 minimum_margin: float = None initial_margin: float = None minimum_order_size: float = None @@ -3968,22 +5530,31 @@ class XLM_BRL: margin: bool = False def __repr__(self): - return "XLM-BRL" + return "FIL-BRL" def __str__(self): - return "XLM-BRL" + return "FIL-BRL" def __call__(self): - return "XLM-BRL" + return "FIL-BRL" -XLM_BRL = XLM_BRL() +MBVASCO01_BRL = MBVASCO01_BRL() @dataclass(slots=True, frozen=True) -class BTB10_BRL: - name: str = "BTB10-BRL" - precision: int = 0.00000001 +class MBVASCO01_BRL: + """ + name: MBVASCO01-BRL + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: None + maximum_order_size: None + margin: False + """ + name: str = "MBVASCO01-BRL" + precision: int = 8 minimum_margin: float = None initial_margin: float = None minimum_order_size: float = None @@ -3991,22 +5562,31 @@ class BTB10_BRL: margin: bool = False def __repr__(self): - return "BTB10-BRL" + return "MBVASCO01-BRL" def __str__(self): - return "BTB10-BRL" + return "MBVASCO01-BRL" def __call__(self): - return "BTB10-BRL" + return "MBVASCO01-BRL" -BTB10_BRL = BTB10_BRL() +MBPRK07_BRL = MBPRK07_BRL() @dataclass(slots=True, frozen=True) -class KSM_BRL: - name: str = "KSM-BRL" - precision: int = 0.00000001 +class MBPRK07_BRL: + """ + name: MBPRK07-BRL + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: None + maximum_order_size: None + margin: False + """ + name: str = "MBPRK07-BRL" + precision: int = 8 minimum_margin: float = None initial_margin: float = None minimum_order_size: float = None @@ -4014,22 +5594,31 @@ class KSM_BRL: margin: bool = False def __repr__(self): - return "KSM-BRL" + return "MBPRK07-BRL" def __str__(self): - return "KSM-BRL" + return "MBPRK07-BRL" def __call__(self): - return "KSM-BRL" + return "MBPRK07-BRL" -KSM_BRL = KSM_BRL() +CSCONS02_BRL = CSCONS02_BRL() @dataclass(slots=True, frozen=True) -class MBFP12_BRL: - name: str = "MBFP12-BRL" - precision: int = 0.00000001 +class CSCONS02_BRL: + """ + name: CSCONS02-BRL + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: None + maximum_order_size: None + margin: False + """ + name: str = "CSCONS02-BRL" + precision: int = 8 minimum_margin: float = None initial_margin: float = None minimum_order_size: float = None @@ -4037,22 +5626,31 @@ class MBFP12_BRL: margin: bool = False def __repr__(self): - return "MBFP12-BRL" + return "CSCONS02-BRL" def __str__(self): - return "MBFP12-BRL" + return "CSCONS02-BRL" def __call__(self): - return "MBFP12-BRL" + return "CSCONS02-BRL" -MBFP12_BRL = MBFP12_BRL() +ALGO_BRL = ALGO_BRL() @dataclass(slots=True, frozen=True) -class SPELL_BRL: - name: str = "SPELL-BRL" - precision: int = 0.00000001 +class ALGO_BRL: + """ + name: ALGO-BRL + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: None + maximum_order_size: None + margin: False + """ + name: str = "ALGO-BRL" + precision: int = 8 minimum_margin: float = None initial_margin: float = None minimum_order_size: float = None @@ -4060,22 +5658,31 @@ class SPELL_BRL: margin: bool = False def __repr__(self): - return "SPELL-BRL" + return "ALGO-BRL" def __str__(self): - return "SPELL-BRL" + return "ALGO-BRL" def __call__(self): - return "SPELL-BRL" + return "ALGO-BRL" -SPELL_BRL = SPELL_BRL() +MBPRK01_BRL = MBPRK01_BRL() @dataclass(slots=True, frozen=True) -class REN_BRL: - name: str = "REN-BRL" - precision: int = 0.00000001 +class MBPRK01_BRL: + """ + name: MBPRK01-BRL + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: None + maximum_order_size: None + margin: False + """ + name: str = "MBPRK01-BRL" + precision: int = 8 minimum_margin: float = None initial_margin: float = None minimum_order_size: float = None @@ -4083,22 +5690,31 @@ class REN_BRL: margin: bool = False def __repr__(self): - return "REN-BRL" + return "MBPRK01-BRL" def __str__(self): - return "REN-BRL" + return "MBPRK01-BRL" def __call__(self): - return "REN-BRL" + return "MBPRK01-BRL" -REN_BRL = REN_BRL() +BARFT_BRL = BARFT_BRL() @dataclass(slots=True, frozen=True) -class GALOFT_BRL: - name: str = "GALOFT-BRL" - precision: int = 0.00000001 +class BARFT_BRL: + """ + name: BARFT-BRL + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: None + maximum_order_size: None + margin: False + """ + name: str = "BARFT-BRL" + precision: int = 8 minimum_margin: float = None initial_margin: float = None minimum_order_size: float = None @@ -4106,22 +5722,31 @@ class GALOFT_BRL: margin: bool = False def __repr__(self): - return "GALOFT-BRL" + return "BARFT-BRL" def __str__(self): - return "GALOFT-BRL" + return "BARFT-BRL" def __call__(self): - return "GALOFT-BRL" + return "BARFT-BRL" -GALOFT_BRL = GALOFT_BRL() +MIR_BRL = MIR_BRL() @dataclass(slots=True, frozen=True) -class PERP_BRL: - name: str = "PERP-BRL" - precision: int = 0.00000001 +class MIR_BRL: + """ + name: MIR-BRL + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: None + maximum_order_size: None + margin: False + """ + name: str = "MIR-BRL" + precision: int = 8 minimum_margin: float = None initial_margin: float = None minimum_order_size: float = None @@ -4129,22 +5754,31 @@ class PERP_BRL: margin: bool = False def __repr__(self): - return "PERP-BRL" + return "MIR-BRL" def __str__(self): - return "PERP-BRL" + return "MIR-BRL" def __call__(self): - return "PERP-BRL" + return "MIR-BRL" -PERP_BRL = PERP_BRL() +DYDX_BRL = DYDX_BRL() @dataclass(slots=True, frozen=True) -class STX_BRL: - name: str = "STX-BRL" - precision: int = 0.00000001 +class DYDX_BRL: + """ + name: DYDX-BRL + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: None + maximum_order_size: None + margin: False + """ + name: str = "DYDX-BRL" + precision: int = 8 minimum_margin: float = None initial_margin: float = None minimum_order_size: float = None @@ -4152,22 +5786,31 @@ class STX_BRL: margin: bool = False def __repr__(self): - return "STX-BRL" + return "DYDX-BRL" def __str__(self): - return "STX-BRL" + return "DYDX-BRL" def __call__(self): - return "STX-BRL" + return "DYDX-BRL" -STX_BRL = STX_BRL() +USDC_BRL = USDC_BRL() @dataclass(slots=True, frozen=True) -class ALICE_BRL: - name: str = "ALICE-BRL" - precision: int = 0.00000001 +class USDC_BRL: + """ + name: USDC-BRL + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: None + maximum_order_size: None + margin: False + """ + name: str = "USDC-BRL" + precision: int = 8 minimum_margin: float = None initial_margin: float = None minimum_order_size: float = None @@ -4175,22 +5818,31 @@ class ALICE_BRL: margin: bool = False def __repr__(self): - return "ALICE-BRL" + return "USDC-BRL" def __str__(self): - return "ALICE-BRL" + return "USDC-BRL" def __call__(self): - return "ALICE-BRL" + return "USDC-BRL" -ALICE_BRL = ALICE_BRL() +CVC_BRL = CVC_BRL() @dataclass(slots=True, frozen=True) -class MBCCSH09_BRL: - name: str = "MBCCSH09-BRL" - precision: int = 0.00000001 +class CVC_BRL: + """ + name: CVC-BRL + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: None + maximum_order_size: None + margin: False + """ + name: str = "CVC-BRL" + precision: int = 8 minimum_margin: float = None initial_margin: float = None minimum_order_size: float = None @@ -4198,22 +5850,31 @@ class MBCCSH09_BRL: margin: bool = False def __repr__(self): - return "MBCCSH09-BRL" + return "CVC-BRL" def __str__(self): - return "MBCCSH09-BRL" + return "CVC-BRL" def __call__(self): - return "MBCCSH09-BRL" + return "CVC-BRL" -MBCCSH09_BRL = MBCCSH09_BRL() +ADA_BRL = ADA_BRL() @dataclass(slots=True, frozen=True) -class MBCCSH10_BRL: - name: str = "MBCCSH10-BRL" - precision: int = 0.00000001 +class ADA_BRL: + """ + name: ADA-BRL + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: None + maximum_order_size: None + margin: False + """ + name: str = "ADA-BRL" + precision: int = 8 minimum_margin: float = None initial_margin: float = None minimum_order_size: float = None @@ -4221,22 +5882,31 @@ class MBCCSH10_BRL: margin: bool = False def __repr__(self): - return "MBCCSH10-BRL" + return "ADA-BRL" def __str__(self): - return "MBCCSH10-BRL" + return "ADA-BRL" def __call__(self): - return "MBCCSH10-BRL" + return "ADA-BRL" -MBCCSH10_BRL = MBCCSH10_BRL() +CSCONS05_BRL = CSCONS05_BRL() @dataclass(slots=True, frozen=True) -class MBCCSH12_BRL: - name: str = "MBCCSH12-BRL" - precision: int = 0.00000001 +class CSCONS05_BRL: + """ + name: CSCONS05-BRL + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: None + maximum_order_size: None + margin: False + """ + name: str = "CSCONS05-BRL" + precision: int = 8 minimum_margin: float = None initial_margin: float = None minimum_order_size: float = None @@ -4244,22 +5914,31 @@ class MBCCSH12_BRL: margin: bool = False def __repr__(self): - return "MBCCSH12-BRL" + return "CSCONS05-BRL" def __str__(self): - return "MBCCSH12-BRL" + return "CSCONS05-BRL" def __call__(self): - return "MBCCSH12-BRL" + return "CSCONS05-BRL" -MBCCSH12_BRL = MBCCSH12_BRL() +UMA_BRL = UMA_BRL() @dataclass(slots=True, frozen=True) -class WLUNA_BRL: - name: str = "WLUNA-BRL" - precision: int = 0.00000001 +class UMA_BRL: + """ + name: UMA-BRL + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: None + maximum_order_size: None + margin: False + """ + name: str = "UMA-BRL" + precision: int = 8 minimum_margin: float = None initial_margin: float = None minimum_order_size: float = None @@ -4267,22 +5946,31 @@ class WLUNA_BRL: margin: bool = False def __repr__(self): - return "WLUNA-BRL" + return "UMA-BRL" def __str__(self): - return "WLUNA-BRL" + return "UMA-BRL" def __call__(self): - return "WLUNA-BRL" + return "UMA-BRL" -WLUNA_BRL = WLUNA_BRL() +SYN_BRL = SYN_BRL() @dataclass(slots=True, frozen=True) -class CRV_BRL: - name: str = "CRV-BRL" - precision: int = 0.00000001 +class SYN_BRL: + """ + name: SYN-BRL + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: None + maximum_order_size: None + margin: False + """ + name: str = "SYN-BRL" + precision: int = 8 minimum_margin: float = None initial_margin: float = None minimum_order_size: float = None @@ -4290,22 +5978,31 @@ class CRV_BRL: margin: bool = False def __repr__(self): - return "CRV-BRL" + return "SYN-BRL" def __str__(self): - return "CRV-BRL" + return "SYN-BRL" def __call__(self): - return "CRV-BRL" + return "SYN-BRL" -CRV_BRL = CRV_BRL() +STVFT_BRL = STVFT_BRL() @dataclass(slots=True, frozen=True) -class USDP_BRL: - name: str = "USDP-BRL" - precision: int = 0.00000001 +class STVFT_BRL: + """ + name: STVFT-BRL + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: None + maximum_order_size: None + margin: False + """ + name: str = "STVFT-BRL" + precision: int = 8 minimum_margin: float = None initial_margin: float = None minimum_order_size: float = None @@ -4313,22 +6010,31 @@ class USDP_BRL: margin: bool = False def __repr__(self): - return "USDP-BRL" + return "STVFT-BRL" def __str__(self): - return "USDP-BRL" + return "STVFT-BRL" def __call__(self): - return "USDP-BRL" + return "STVFT-BRL" -USDP_BRL = USDP_BRL() +MBCCSH07_BRL = MBCCSH07_BRL() @dataclass(slots=True, frozen=True) -class GST_BRL: - name: str = "GST-BRL" - precision: int = 0.00000001 +class MBCCSH07_BRL: + """ + name: MBCCSH07-BRL + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: None + maximum_order_size: None + margin: False + """ + name: str = "MBCCSH07-BRL" + precision: int = 8 minimum_margin: float = None initial_margin: float = None minimum_order_size: float = None @@ -4336,22 +6042,31 @@ class GST_BRL: margin: bool = False def __repr__(self): - return "GST-BRL" + return "MBCCSH07-BRL" def __str__(self): - return "GST-BRL" + return "MBCCSH07-BRL" def __call__(self): - return "GST-BRL" + return "MBCCSH07-BRL" -GST_BRL = GST_BRL() +CRV_BRL = CRV_BRL() @dataclass(slots=True, frozen=True) -class ENER02_BRL: - name: str = "ENER02-BRL" - precision: int = 0.00000001 +class CRV_BRL: + """ + name: CRV-BRL + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: None + maximum_order_size: None + margin: False + """ + name: str = "CRV-BRL" + precision: int = 8 minimum_margin: float = None initial_margin: float = None minimum_order_size: float = None @@ -4359,22 +6074,31 @@ class ENER02_BRL: margin: bool = False def __repr__(self): - return "ENER02-BRL" + return "CRV-BRL" def __str__(self): - return "ENER02-BRL" + return "CRV-BRL" def __call__(self): - return "ENER02-BRL" + return "CRV-BRL" -ENER02_BRL = ENER02_BRL() +RACA_BRL = RACA_BRL() @dataclass(slots=True, frozen=True) -class MBCCSH08_BRL: - name: str = "MBCCSH08-BRL" - precision: int = 0.00000001 +class RACA_BRL: + """ + name: RACA-BRL + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: None + maximum_order_size: None + margin: False + """ + name: str = "RACA-BRL" + precision: int = 8 minimum_margin: float = None initial_margin: float = None minimum_order_size: float = None @@ -4382,22 +6106,31 @@ class MBCCSH08_BRL: margin: bool = False def __repr__(self): - return "MBCCSH08-BRL" + return "RACA-BRL" def __str__(self): - return "MBCCSH08-BRL" + return "RACA-BRL" def __call__(self): - return "MBCCSH08-BRL" + return "RACA-BRL" -MBCCSH08_BRL = MBCCSH08_BRL() +ROSE_BRL = ROSE_BRL() @dataclass(slots=True, frozen=True) -class CVX_BRL: - name: str = "CVX-BRL" - precision: int = 0.00000001 +class ROSE_BRL: + """ + name: ROSE-BRL + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: None + maximum_order_size: None + margin: False + """ + name: str = "ROSE-BRL" + precision: int = 8 minimum_margin: float = None initial_margin: float = None minimum_order_size: float = None @@ -4405,22 +6138,31 @@ class CVX_BRL: margin: bool = False def __repr__(self): - return "CVX-BRL" + return "ROSE-BRL" def __str__(self): - return "CVX-BRL" + return "ROSE-BRL" def __call__(self): - return "CVX-BRL" + return "ROSE-BRL" -CVX_BRL = CVX_BRL() +ENER01_BRL = ENER01_BRL() @dataclass(slots=True, frozen=True) -class ADA_BRL: - name: str = "ADA-BRL" - precision: int = 0.00000001 +class ENER01_BRL: + """ + name: ENER01-BRL + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: None + maximum_order_size: None + margin: False + """ + name: str = "ENER01-BRL" + precision: int = 8 minimum_margin: float = None initial_margin: float = None minimum_order_size: float = None @@ -4428,22 +6170,31 @@ class ADA_BRL: margin: bool = False def __repr__(self): - return "ADA-BRL" + return "ENER01-BRL" def __str__(self): - return "ADA-BRL" + return "ENER01-BRL" def __call__(self): - return "ADA-BRL" + return "ENER01-BRL" -ADA_BRL = ADA_BRL() +ICP_BRL = ICP_BRL() @dataclass(slots=True, frozen=True) -class MPL_BRL: - name: str = "MPL-BRL" - precision: int = 0.00000001 +class ICP_BRL: + """ + name: ICP-BRL + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: None + maximum_order_size: None + margin: False + """ + name: str = "ICP-BRL" + precision: int = 8 minimum_margin: float = None initial_margin: float = None minimum_order_size: float = None @@ -4451,22 +6202,31 @@ class MPL_BRL: margin: bool = False def __repr__(self): - return "MPL-BRL" + return "ICP-BRL" def __str__(self): - return "MPL-BRL" + return "ICP-BRL" def __call__(self): - return "MPL-BRL" + return "ICP-BRL" -MPL_BRL = MPL_BRL() +MBPRK04_BRL = MBPRK04_BRL() @dataclass(slots=True, frozen=True) -class FLOW_BRL: - name: str = "FLOW-BRL" - precision: int = 0.00000001 +class MBPRK04_BRL: + """ + name: MBPRK04-BRL + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: None + maximum_order_size: None + margin: False + """ + name: str = "MBPRK04-BRL" + precision: int = 8 minimum_margin: float = None initial_margin: float = None minimum_order_size: float = None @@ -4474,22 +6234,31 @@ class FLOW_BRL: margin: bool = False def __repr__(self): - return "FLOW-BRL" + return "MBPRK04-BRL" def __str__(self): - return "FLOW-BRL" + return "MBPRK04-BRL" def __call__(self): - return "FLOW-BRL" + return "MBPRK04-BRL" -FLOW_BRL = FLOW_BRL() +SAUBERFT_BRL = SAUBERFT_BRL() @dataclass(slots=True, frozen=True) -class LPT_BRL: - name: str = "LPT-BRL" - precision: int = 0.00000001 +class SAUBERFT_BRL: + """ + name: SAUBERFT-BRL + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: None + maximum_order_size: None + margin: False + """ + name: str = "SAUBERFT-BRL" + precision: int = 8 minimum_margin: float = None initial_margin: float = None minimum_order_size: float = None @@ -4497,22 +6266,31 @@ class LPT_BRL: margin: bool = False def __repr__(self): - return "LPT-BRL" + return "SAUBERFT-BRL" def __str__(self): - return "LPT-BRL" + return "SAUBERFT-BRL" def __call__(self): - return "LPT-BRL" + return "SAUBERFT-BRL" -LPT_BRL = LPT_BRL() +MBFP08_BRL = MBFP08_BRL() @dataclass(slots=True, frozen=True) -class WBX_BRL: - name: str = "WBX-BRL" - precision: int = 0.00000001 +class MBFP08_BRL: + """ + name: MBFP08-BRL + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: None + maximum_order_size: None + margin: False + """ + name: str = "MBFP08-BRL" + precision: int = 8 minimum_margin: float = None initial_margin: float = None minimum_order_size: float = None @@ -4520,22 +6298,31 @@ class WBX_BRL: margin: bool = False def __repr__(self): - return "WBX-BRL" + return "MBFP08-BRL" def __str__(self): - return "WBX-BRL" + return "MBFP08-BRL" def __call__(self): - return "WBX-BRL" + return "MBFP08-BRL" -WBX_BRL = WBX_BRL() +NODL_BRL = NODL_BRL() @dataclass(slots=True, frozen=True) -class UNI_BRL: - name: str = "UNI-BRL" - precision: int = 0.00000001 +class NODL_BRL: + """ + name: NODL-BRL + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: None + maximum_order_size: None + margin: False + """ + name: str = "NODL-BRL" + precision: int = 8 minimum_margin: float = None initial_margin: float = None minimum_order_size: float = None @@ -4543,22 +6330,31 @@ class UNI_BRL: margin: bool = False def __repr__(self): - return "UNI-BRL" + return "NODL-BRL" def __str__(self): - return "UNI-BRL" + return "NODL-BRL" def __call__(self): - return "UNI-BRL" + return "NODL-BRL" -UNI_BRL = UNI_BRL() +OGFT_BRL = OGFT_BRL() @dataclass(slots=True, frozen=True) -class OPUL_BRL: - name: str = "OPUL-BRL" - precision: int = 0.00000001 +class OGFT_BRL: + """ + name: OGFT-BRL + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: None + maximum_order_size: None + margin: False + """ + name: str = "OGFT-BRL" + precision: int = 8 minimum_margin: float = None initial_margin: float = None minimum_order_size: float = None @@ -4566,22 +6362,31 @@ class OPUL_BRL: margin: bool = False def __repr__(self): - return "OPUL-BRL" + return "OGFT-BRL" def __str__(self): - return "OPUL-BRL" + return "OGFT-BRL" def __call__(self): - return "OPUL-BRL" + return "OGFT-BRL" -OPUL_BRL = OPUL_BRL() +SNX_BRL = SNX_BRL() @dataclass(slots=True, frozen=True) -class MBSANTOS01_BRL: - name: str = "MBSANTOS01-BRL" - precision: int = 0.00000001 +class SNX_BRL: + """ + name: SNX-BRL + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: None + maximum_order_size: None + margin: False + """ + name: str = "SNX-BRL" + precision: int = 8 minimum_margin: float = None initial_margin: float = None minimum_order_size: float = None @@ -4589,22 +6394,31 @@ class MBSANTOS01_BRL: margin: bool = False def __repr__(self): - return "MBSANTOS01-BRL" + return "SNX-BRL" def __str__(self): - return "MBSANTOS01-BRL" + return "SNX-BRL" def __call__(self): - return "MBSANTOS01-BRL" + return "SNX-BRL" -MBSANTOS01_BRL = MBSANTOS01_BRL() +ALCX_BRL = ALCX_BRL() @dataclass(slots=True, frozen=True) -class ATOM_BRL: - name: str = "ATOM-BRL" - precision: int = 0.00000001 +class ALCX_BRL: + """ + name: ALCX-BRL + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: None + maximum_order_size: None + margin: False + """ + name: str = "ALCX-BRL" + precision: int = 8 minimum_margin: float = None initial_margin: float = None minimum_order_size: float = None @@ -4612,22 +6426,31 @@ class ATOM_BRL: margin: bool = False def __repr__(self): - return "ATOM-BRL" + return "ALCX-BRL" def __str__(self): - return "ATOM-BRL" + return "ALCX-BRL" def __call__(self): - return "ATOM-BRL" + return "ALCX-BRL" -ATOM_BRL = ATOM_BRL() +MBFP07_BRL = MBFP07_BRL() @dataclass(slots=True, frozen=True) -class ASRFT_BRL: - name: str = "ASRFT-BRL" - precision: int = 0.00000001 +class MBFP07_BRL: + """ + name: MBFP07-BRL + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: None + maximum_order_size: None + margin: False + """ + name: str = "MBFP07-BRL" + precision: int = 8 minimum_margin: float = None initial_margin: float = None minimum_order_size: float = None @@ -4635,22 +6458,31 @@ class ASRFT_BRL: margin: bool = False def __repr__(self): - return "ASRFT-BRL" + return "MBFP07-BRL" def __str__(self): - return "ASRFT-BRL" + return "MBFP07-BRL" def __call__(self): - return "ASRFT-BRL" + return "MBFP07-BRL" -ASRFT_BRL = ASRFT_BRL() +ANT_BRL = ANT_BRL() @dataclass(slots=True, frozen=True) -class BTC_BRL: - name: str = "BTC-BRL" - precision: int = 0.00000001 +class ANT_BRL: + """ + name: ANT-BRL + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: None + maximum_order_size: None + margin: False + """ + name: str = "ANT-BRL" + precision: int = 8 minimum_margin: float = None initial_margin: float = None minimum_order_size: float = None @@ -4658,22 +6490,31 @@ class BTC_BRL: margin: bool = False def __repr__(self): - return "BTC-BRL" + return "ANT-BRL" def __str__(self): - return "BTC-BRL" + return "ANT-BRL" def __call__(self): - return "BTC-BRL" + return "ANT-BRL" -BTC_BRL = BTC_BRL() +DIA_BRL = DIA_BRL() @dataclass(slots=True, frozen=True) -class PORFT_BRL: - name: str = "PORFT-BRL" - precision: int = 0.00000001 +class DIA_BRL: + """ + name: DIA-BRL + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: None + maximum_order_size: None + margin: False + """ + name: str = "DIA-BRL" + precision: int = 8 minimum_margin: float = None initial_margin: float = None minimum_order_size: float = None @@ -4681,22 +6522,31 @@ class PORFT_BRL: margin: bool = False def __repr__(self): - return "PORFT-BRL" + return "DIA-BRL" def __str__(self): - return "PORFT-BRL" + return "DIA-BRL" def __call__(self): - return "PORFT-BRL" + return "DIA-BRL" -PORFT_BRL = PORFT_BRL() +SPELL_BRL = SPELL_BRL() @dataclass(slots=True, frozen=True) -class ACH_BRL: - name: str = "ACH-BRL" - precision: int = 0.00000001 +class SPELL_BRL: + """ + name: SPELL-BRL + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: None + maximum_order_size: None + margin: False + """ + name: str = "SPELL-BRL" + precision: int = 8 minimum_margin: float = None initial_margin: float = None minimum_order_size: float = None @@ -4704,22 +6554,31 @@ class ACH_BRL: margin: bool = False def __repr__(self): - return "ACH-BRL" + return "SPELL-BRL" def __str__(self): - return "ACH-BRL" + return "SPELL-BRL" def __call__(self): - return "ACH-BRL" + return "SPELL-BRL" -ACH_BRL = ACH_BRL() +AVAX_BRL = AVAX_BRL() @dataclass(slots=True, frozen=True) -class MBCCSH07_BRL: - name: str = "MBCCSH07-BRL" - precision: int = 0.00000001 +class AVAX_BRL: + """ + name: AVAX-BRL + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: None + maximum_order_size: None + margin: False + """ + name: str = "AVAX-BRL" + precision: int = 8 minimum_margin: float = None initial_margin: float = None minimum_order_size: float = None @@ -4727,22 +6586,31 @@ class MBCCSH07_BRL: margin: bool = False def __repr__(self): - return "MBCCSH07-BRL" + return "AVAX-BRL" def __str__(self): - return "MBCCSH07-BRL" + return "AVAX-BRL" def __call__(self): - return "MBCCSH07-BRL" + return "AVAX-BRL" -MBCCSH07_BRL = MBCCSH07_BRL() +YFI_BRL = YFI_BRL() @dataclass(slots=True, frozen=True) -class BNT_BRL: - name: str = "BNT-BRL" - precision: int = 0.00000001 +class YFI_BRL: + """ + name: YFI-BRL + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: None + maximum_order_size: None + margin: False + """ + name: str = "YFI-BRL" + precision: int = 8 minimum_margin: float = None initial_margin: float = None minimum_order_size: float = None @@ -4750,22 +6618,31 @@ class BNT_BRL: margin: bool = False def __repr__(self): - return "BNT-BRL" + return "YFI-BRL" def __str__(self): - return "BNT-BRL" + return "YFI-BRL" def __call__(self): - return "BNT-BRL" + return "YFI-BRL" -BNT_BRL = BNT_BRL() +GRT_BRL = GRT_BRL() @dataclass(slots=True, frozen=True) -class SUSHI_BRL: - name: str = "SUSHI-BRL" - precision: int = 0.00000001 +class GRT_BRL: + """ + name: GRT-BRL + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: None + maximum_order_size: None + margin: False + """ + name: str = "GRT-BRL" + precision: int = 8 minimum_margin: float = None initial_margin: float = None minimum_order_size: float = None @@ -4773,22 +6650,31 @@ class SUSHI_BRL: margin: bool = False def __repr__(self): - return "SUSHI-BRL" + return "GRT-BRL" def __str__(self): - return "SUSHI-BRL" + return "GRT-BRL" def __call__(self): - return "SUSHI-BRL" + return "GRT-BRL" -SUSHI_BRL = SUSHI_BRL() +BAL_BRL = BAL_BRL() @dataclass(slots=True, frozen=True) -class FET_BRL: - name: str = "FET-BRL" - precision: int = 0.00000001 +class BAL_BRL: + """ + name: BAL-BRL + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: None + maximum_order_size: None + margin: False + """ + name: str = "BAL-BRL" + precision: int = 8 minimum_margin: float = None initial_margin: float = None minimum_order_size: float = None @@ -4796,22 +6682,31 @@ class FET_BRL: margin: bool = False def __repr__(self): - return "FET-BRL" + return "BAL-BRL" def __str__(self): - return "FET-BRL" + return "BAL-BRL" def __call__(self): - return "FET-BRL" + return "BAL-BRL" -FET_BRL = FET_BRL() +STG_BRL = STG_BRL() @dataclass(slots=True, frozen=True) -class LOOKS_BRL: - name: str = "LOOKS-BRL" - precision: int = 0.00000001 +class STG_BRL: + """ + name: STG-BRL + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: None + maximum_order_size: None + margin: False + """ + name: str = "STG-BRL" + precision: int = 8 minimum_margin: float = None initial_margin: float = None minimum_order_size: float = None @@ -4819,22 +6714,31 @@ class LOOKS_BRL: margin: bool = False def __repr__(self): - return "LOOKS-BRL" + return "STG-BRL" def __str__(self): - return "LOOKS-BRL" + return "STG-BRL" def __call__(self): - return "LOOKS-BRL" + return "STG-BRL" -LOOKS_BRL = LOOKS_BRL() +MBFP11_BRL = MBFP11_BRL() @dataclass(slots=True, frozen=True) -class RLY_BRL: - name: str = "RLY-BRL" - precision: int = 0.00000001 +class MBFP11_BRL: + """ + name: MBFP11-BRL + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: None + maximum_order_size: None + margin: False + """ + name: str = "MBFP11-BRL" + precision: int = 8 minimum_margin: float = None initial_margin: float = None minimum_order_size: float = None @@ -4842,22 +6746,31 @@ class RLY_BRL: margin: bool = False def __repr__(self): - return "RLY-BRL" + return "MBFP11-BRL" def __str__(self): - return "RLY-BRL" + return "MBFP11-BRL" def __call__(self): - return "RLY-BRL" + return "MBFP11-BRL" -RLY_BRL = RLY_BRL() +MBCCSH10_BRL = MBCCSH10_BRL() @dataclass(slots=True, frozen=True) -class HIGH_BRL: - name: str = "HIGH-BRL" - precision: int = 0.00000001 +class MBCCSH10_BRL: + """ + name: MBCCSH10-BRL + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: None + maximum_order_size: None + margin: False + """ + name: str = "MBCCSH10-BRL" + precision: int = 8 minimum_margin: float = None initial_margin: float = None minimum_order_size: float = None @@ -4865,22 +6778,31 @@ class HIGH_BRL: margin: bool = False def __repr__(self): - return "HIGH-BRL" + return "MBCCSH10-BRL" def __str__(self): - return "HIGH-BRL" + return "MBCCSH10-BRL" def __call__(self): - return "HIGH-BRL" + return "MBCCSH10-BRL" -HIGH_BRL = HIGH_BRL() +ADS_BRL = ADS_BRL() @dataclass(slots=True, frozen=True) -class KP3R_BRL: - name: str = "KP3R-BRL" - precision: int = 0.00000001 +class ADS_BRL: + """ + name: ADS-BRL + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: None + maximum_order_size: None + margin: False + """ + name: str = "ADS-BRL" + precision: int = 8 minimum_margin: float = None initial_margin: float = None minimum_order_size: float = None @@ -4888,22 +6810,31 @@ class KP3R_BRL: margin: bool = False def __repr__(self): - return "KP3R-BRL" + return "ADS-BRL" def __str__(self): - return "KP3R-BRL" + return "ADS-BRL" def __call__(self): - return "KP3R-BRL" + return "ADS-BRL" -KP3R_BRL = KP3R_BRL() +DPI_BRL = DPI_BRL() @dataclass(slots=True, frozen=True) -class ROSE_BRL: - name: str = "ROSE-BRL" - precision: int = 0.00000001 +class DPI_BRL: + """ + name: DPI-BRL + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: None + maximum_order_size: None + margin: False + """ + name: str = "DPI-BRL" + precision: int = 8 minimum_margin: float = None initial_margin: float = None minimum_order_size: float = None @@ -4911,22 +6842,31 @@ class ROSE_BRL: margin: bool = False def __repr__(self): - return "ROSE-BRL" + return "DPI-BRL" def __str__(self): - return "ROSE-BRL" + return "DPI-BRL" def __call__(self): - return "ROSE-BRL" + return "DPI-BRL" -ROSE_BRL = ROSE_BRL() +BTB05_BRL = BTB05_BRL() @dataclass(slots=True, frozen=True) -class MBPRK03_BRL: - name: str = "MBPRK03-BRL" - precision: int = 0.00000001 +class BTB05_BRL: + """ + name: BTB05-BRL + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: None + maximum_order_size: None + margin: False + """ + name: str = "BTB05-BRL" + precision: int = 8 minimum_margin: float = None initial_margin: float = None minimum_order_size: float = None @@ -4934,22 +6874,31 @@ class MBPRK03_BRL: margin: bool = False def __repr__(self): - return "MBPRK03-BRL" + return "BTB05-BRL" def __str__(self): - return "MBPRK03-BRL" + return "BTB05-BRL" def __call__(self): - return "MBPRK03-BRL" + return "BTB05-BRL" -MBPRK03_BRL = MBPRK03_BRL() +MBPRK05_BRL = MBPRK05_BRL() @dataclass(slots=True, frozen=True) -class CSCONS01_BRL: - name: str = "CSCONS01-BRL" - precision: int = 0.00000001 +class MBPRK05_BRL: + """ + name: MBPRK05-BRL + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: None + maximum_order_size: None + margin: False + """ + name: str = "MBPRK05-BRL" + precision: int = 8 minimum_margin: float = None initial_margin: float = None minimum_order_size: float = None @@ -4957,22 +6906,31 @@ class CSCONS01_BRL: margin: bool = False def __repr__(self): - return "CSCONS01-BRL" + return "MBPRK05-BRL" def __str__(self): - return "CSCONS01-BRL" + return "MBPRK05-BRL" def __call__(self): - return "CSCONS01-BRL" + return "MBPRK05-BRL" -CSCONS01_BRL = CSCONS01_BRL() +FLOKI_BRL = FLOKI_BRL() @dataclass(slots=True, frozen=True) -class CEEK_BRL: - name: str = "CEEK-BRL" - precision: int = 0.00000001 +class FLOKI_BRL: + """ + name: FLOKI-BRL + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: None + maximum_order_size: None + margin: False + """ + name: str = "FLOKI-BRL" + precision: int = 8 minimum_margin: float = None initial_margin: float = None minimum_order_size: float = None @@ -4980,22 +6938,31 @@ class CEEK_BRL: margin: bool = False def __repr__(self): - return "CEEK-BRL" + return "FLOKI-BRL" def __str__(self): - return "CEEK-BRL" + return "FLOKI-BRL" def __call__(self): - return "CEEK-BRL" + return "FLOKI-BRL" -CEEK_BRL = CEEK_BRL() +ENJ_BRL = ENJ_BRL() @dataclass(slots=True, frozen=True) -class CSCONS04_BRL: - name: str = "CSCONS04-BRL" - precision: int = 0.00000001 +class ENJ_BRL: + """ + name: ENJ-BRL + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: None + maximum_order_size: None + margin: False + """ + name: str = "ENJ-BRL" + precision: int = 8 minimum_margin: float = None initial_margin: float = None minimum_order_size: float = None @@ -5003,22 +6970,31 @@ class CSCONS04_BRL: margin: bool = False def __repr__(self): - return "CSCONS04-BRL" + return "ENJ-BRL" def __str__(self): - return "CSCONS04-BRL" + return "ENJ-BRL" def __call__(self): - return "CSCONS04-BRL" + return "ENJ-BRL" -CSCONS04_BRL = CSCONS04_BRL() +BNT_BRL = BNT_BRL() @dataclass(slots=True, frozen=True) -class ATMFT_BRL: - name: str = "ATMFT-BRL" - precision: int = 0.00000001 +class BNT_BRL: + """ + name: BNT-BRL + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: None + maximum_order_size: None + margin: False + """ + name: str = "BNT-BRL" + precision: int = 8 minimum_margin: float = None initial_margin: float = None minimum_order_size: float = None @@ -5026,22 +7002,31 @@ class ATMFT_BRL: margin: bool = False def __repr__(self): - return "ATMFT-BRL" + return "BNT-BRL" def __str__(self): - return "ATMFT-BRL" + return "BNT-BRL" def __call__(self): - return "ATMFT-BRL" + return "BNT-BRL" -ATMFT_BRL = ATMFT_BRL() +RARI_BRL = RARI_BRL() @dataclass(slots=True, frozen=True) -class IMX_BRL: - name: str = "IMX-BRL" - precision: int = 0.00000001 +class RARI_BRL: + """ + name: RARI-BRL + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: None + maximum_order_size: None + margin: False + """ + name: str = "RARI-BRL" + precision: int = 8 minimum_margin: float = None initial_margin: float = None minimum_order_size: float = None @@ -5049,22 +7034,31 @@ class IMX_BRL: margin: bool = False def __repr__(self): - return "IMX-BRL" + return "RARI-BRL" def __str__(self): - return "IMX-BRL" + return "RARI-BRL" def __call__(self): - return "IMX-BRL" + return "RARI-BRL" -IMX_BRL = IMX_BRL() +XRP_BRL = XRP_BRL() @dataclass(slots=True, frozen=True) -class GMT_BRL: - name: str = "GMT-BRL" - precision: int = 0.00000001 +class XRP_BRL: + """ + name: XRP-BRL + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: None + maximum_order_size: None + margin: False + """ + name: str = "XRP-BRL" + precision: int = 8 minimum_margin: float = None initial_margin: float = None minimum_order_size: float = None @@ -5072,22 +7066,31 @@ class GMT_BRL: margin: bool = False def __repr__(self): - return "GMT-BRL" + return "XRP-BRL" def __str__(self): - return "GMT-BRL" + return "XRP-BRL" def __call__(self): - return "GMT-BRL" + return "XRP-BRL" -GMT_BRL = GMT_BRL() +ANKR_BRL = ANKR_BRL() @dataclass(slots=True, frozen=True) -class RFDFP16_BRL: - name: str = "RFDFP16-BRL" - precision: int = 0.00000001 +class ANKR_BRL: + """ + name: ANKR-BRL + precision: 8 + minimum_margin: None + initial_margin: None + minimum_order_size: None + maximum_order_size: None + margin: False + """ + name: str = "ANKR-BRL" + precision: int = 8 minimum_margin: float = None initial_margin: float = None minimum_order_size: float = None @@ -5095,15 +7098,10 @@ class RFDFP16_BRL: margin: bool = False def __repr__(self): - return "RFDFP16-BRL" + return "ANKR-BRL" def __str__(self): - return "RFDFP16-BRL" + return "ANKR-BRL" def __call__(self): - return "RFDFP16-BRL" - - -RFDFP16_BRL = RFDFP16_BRL() - - + return "ANKR-BRL"