def __init__(self, name: str = None, stream: Stream = None, socket_ip: str = None, socket_port: int = None) -> None:
"""
Init the api server, and init the super class RPC
"""
if name is None:
raise Exception("WebSocketServer needs distinguishable name for logging purposes")
self.name = '{}.{}'.format(__name__, name)
self.logger = setup_logger(name=self.name)
self.logger.info('Initializing %s component.', self.name)
if stream is None:
raise Exception("WebSocketServer needs distinguishable stream for operating purposes")
self.stream = stream
if socket_ip is None:
self.logger.info("WebSocketServer got no `socket_ip` defaulting to {}".format(self._socket_ip))
else:
self._socket_ip = socket_ip
if socket_port is None:
self.logger.info("WebSocketServer got no `socket_port` defaulting to {}".format(self._socket_port))
else:
self._socket_port = socket_port
self._socket_base_url = '{}:{}'.format(self._socket_ip, self._socket_port)
self.logger.info("Will serve WebSocket at %s", self._socket_base_url)
self.connections = []
self.read_queue = Queue()
self.write_queue = Queue()
self.connections = set()
self.connection_handler = ThreadPoolExecutor(4)
def __init__(self, name: str = None, rest_ip: str = None, rest_port: int = None) -> None:
"""
Init the api server, and init the super class RPC
"""
if name is None:
raise Exception("APIServer needs distinguishable name for logging purposes")
self.name = '{}.{}'.format(__name__, name)
self.logger = setup_logger(name=self.name)
self.logger.info('Initializing %s component.', self.name)
self.app = Flask(__name__)
CORS(self.app)
self.app.config['SECRET_KEY'] = "s!"#$123%!%&!&e!"123424#34534$%!5345%&!&c345!"#234$%!1342334224%&!&et!242!"#$%342!%&!&"
if rest_ip is None:
self.logger.info('APIServer got no `rest_ip` defaulting to {}'.format(self._rest_ip))
else:
self._rest_ip = rest_ip
if rest_port is None:
self.logger.info('APIServer got no `rest_port` defaulting to {}'.format(self._rest_port))
else:
self._rest_port = rest_port
self._rest_base_url = '{}:{}'.format(self._rest_ip, self._rest_port)
self.logger.info("Will serve API at %s", self._rest_base_url)
# Register base application handling
self.register_base_rest_rpc_urls()
def __init__(self, data: pd.DataFrame) -> None:
if not isinstance(data, pd.DataFrame):
raise ValueError("Data must be a pandas dataframe")
self.logger = setup_logger(name=self._name)
# rd stands for relativedelta
rd_call: Callable = None
rd_args: dict = None
rd_call, rd_args = get_delta_callable_for_tf(tf=self.tf)
self.__verbosity = settings.FORWARDTESTING_VERBOSITY
self.__analysis_throttle = rd_call(**rd_args)
self.__next_candle = (dt.fromtimestamp(self.yesterday.time) +
self.__analysis_throttle)
self.__next_analysis = (self.__next_candle + self.__analysis_throttle)
self.__start_time = dt.now()
self.logger.info(
'Forward testing session started for: {}-{} using {} at {} '.
format(
self.pair,
self.tf,
self.logic.__name__,
self.__start_time,
), )
self.logger.info('next analysis {}'.format(self.__next_analysis))
def main(sysargv: List[str] = None) -> None:
"""
This function will initiate the bridge.
:return: None
"""
return_code: Any = 1
logger = setup_logger(name='{}.v{}'.format(__title__, __version__))
logger.info('Launching the bridge environment..\n' +
' __ _ __ ' + '\n' +
' / /_ _____(_)___/ /___ ____ ' + '\n' +
' / __ \/ ___/ / __ / __ `/ _ \\' + '\n' +
' / /_/ / / / / /_/ / /_/ / __/' + '\n' +
'/_.___/_/ /_/\__,_/\__, /\___/ ' + '\n' +
' /____/ ₀.₀.₁' + '\n')
bridge_config: BridgeConfig = None
bridge: BridgeIntegrator = None
bridge_config: BridgeConfig = parse_arguments(logger=logger,
sysargv=sysargv)
if bridge_config is not None:
bridge = BridgeIntegrator(config=bridge_config)
else:
logger.warning('WARNING: No bridge config set, exiting.')
return 0
try:
bridge.run()
except KeyboardInterrupt:
logger.info('SIGINT received, aborting ...')
return_code = 0
return return_code
def __init__(self,
config: Dict[str, Any] = {},
logger: logging.Logger = None,
verbose: bool = False):
"""
Initialize the CryptoCompare API object with a Config dict.
"""
if not logger:
self.logger = setup_logger(name=__name__)
else:
self.logger = logger
_api_key: str = config.get('apikey', None)
self.comparison_symbol = config.get('comparison_symbol', 'USD')
self.exchange = config.get('exchange', None)
self._verbose = verbose
if _api_key:
self._header = {
'Authorization': 'Apikey ' + _api_key,
}
elif s.CCAPI_KEY:
self._header = {
'Authorization': 'Apikey ' + s.CCAPI_KEY,
}
if self._verbose:
self.logger.info(
'Initializing CryptoCompareAPI module with key {}.'.format(
_api_key))
def __init__(self, name: str = None, socket_ip: str = None, socket_port: int = None) -> None:
"""
Init the api server, and init the super class RPC
"""
if name is None:
raise Exception("SocketServer needs distinguishable name for logging purposes")
self.name = '{}.{}'.format(__name__, name)
self.logger = setup_logger(name=self.name)
self.logger.info('Initializing %s component.', self.name)
self.app = Flask(__name__)
CORS(self.app)
self.app.config['SECRET_KEY'] = "s!"#$123%!%&!&e!"123424#34534$%!5345%&!&c345!"#234$%!1342334224%&!&et!242!"#$%342!%&!&"
self.socket = SocketIO(self.app)
if socket_ip is None:
self.logger.info("SocketServer got no `socket_ip` defaulting to {}".format(self._socket_ip))
else:
self._socket_ip = socket_ip
if socket_port is None:
self.logger.info("SocketServer got no `socket_port` defaulting to {}".format(self._socket_port))
else:
self._socket_port = socket_port
self._socket_base_url = '{}:{}'.format(self._socket_ip, self._socket_port)
self.logger.info("Will serve Socket at %s", self._socket_base_url)
def __init__(self, item: dict = None) -> None:
""" Initialize. """
self.logger = setup_logger(name=__name__)
self.read_queue = Queue()
if item is not None:
self.logger.info('Starting analysis of {} - {}'.format(
item.get('pair'), item.get('timeframe')))
self.run(item=item)
def __init__(self):
"""Initialize the wallet module."""
self.logger = setup_logger(name=__name__)
self.logger.info('Initializing %s module.', __name__)
self.wallet_balances = self._setup_wallet()
for item in self.wallet_balances:
currency = item.get('currency')
if currency and str(currency) == 'BTC':
self.logger.info('Initial wallet balance for %s: %.8g', currency, item.get('value'))
else:
self.logger.info('Initial wallet balance for %s: %d', currency, item.get('value'))
def __init__(self, name: str = None, module_name: str = None) -> None:
"""Initialize the playground's simulation integrator."""
if name is None:
raise Exception("Integrator class needs `name` param")
if module_name is None:
raise Exception("Integrator class needs `module_name` param")
self.name = '{}.{}'.format(__name__, name)
self.logger = setup_logger(name=self.name)
self.logger.info('Initializing %s component.', self.name)
self.module_name = module_name
def __init__(self, name: str = None):
"""
Simply initiate the BridgeConfig.
"""
if name is None:
raise Exception(
"Metrics class needs `name` param to designate itself")
self.name = '{}.{}'.format(__name__, name)
logger = setup_logger(name=self.name)
logger.info('Initializing %s component.', self.name)
# Set all metrics to 0
self.messages_read = 0
self.messages_delivered = 0
def __init__(self) -> None:
"""
Initialize the Warehouse object with the settings.
"""
self.logger = setup_logger(name=__name__)
self.logger.info('Initializing %s module.', __name__)
self.___read_lock = threading.RLock()
self.___update_lock = threading.RLock()
self._parse_settings()
self._parse_running_pairs()
self.missing_sets = self._check_missing_datasets()
if self.missing_sets:
self._build_missing_datasets()
self.outdated_sets = self._check_outdated_datasets()
if len(self.outdated_sets) == 0:
self.logger.info('Warehouse updated.')
self.set_updated()
else:
self.logger.info('Datasets outdated: {}'.format(
self.outdated_sets))
self.update_datasets()
if s.FORCE_STARTUP_ANALYSIS:
self.logger.info('Forcing startup analysis.')
self.analyse_datasets()
self.missing_analysed_sets = self._check_missing_datasets(
analysed=True)
if len(self.missing_analysed_sets) == 0:
self.logger.info('Warehouse analysed.')
self.set_analysed()
else:
self.logger.info('Datasets outdated: {}'.format(
self.outdated_sets))
self.analyse_datasets(datasets=self.missing_analysed_sets)
# Only analyse the ones we detected earlier for less startup time
self.set_ready()
def __init__(self,
on_message_func: Callable = None,
on_connected_func: Callable = None,
get_data_func: Callable = None,
name: str = None,
url: str = None,
timeout: int = None) -> None:
self.name = '{}.{}'.format(__name__, name)
self.logger = setup_logger(name=self.name)
self.logger.info('Initializing %s component.', self.name)
self.url = url
self.on_connected_func = on_connected_func
self.on_message_func = on_message_func
self.get_data_func = get_data_func
PeriodicCallback(self.keep_alive, 20000).start()
self.timeout = timeout
self.ioloop = IOLoop.instance()
self.ws = None
def main(sysargv: List[str] = None) -> None:
"""
This function will initiate the playground.
:return: None
"""
return_code: Any = 1
logger = setup_logger(name='{}.v{}'.format(__title__, __version__))
logger.info('Launching playground environment..\n' +
' __ __\n' +
' ____ / /___ ___ ______ __________ __ ______ ____/ /\n' +
' / __ \/ / __ `/ / / / __ `/ ___/ __ \/ / / / __ \/ __ / \n' +
' / /_/ / / /_/ / /_/ / /_/ / / / /_/ / /_/ / / / / /_/ / \n' +
' / .___/_/\__,_/\__, /\__, /_/ \____/\__,_/_/ /_/\__,_/ \n' +
'/_/ /____//____/ ₀.₁.₁ \n'
)
pg_config: PlaygroundConfig = None
pg: PlaygroundIntegrator = None
pg_config: PlaygroundConfig = parse_arguments(logger=logger, sysargv=sysargv)
if pg_config is not None:
pg = PlaygroundIntegrator(config=pg_config)
else:
logger.warning('WARNING: No playground config set, running with deprecated default settings.')
pg = PlaygroundIntegrator()
try:
pg.run()
except KeyboardInterrupt:
logger.info('SIGINT received, aborting ...')
return_code = 0
"""
for ft in worker.forwardtests:
if len(ft.data) != 0:
ft.print_results()
#ft.chart()
"""
# TODO: stuff related with livetrading
return return_code
def __init__(
self,
name: str = None,
market_pair: MarketPair = None,
timeframe: str = None,
desired_start: dt.datetime = None,
desired_finish: dt.datetime = None,
work_func: Callable = None,
throttle_func: Callable = None,
) -> None:
"""
Initialize the worker.
"""
if name is None:
raise Exception(
"Operation class needs `name` param to designate itself")
if market_pair is None:
raise Exception(
"Operation class needs `market_pair` param to work on")
if timeframe is None:
raise Exception(
"Operation class needs `timeframe` param to work on")
self.name = '{}.{}-{}-{}'.format(__name__, name, market_pair,
timeframe)
self.logger = setup_logger(name=self.name)
self.logger.info('Initializing %s operation.', self.name)
if desired_start is None:
raise Exception(
"Operation class needs `desired_start` param to work on")
if desired_finish is None:
raise Exception(
"Operation class needs `desired_finish` param to work on")
self.pair = market_pair
def __init__(self,
name: str = None,
work_func: Callable = None,
throttle_func: Callable = None,
daemon: bool = None) -> None:
"""
Initialize the worker.
"""
self.state = State.STARTING
if name is None:
raise Exception("Worker class needs `name` param")
self.name = '{}.{}'.format(__name__, name)
self.logger = setup_logger(name=self.name)
self.logger.info('Initializing %s component.', self.name)
if throttle_func is None:
self.logger.info(
'Worker class got no `throttle_func` param, worker will not sleep between work cycles.'
)
else:
self._throttlefunc = throttle_func
if work_func is None:
raise Exception("Worker class needs `work_func` param to work")
self._workfunc = work_func
self.logger.info('Worker is ready.')
self.state = State.READY
if daemon != None:
self._daemon = daemon
if self._daemon == True:
self.logger.info('Worker is starting as daemon.')
self.Start()
def __init__(self, config: BridgeConfig = None) -> None:
"""Initialize the bridge."""
self.name = '{}.{}-{}.{}'.format(__name__, config.name, config.mode,
__version__)
self.logger = setup_logger(name=self.name)
self.logger.info('Initializing %s component.', self.name)
if config is None:
raise Exception('Bridge needs param `config` to setup')
super().__init__(
name=self.name,
socket_ip=config.socket_ip,
socket_port=config.socket_port,
open_func=lambda: self.client_connected,
on_close_func=lambda: self.on_client_disconnected,
on_message_func=lambda: self.on_message_received,
check_origin_func=lambda: self.check_origin_headers,
url_func=lambda: Bridge.bridge_urls(),
)
self.flows = config.flows
self.metrics = BridgeMetrics()
def __init__(self, config: Dict = None) -> None:
"""Initialize the playground's simulation integrator."""
self.logger = setup_logger(name='{}.{}'.format(__title__, __name__))
self.logger.info("Creating the SimulationIntegrator...")
__title__ = "playground"
__author__ = "murlux"
__copyright__ = "Copyright 2019, " + __author__
__credits__ = (__author__, )
__license__ = "MIT"
__email__ = "*****@*****.**"
from typing import Dict, Any, Optional
from playground.util import setup_logger
logger = setup_logger(name=__name__)
class Stream:
"""
This class represents a Stream of data within the system
"""
# This is the name of the stream
module_name: str = None
name: str = None
extra: Dict[str, Any] = None
def __init__(self,
name: str = None,
module_name: str = None,
extra: Dict[str, Any] = None) -> None:
"""
Init from json
:param config: json dict of the class
def __init__(
self,
open_func: Callable = None,
on_close_func: Callable = None,
on_message_func: Callable = None,
check_origin_func: Callable = None,
url_func: Callable = None,
name: str = None,
stream: Stream = None,
socket_ip: str = None,
socket_port: int = None,
) -> None:
"""
Init the socket server and it's internals. Server provided by Tornado.
"""
if name is None:
raise Exception(
"WebSocketServer needs distinguishable name for logging purposes"
)
self.name = '{}.{}'.format(__name__, name)
self.logger = setup_logger(name=self.name)
self.logger.info('Initializing %s component.', self.name)
if stream is not None:
self.stream = stream
if open_func is None:
self.logger.error(
"WebSocketServer got no `open_func` defaulting to internal {}".
format(self.__open_func))
else:
self.open_func = open_func
if on_close_func is None:
self.logger.error(
"WebSocketServer got no `on_close_func` defaulting to internal {}"
.format(self.__on_close_func))
else:
self.on_close_func = on_close_func
if on_message_func is None:
self.logger.error(
"WebSocketServer got no `on_message_func` defaulting to internal {}"
.format(self.__on_message_func))
else:
self.on_message_func = on_message_func
if check_origin_func is None:
self.logger.error(
"WebSocketServer got no `check_origin_func` defaulting to internal {}"
.format(self.__check_origin_func))
else:
self.check_origin_func = check_origin_func
if url_func is None:
self.logger.error(
"WebSocketServer got no `url_func` defaulting to internal {}".
format(self.__url_func))
else:
self.url_func = url_func
if socket_ip is None:
self.logger.info(
"WebSocketServer got no `socket_ip` defaulting to {}".format(
self._socket_ip))
else:
self._socket_ip = socket_ip
if socket_port is None:
self.logger.info(
"WebSocketServer got no `socket_port` defaulting to {}".format(
self._socket_port))
else:
self._socket_port = socket_port
self._socket_base_url = '{}:{}'.format(self._socket_ip,
self._socket_port)
self.logger.info("Will serve WebSocket at %s", self._socket_base_url)
self.read_queue = Queue()
self.write_queue = Queue()
self.connections = set()
def __init__(
self,
data,
yesterday,
initial_capital,
pair,
tf,
logic,
):
"""Initate the ForwardTestSession.
:param data: An HLOCV+ pandas dataframe with a datetime index
:type data: pandas.DataFrame
:param yesterday: An HLOCV+ pandas dataframe with a datetime index
:type yesterday: pandas.DataFrame
:param initial_capital: Starting capital to fund account
:type initial_capital: float
:param pair: Operating market pair
:type pair: MarketPair obj
:param tf: Operating timeframe
:type tf: str
:param logic: A function that will be applied to each lookback period of the data
:type logic: function
:return: A forwardtesting simulation
:rtype: ForwardTestSession
"""
if not isinstance(data, pd.DataFrame):
raise ValueError("Data must be a pandas dataframe")
missing = set(['high', 'low', 'open', 'close', 'volume']) - set(
data.columns)
if len(missing) > 0:
msg = "Missing {0} column(s), dataframe must be HLOCV+".format(
list(missing))
warnings.warn(msg)
self.tracker = []
self.backdata = data.copy()
self.yesterday = yesterday
self.today = None
self.backdata = self.backdata.set_index('datetime').sort_index(
inplace=True, ascending=False)
self.account = Account(initial_capital=initial_capital,
pair=pair,
tf=tf)
self.logic = logic
self.pair = pair
self.tf = tf
self._simple_tts = '{} - {}\n\n'.format(
self.pair,
self.tf,
logic.__name__,
)
self._tts = __name__ + '\n\n{} - {}\n :: {}\n\n'.format(
self.pair,
self.tf,
logic.__name__,
)
self._name = __name__ + '. {} - {} :: {} :: {}'.format(
self.pair,
self.tf,
logic.__name__,
str(dt.now().date()),
).replace(' ', '')
self.logger = setup_logger(name=self._name)
# rd stands for relativedelta
rd_call: Callable = None
rd_args: dict = None
rd_call, rd_args = get_delta_callable_for_tf(tf=self.tf)
self.__verbosity = settings.FORWARDTESTING_VERBOSITY
self.__analysis_throttle = rd_call(**rd_args)
self.__next_candle = (dt.fromtimestamp(self.yesterday.time) +
self.__analysis_throttle)
self.__next_analysis = (self.__next_candle + self.__analysis_throttle)
self.__start_time = dt.now()
self.logger.info(
'Forwardtesting session started for: {}-{} using {} at {} '.format(
self.pair,
self.tf,
self.logic.__name__,
self.__start_time,
), )
self.logger.info('next analysis {}'.format(self.__next_analysis))
