mirror of
https://github.com/Ichinga-Samuel/aiomql.git
synced 2026-08-13 11:58:04 +00:00
v4
This commit is contained in:
Ichinga Samuel
+6
-77
@@ -2,66 +2,21 @@
|
||||
|
||||
## Table of Contents
|
||||
- [Account](#account.Account)
|
||||
- [\_\_init\_\_](#account.__init__)
|
||||
- [\_\_aenter\_\_](#account.__aenter__)
|
||||
- [\_\_aexit\_\_](#account.__aexit__)
|
||||
- [sign_in](#account.sign_in)
|
||||
- [refresh](#account.refresh)
|
||||
- [has_symbol](#account.has_symbol)
|
||||
- [symbols_get](#account.symbols_get)
|
||||
|
||||
<a id="Account"></a>
|
||||
|
||||
<a id="account.Account"></a>
|
||||
### Account
|
||||
```python
|
||||
class Account(AccountInfo)
|
||||
class Account(_Base, AccountInfo)
|
||||
```
|
||||
Singleton class for managing a trading account. A subclass of AccountInfo.
|
||||
All AccountInfo attributes are available in this class.
|
||||
A singleton class for managing a trading account. A subclass of _Base and AccountInfo. It supports asynchronous context
|
||||
management protocol.
|
||||
|
||||
#### Attributes
|
||||
| Name | Type | Description | Default |
|
||||
|-------------|-------------------|------------------------------------------------------|---------|
|
||||
| `connected` | `bool` | Status of connection to MetaTrader 5 Terminal | False |
|
||||
| `symbols` | `set[SymbolInfo]` | A set of available symbols for the financial market. | set() |
|
||||
|
||||
<a id="account.__init__"></a>
|
||||
#### \_\_init\_\_
|
||||
```python
|
||||
def __init__(self, *args, **kwargs)
|
||||
```
|
||||
Initializes the Account class. Inherits all attributes from the AccountInfo class.
|
||||
|
||||
<a id="account.__aenter__"></a>
|
||||
### __aenter__
|
||||
```python
|
||||
async def __aenter__() -> 'Account'
|
||||
```
|
||||
Async context manager for the Account class. Connects to a trading account and returns the account instance.
|
||||
#### Returns:
|
||||
| Type | Description |
|
||||
|-----------|----------------------------------|
|
||||
| `Account` | An instance of the Account class |
|
||||
#### Raises:
|
||||
| Exception | Description |
|
||||
|--------------|----------------|
|
||||
| `LoginError` | If login fails |
|
||||
|
||||
<a id="account.__aexit__"></a>
|
||||
### __aexit__
|
||||
```python
|
||||
async def __aexit__(exc_type, exc_value, traceback)
|
||||
```
|
||||
Async context manager for the Account class. Disconnects from the trading account.
|
||||
|
||||
<a id="account.sign_in"></a>
|
||||
### sign_in
|
||||
```python
|
||||
async def sign_in() -> bool
|
||||
```
|
||||
Connect to a trading account.
|
||||
#### Returns:
|
||||
| Type | Description |
|
||||
|--------|-----------------------------------------|
|
||||
| `bool` | True if login was successful else False |
|
||||
|
||||
<a id="account.refresh"></a>
|
||||
### refresh
|
||||
@@ -69,29 +24,3 @@ Connect to a trading account.
|
||||
async def refresh()
|
||||
```
|
||||
Refreshes the account instance with the latest data from the MetaTrader 5 terminal
|
||||
|
||||
<a id="account.has_symbol"></a>
|
||||
### has_symbol
|
||||
```python
|
||||
def has_symbol(symbol: str | Type[SymbolInfo])
|
||||
```
|
||||
Checks to see if a symbol is available for a trading account
|
||||
#### Parameters:
|
||||
| Name | Type | Description |
|
||||
|----------|---------------------|--------------------------------------|
|
||||
| `symbol` | `str`\|`SymbolInfo` | A symbol name or SymbolInfo instance |
|
||||
#### Returns:
|
||||
| Type | Description |
|
||||
|--------|----------------------------------------|
|
||||
| `bool` | True if symbol is available else False |
|
||||
|
||||
<a id="account.symbols_get"></a>
|
||||
### symbols_get
|
||||
```python
|
||||
async def symbols_get() -> set[SymbolInfo]
|
||||
```
|
||||
Get all financial instruments from the MetaTrader 5 terminal available for the current account.
|
||||
#### Returns:
|
||||
| Type | Description |
|
||||
|-------------------|-------------------------------|
|
||||
| `set[SymbolInfo]` | A set of SymbolInfo instances |
|
||||
|
||||
+153
@@ -0,0 +1,153 @@
|
||||
# Bot
|
||||
|
||||
## Table of Contents
|
||||
- [Bot](#bot.Bot)
|
||||
- [\_\_init\_\_](#bot.init)
|
||||
- [initialize](#bot.initialize)
|
||||
- [execute](#bot.execute)
|
||||
- [start](#bot.start)
|
||||
- [add_coroutine](#bot.add_coroutine)
|
||||
- [add_function](#bot.add_function)
|
||||
- [add_strategy](#bot.add_strategy)
|
||||
- [add_strategies](#bot.add_strategies)
|
||||
- [add_strategy_all](#bot.add_strategy_all)
|
||||
- [process_pool](#bot.run_bots)
|
||||
|
||||
<a id='bot.Bot'></a>
|
||||
### Bot
|
||||
```python
|
||||
class Bot
|
||||
```
|
||||
"""The bot class. Create a bot instance to run strategies.
|
||||
|
||||
#### Attributes.
|
||||
| Name | Type | Description | Default |
|
||||
|--------------|--------------------|--------------------------------------------|--------------|
|
||||
| `account` | `Account` | Account Object. | None |
|
||||
| `executor` | `Executor` | The executor. | None |
|
||||
| `strategies` | `List[Strategies]` | A list of strategies to initialize and run | list() |
|
||||
| `mt5` | `MetaTrader` | `A MetaTrader Instance` | MetaTrader() |
|
||||
| `config` | `Config` | A Config instance | Config() |
|
||||
|
||||
<a id='bot.init'></a>
|
||||
### \_\_init\_\_
|
||||
```python
|
||||
def __init__()
|
||||
```
|
||||
Initializes the Bot class.
|
||||
|
||||
<a id='bot.initialize'></a>
|
||||
### initialize
|
||||
```python
|
||||
async def initialize(self)
|
||||
```
|
||||
Prepares the bot by signing in to the trading account and initializing the symbols for each strategy.
|
||||
Only strategies with successfully initialized symbols will be added to the executor. Starts the global task queue.
|
||||
|
||||
Note: *initialize_sync* is a synchronous version of this method.
|
||||
|
||||
#### Raises:
|
||||
| Exception | Description |
|
||||
|--------------|-------------------------------|
|
||||
| `SystemExit` | If sign in was not successful |
|
||||
|
||||
|
||||
|
||||
<a id='bot.execute'></a>
|
||||
### execute
|
||||
```python
|
||||
def execute()
|
||||
```
|
||||
Executes the bot. Use this method to run the bot in a synchronous manner.
|
||||
This method is blocking and will not return until the bot is done running.
|
||||
|
||||
<a id='bot.start'></a>
|
||||
### start
|
||||
```python
|
||||
async def start()
|
||||
```
|
||||
Initialize the bot and execute it. Similar to calling **execute** method but is asynchronous.
|
||||
|
||||
<a id='bot.add_coroutine'></a>
|
||||
### add_coroutine
|
||||
```python
|
||||
def add_coroutine(self, coroutine: Coroutine, on_separate_thread=False, **kwargs)
|
||||
```
|
||||
Add a coroutine to the executor. By default, all coroutines added to the executor run on this same thread,
|
||||
using _asyncio.gather_, but if _on_separate_thread_ is true then the coroutine is given it's own thread.
|
||||
|
||||
#### Parameters:
|
||||
| Name | Type | Description |
|
||||
|----------------------|-------------|----------------------------------------------------|
|
||||
| `coroutine` | `Coroutine` | A coroutine to run in the executor |
|
||||
| `on_separate_thread` | `bool` | Run coroutine on a separate thread in the executor |
|
||||
| `kwargs` | `Any` | Keyword arguments to pass to the coroutine |
|
||||
|
||||
<a id='bot.add_function'></a>
|
||||
### add_function
|
||||
```python
|
||||
def add_function(self, function: Callable, **kwargs)
|
||||
```
|
||||
Add a function to the executor.
|
||||
#### Parameters:
|
||||
| Name | Type | Description |
|
||||
|------------|------------|-------------------------------------------|
|
||||
| `function` | `Callable` | A function to run in the executor |
|
||||
| `kwargs` | `Any` | Keyword arguments to pass to the function |
|
||||
|
||||
<a id='bot.add_strategy'></a>
|
||||
### add_strategy
|
||||
```python
|
||||
def add_strategy(self, strategy: Strategy)
|
||||
```
|
||||
Add a strategy to the list of strategies.
|
||||
|
||||
#### Parameters:
|
||||
| Name | Type | Description |
|
||||
|------------|------------|-----------------------------------|
|
||||
| `strategy` | `Strategy` | A Strategy instance to run on bot |
|
||||
|
||||
<a id='bot.add_strategies'></a>
|
||||
### add_strategies
|
||||
```python
|
||||
def add_strategies(strategies: Iterable[Strategy])
|
||||
```
|
||||
Add multiple strategies at the same time
|
||||
#### Parameters:
|
||||
| Name | Type | Description |
|
||||
|--------------|----------------------|-----------------------------------|
|
||||
| `strategies` | `Iterable[Strategy]` | An iterable of Strategy instances |
|
||||
|
||||
<a id='bot.add_strategy_all'></a>
|
||||
### add_strategy_all
|
||||
```python
|
||||
def add_strategy_all(*, strategy: Type[Strategy], params: dict | None = None, symbols: list[Symbol] = None, **kwargs)
|
||||
```
|
||||
Use this to run a single strategy on multiple symbols with the same parameters and keyword arguments.
|
||||
#### Parameters:
|
||||
| Name | Type | Description |
|
||||
|------------|------------------|---------------------------------------------|
|
||||
| `strategy` | `Type[Strategy]` | A Strategy class |
|
||||
| `params` | `dict` or `None` | A dictionary of parameters for the strategy |
|
||||
| `symbols` | `list[Symbol]` | A list of symbols to run the strategy on |
|
||||
| `**kwargs` | `Any` | Keyword arguments |
|
||||
|
||||
|
||||
<a id='bot.process_pool'></a>
|
||||
```python
|
||||
@classmethod
|
||||
def process_pool(cls, bots: dict[Callable: dict] = None, num_workers: int = None):
|
||||
```
|
||||
Run multiple functions (scripts, bots) at the same time in parallel with different accounts.
|
||||
Running multiple functions is useful when you want to run different strategies on different accounts.
|
||||
The callable can for example be a bot instance that defines its own Config instance within the function scope.
|
||||
The dictionary should contain the callable as the key and the dictionary of keyword arguments to pass to the callable as
|
||||
the value. Use the path attribute of the config instance to specify the terminal path of each account.
|
||||
The num_workers parameter specifies the number of workers to use. If not specified, the number of workers will be the
|
||||
number of bots.
|
||||
|
||||
#### Parameters
|
||||
| Name | Type | Description |
|
||||
|--------------|------------------------|---------------------------------------------------------------------------------|
|
||||
| `bots` | `dict[Callable: dict]` | A dictionary of callables and their keyword arguments to run as bots |
|
||||
| `num_workers` | `int` | The number of workers to use. If not specified, the number of bots will be used |
|
||||
@@ -1,162 +0,0 @@
|
||||
# Bot
|
||||
|
||||
## Table of Contents
|
||||
- [Bot](#bb.Bot)
|
||||
- [\_\_init\_\_](#bb.__init__)
|
||||
- [initialize](#bb.initialize)
|
||||
- [execute](#bb.execute)
|
||||
- [start](#bb.start)
|
||||
- [add_coroutine](#bb.add_coroutine)
|
||||
- [add_function](#bb.add_function)
|
||||
- [add_strategy](#bb.add_strategy)
|
||||
- [add_strategies](#bb.add_strategies)
|
||||
- [add_strategy_all](#bb.add_strategy_all)
|
||||
- [init_symbols](#bb.init_symbols)
|
||||
- [init_symbol](#bb.init_symbol]())
|
||||
- [run_bots](#bb.run_bots)
|
||||
|
||||
<a id='bb.Bot'></a>
|
||||
### Bot
|
||||
```python
|
||||
class Bot
|
||||
```
|
||||
The bot class. Create a bot instance to run your strategies.
|
||||
#### Attributes:
|
||||
| Name | Type | Description | Default |
|
||||
|------------|----------------------|------------------------------------------|----------|
|
||||
| `account` | `Account` | Account Object. | None |
|
||||
| `executor` | `ThreadPoolExecutor` | The default thread executor. | None |
|
||||
| `symbols` | `set[Symbols]` | A set of symbols for the trading session | set() |
|
||||
| `config` | `Config` | A Config instance | Config() |
|
||||
|
||||
<a id='bb.__init__'></a>
|
||||
### \_\_init\_\_
|
||||
```python
|
||||
def __init__()
|
||||
```
|
||||
Initializes the Bot class.
|
||||
|
||||
<a id='bb.initialize'></a>
|
||||
### initialize
|
||||
```python
|
||||
async def initialize()
|
||||
```
|
||||
Prepares the bot by signing in to the trading account and initializing the symbols for the trading session.
|
||||
#### Raises:
|
||||
| Exception | Description |
|
||||
|--------------|-------------------------------|
|
||||
| `SystemExit` | If sign in was not successful |
|
||||
|
||||
<a id='bb.execute'></a>
|
||||
### execute
|
||||
```python
|
||||
def execute()
|
||||
```
|
||||
Execute the bot. Use this method to run the bot.
|
||||
|
||||
<a id='bb.start'></a>
|
||||
### start
|
||||
```python
|
||||
async def start()
|
||||
```
|
||||
Initialize the bot and execute it. Similar to calling **execute** method but is asynchronous.
|
||||
|
||||
<a id='bb.add_coroutine'></a>
|
||||
### add_coroutine
|
||||
```python
|
||||
def add_coroutine(coro: Coroutine, **kwargs)
|
||||
```
|
||||
Add a coroutine to the executor.
|
||||
#### Parameters:
|
||||
| Name | Type | Description |
|
||||
|----------|-------------|--------------------------------------------|
|
||||
| `coro` | `Coroutine` | A coroutine to run in the executor |
|
||||
| `kwargs` | `Any` | Keyword arguments to pass to the coroutine |
|
||||
|
||||
<a id='bb.add_function'></a>
|
||||
### add_function
|
||||
```python
|
||||
def add_function(func: Callable, **kwargs)
|
||||
```
|
||||
Add a function to the executor.
|
||||
#### Parameters:
|
||||
| Name | Type | Description |
|
||||
|----------|------------|-------------------------------------------|
|
||||
| `func` | `Callable` | A function to run in the executor |
|
||||
| `kwargs` | `Any` | Keyword arguments to pass to the function |
|
||||
|
||||
<a id='bb.add_strategy'></a>
|
||||
### add_strategy
|
||||
```python
|
||||
def add_strategy(strategy: Strategy)
|
||||
```
|
||||
Add a strategy to the executor. An added strategy will only run if it's symbol was successfully initialized.
|
||||
#### Parameters:
|
||||
| Name | Type | Description |
|
||||
|------------|------------|-----------------------------------|
|
||||
| `strategy` | `Strategy` | A Strategy instance to run on bot |
|
||||
|
||||
<a id='bb.add_strategies'></a>
|
||||
### add_strategies
|
||||
```python
|
||||
def add_strategies(strategies: Iterable[Strategy])
|
||||
```
|
||||
Add multiple strategies at the same time
|
||||
#### Parameters:
|
||||
| Name | Type | Description |
|
||||
|--------------|----------------------|-----------------------------------|
|
||||
| `strategies` | `Iterable[Strategy]` | An iterable of Strategy instances |
|
||||
|
||||
<a id='bb.add_strategy_all'></a>
|
||||
### add_strategy_all
|
||||
```python
|
||||
def add_strategy_all(*, strategy: Type[Strategy], params: dict | None = None)
|
||||
```
|
||||
Use this to run a single strategy on all available instruments in the market using the default parameters
|
||||
i.e. one set of parameters for all trading symbols
|
||||
#### Parameters:
|
||||
| Name | Type | Description |
|
||||
|------------|------------------|---------------------------------------------|
|
||||
| `strategy` | `Type[Strategy]` | A Strategy class |
|
||||
| `params` | `dict` or `None` | A dictionary of parameters for the strategy |
|
||||
|
||||
<a id='bb.init_symbols'></a>
|
||||
### init_symbols
|
||||
```python
|
||||
async def init_symbols()
|
||||
```
|
||||
Initialize the symbols for the current trading session. This method is called internally by the bot.
|
||||
|
||||
<a id='bb.init_symbol'></a>
|
||||
### init_symbol
|
||||
```python
|
||||
async def init_symbol(symbol: Symbol) -> Symbol
|
||||
```
|
||||
Initialize a symbol before the beginning of a trading session.
|
||||
Removes it from the list of symbols if it was not successfully initialized or not available for the account.
|
||||
#### Parameters:
|
||||
| Name | Type | Description |
|
||||
|----------|----------|-------------------|
|
||||
| `symbol` | `Symbol` | A Symbol instance |
|
||||
#### Returns:
|
||||
| Type | Description |
|
||||
|----------|-------------------|
|
||||
| `Symbol` | A Symbol instance |
|
||||
|
||||
<a id='bb.run_bots'></a>
|
||||
```python
|
||||
@classmethod
|
||||
def run_bots(cls, funcs: dict[Callable: dict] = None, num_workers: int = None):
|
||||
```
|
||||
Run multiple functions (scripts, bots) at the same time in parallel with different accounts.
|
||||
Running multiple functions is useful when you want to run different strategies on different accounts.
|
||||
The callable can for example be a bot instance that defines its own Config instance within the function scope.
|
||||
The dictionary should contain the callable as the key and the dictionary of keyword arguments to pass to the callable as
|
||||
the value. Use the path attribute of the config instance to specify the terminal path of each account.
|
||||
The num_workers parameter specifies the number of workers to use. If not specified, the number of workers will be the
|
||||
number of bots.
|
||||
#### Parameters
|
||||
| Name | Type | Description |
|
||||
|---------------|------------------------|---------------------------------------------------------------------------------|
|
||||
| `funcs` | `dict[Callable: dict]` | A dictionary of callables and their keyword arguments to run as bots |
|
||||
| `num_workers` | `int` | The number of workers to use. If not specified, the number of bots will be used |
|
||||
Reference in New Issue
Block a user