https://github.com/themoor9/jarviis-beta-refactored-eureka
JARVIIS is a professional app for Intelligent Capital Management. This beta version is publicly available to be reviewed. (All strategy implementations has been removed)
https://github.com/themoor9/jarviis-beta-refactored-eureka
Last synced: 3 months ago
JSON representation
JARVIIS is a professional app for Intelligent Capital Management. This beta version is publicly available to be reviewed. (All strategy implementations has been removed)
- Host: GitHub
- URL: https://github.com/themoor9/jarviis-beta-refactored-eureka
- Owner: theMoor9
- License: apache-2.0
- Created: 2024-07-03T10:54:07.000Z (11 months ago)
- Default Branch: main
- Last Pushed: 2024-07-16T13:16:51.000Z (11 months ago)
- Last Synced: 2025-01-26T06:27:13.092Z (4 months ago)
- Language: Python
- Homepage:
- Size: 159 KB
- Stars: 1
- Watchers: 1
- Forks: 0
- Open Issues: 0
-
Metadata Files:
- Readme: README.md
- License: LICENSE
Awesome Lists containing this project
README
___ ___ _____ __ __ ____ ____ ____
|_ _| / _ \ | _ \| | | ||_ _||_ _| / *_\
| | | |_| || |_| | \ \ / / | | | | \ \
_| | | _ || _ / \ / | | | | _\ \
|___| |_| |_||_| \_\ \_/ |____||____|\_____/ Δ
# Tools:
- **Jarviis**:
- ADX
- RSI
- Bollinger Bands
- SMA
- MACD
- **Dipso**:
- Funzione di supporto ai fini del controllo delle logiche di trading
- **Garu**:
- Funzione di supporto ai fini tecnici di programmazione
# Functions:
La meccanica di lucro usa l'interesse composto tramite il seguente funzionamento:
- `JarviisReactor.update_market_data.SMA_cross()`
- `JarviisReactor.update_market_data.BollingerBands()`
Utilizza l'incrocio delle SMA per definire la struttura principale di trading, supportata dalle bande di Bollinger in maniera restrittiva, mirata ad ottemprare alle lacune di schematicità degli incroci in contrapposizione alla fluidità di mercato.
- `logic_config['params_buy/sell']`
Inoltre, dopo la prima attivazione trascorso un periodo di circa 3 mesi di consolidazione capitale, si attiva la meccanica di Leverage con moltiplicatore relativo alle disponibilità di Kraken (BTC/USDT x3).
- `JarviisReactor.update_market_data.MACD()`
Essa è regolamentata tramite il supporto del MACD che indica i periodi di rialzo e di ribasso, permettendo l'attivazione del Leverage in maniera esclusiva nei momenti di rialzo per cogliere con più determinazione il flusso di mercato.
- `configs['trend_flow']`
E' presente in aggiunta una logica (inattiva) che inverte le aperture delle posizioni:
- Aperture short e conseguenti chiusure durante i periodi bearish
- Aperture long e conseguenti chiusure durante i periodi bullish
# Concurrency/Parallelism:
Se si vuole applicare l'assistente su altri symbols occorre creare un account dedito al singolo asset.
# Security:
E' presente la crittazione delle variabili apikey e di sessione con salt.
# Architecture:
Microservices API system
# Progetti futuri:
- Ampliazione strategia - Performance profitability system
- Refactoring SOLID
- Refactoring RUST
# STRUTTURA DESCRITTIVA:
## LIBRERIE:
- numpy
- ccxt
- time
- threading
- os
- logging
- pickle
- progress.spinner
- traceback
- keyboard
- sys
- subprocess
- shutil
- pandas
- prompt_toolkit
- cryptography.hazmat.backends
- cryptography.hazmat.primitives
- cryptography.hazmat.primitives.kdf.pbkdf2
- base64
- cryptography.fernet
- getpass
- json
- zipfile
- datetime
---
```python
class SetupManager:
def __init__(self, symbols, symbol_key, api_config):
# Chiama self.setup_directories()
# Chiama self.setup_loggers()
# Chiama self.setup_pickle_files()
# Chiama self.api_config_setup()
def clear_screen_self_method(self):
def setup_directories(self):
def setup_loggers(self):
def setup_pickle_files(self):
def api_config_setup(self):
# Chiama self.clear_screen_self_method()
def derive_key(self, pin, salt=None):
def encrypt_api_keys(self, pin):
# Chiama self.derive_key()
def decrypt_api_keys(self, pin, limit_attempts=0):
# Chiama self.clear_screen_self_method()
# Chiama self.derive_key()
# Chiama self.api_config_setup()
def log_cleaner(self):
@staticmethod
def cache_cleaner():
class ThreadManager:
def __init__(self, main_class, su_class, symbols, symbol_key):
# Crea il thread con self.throttler()
# Crea il thread con self.listen_for_commands()
# Crea il thread con jarviisReactor.core()
def reset_screen_self_method(self):
def clear_screen_self_method(self):
def throttler(self):
# Chiama self.clear_screen_self_method()
# Chiama self.spark()
def spark(self):
Chiama self.reset_screen_self_method()
def listen_for_commands(self):
Chiama self.clear_screen_self_method()
# Chiama self.reset_screen_self_method()
# Chiama self.hitman()
# Chiama jarviisReactor.dataframe_handler()
def hitman(self):
@staticmethod
def reset_screen():
class JarviisReactor:
# Classe che si occupa delle esecuzioni delle task atte allo svolgimento delle operazioni generali
class TaskManager:
def __init__(self, parent, api_config, symbols, symbol_key, logic_config):
def connection_handler(self):
# Funzione esecuzione capillare delle operazioni
def alchemist(self, code, general1='', general2='', general3='', general4='', general5=''):
# Chiama self.connection_handler()
def initiate_shutdown(self):
# Classe che si occupa della logica delle transazioni
class Transactions:
def __init__(self, taskManager, closures, initconfig, symbolSel1, symbolSel2, couple, MACDtrend):
def buy(self, op_size, multiplier, call):
# Chiama self.taskManager.alchemist(code='KRA300')
# Chiama self.taskManager.alchemist(code='KRA420')
def sell(self, op_size, multiplier, call):
# Chiama self.taskManager.alchemist(code='KRA300')
# Chiama self.taskManager.alchemist(code='KRA420')
def __init__(self, symbols, symbol_key, api_config, indicator_config, logic_config, configs, data_dir):
# Chiama self.update_market_data(self.chart, 1)
# Chiama self.update_market_data(self.support_chart, 2)
# Chiama self.setup_trading_environment()
# Inizializza la classe self.TaskManager
# Inizializza la classe self.Transactions
def setup_trading_environment(self):
# Definisce e chiama df_init(): # Inizializza il DF
# Chiama self.connection_handler()
# Chiama self.alchemist('KRA120')
# Chiama self.alchemist('KRA210')
# Chiama self.alchemist('KRA220')
# Definisce e chiama memory_handler(): # Inizializza le variabili salvate in memoria
# Chiama self.connection_handler()
# Aggiorna i dati di mercato e riceve il dataframe e la tipologia di timeframe
def update_market_data(self, dataframe, timeframe_call):
# Definisce e chiama SMA_cross()
# Definisce e chiama BollingerBands(tf_call)
# Definisce e chiama ADX(tf_call)
# Definisce e chiama RSI(tf_call)
# Definisce e chiama MACD()
# Definisce e chiama minmax()
# Crea un file CSV con i dati del dataframe
def dataframe_handler(self):
# Contiene la logica di trading principale e riceve oggetto classe Transactions
def execute_trading_logic(self, transactionElements):
# Definisce e chiama main_trade_activity(transactionElements)
# Chiama self.taskManager.alchemist(code='KRA410')
# Chiama self.taskManager.alchemist(code='KRA400')
# Chiama self.taskManager.alchemist(code='KRA210')
# Chiama transactionElements.buy()
# Chiama transactionElements.sell()
# Ciclo principale del programma
def core(self):
# Chiama self.taskManager.connection_handler()
# Chiama self.taskManager.alchemist('KRA220')
# Chiama self.update_market_data(self.chart, 1)
# Chiama self.update_market_data(self.support_chart, 2)
# Chiama self.execute_trading_logic(self.transactionElements)
# Main
def main(symbols_config, api_config):
# Chiama setupManager.cache_cleaner()
# Chiama threadManager.reset_screen()
# Chiamata alla funzione principale
if __name__ == "__main__":
main(symbols_config, api_config)
```
# Author
Kenneth Boldrini
# License
This repository is licensed. See the [LICENSE](./LICENSE) file for more details.