bast/MetaTrader5-Docker-Image
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions
MetaTrader5-Docker-Image/config.old-32bit/.local/lib/python3.11/site-packages/mt5linux/__init__.py
bast c5c0d42eac
All checks were successful
MT5 Helm GitOps Deploy / build-and-deploy (push) Has been skipped
Details
using broker mt5
2026-11-06 01:29:29 +01:00

4002 lines
No EOL
144 KiB
Python
Raw Blame History

This file contains ambiguous Unicode characters

This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

import rpyc
from numpy import array
import datetime
class MetaTrader5(object):
''' MetaTrader5'''
# Constants
ACCOUNT_MARGIN_MODE_RETAIL_NETTING = 0
ACCOUNT_MARGIN_MODE_EXCHANGE = 1
ACCOUNT_MARGIN_MODE_RETAIL_HEDGING = 2
ACCOUNT_STOPOUT_MODE_PERCENT = 0
ACCOUNT_STOPOUT_MODE_MONEY = 1
ACCOUNT_TRADE_MODE_DEMO = 0
ACCOUNT_TRADE_MODE_CONTEST = 1
ACCOUNT_TRADE_MODE_REAL = 2
COPY_TICKS_ALL = -1
COPY_TICKS_INFO = 1
COPY_TICKS_TRADE = 2
DAY_OF_WEEK_SUNDAY = 0
DAY_OF_WEEK_MONDAY = 1
DAY_OF_WEEK_TUESDAY = 2
DAY_OF_WEEK_WEDNESDAY = 3
DAY_OF_WEEK_THURSDAY = 4
DAY_OF_WEEK_FRIDAY = 5
DAY_OF_WEEK_SATURDAY = 6
DEAL_DIVIDEND = 15
DEAL_DIVIDEND_FRANKED = 16
DEAL_ENTRY_IN = 0
DEAL_ENTRY_OUT = 1
DEAL_ENTRY_INOUT = 2
DEAL_ENTRY_OUT_BY = 3
DEAL_REASON_CLIENT = 0
DEAL_REASON_MOBILE = 1
DEAL_REASON_WEB = 2
DEAL_REASON_EXPERT = 3
DEAL_REASON_SL = 4
DEAL_REASON_TP = 5
DEAL_REASON_SO = 6
DEAL_REASON_ROLLOVER = 7
DEAL_REASON_VMARGIN = 8
DEAL_REASON_SPLIT = 9
DEAL_TAX = 17
DEAL_TYPE_BUY = 0
DEAL_TYPE_SELL = 1
DEAL_TYPE_BALANCE = 2
DEAL_TYPE_CREDIT = 3
DEAL_TYPE_CHARGE = 4
DEAL_TYPE_CORRECTION = 5
DEAL_TYPE_BONUS = 6
DEAL_TYPE_COMMISSION = 7
DEAL_TYPE_COMMISSION_DAILY = 8
DEAL_TYPE_COMMISSION_MONTHLY = 9
DEAL_TYPE_COMMISSION_AGENT_DAILY = 10
DEAL_TYPE_COMMISSION_AGENT_MONTHLY = 11
DEAL_TYPE_INTEREST = 12
DEAL_TYPE_BUY_CANCELED = 13
DEAL_TYPE_SELL_CANCELED = 14
ORDER_REASON_CLIENT = 0
ORDER_REASON_MOBILE = 1
ORDER_REASON_WEB = 2
ORDER_REASON_EXPERT = 3
ORDER_REASON_SL = 4
ORDER_REASON_TP = 5
ORDER_REASON_SO = 6
ORDER_STATE_STARTED = 0
ORDER_STATE_PLACED = 1
ORDER_STATE_CANCELED = 2
ORDER_STATE_PARTIAL = 3
ORDER_STATE_FILLED = 4
ORDER_STATE_REJECTED = 5
ORDER_STATE_EXPIRED = 6
ORDER_STATE_REQUEST_ADD = 7
ORDER_STATE_REQUEST_MODIFY = 8
ORDER_STATE_REQUEST_CANCEL = 9
POSITION_REASON_CLIENT = 0
POSITION_REASON_MOBILE = 1
POSITION_REASON_WEB = 2
POSITION_REASON_EXPERT = 3
POSITION_TYPE_BUY = 0
POSITION_TYPE_SELL = 1
RES_E_INTERNAL_FAIL_TIMEOUT = -10005
RES_E_INTERNAL_FAIL_CONNECT = -10004
RES_E_INTERNAL_FAIL_INIT = -10003
RES_E_INTERNAL_FAIL_RECEIVE = -10002
RES_E_INTERNAL_FAIL_SEND = -10001
RES_E_INTERNAL_FAIL = -10000
RES_E_AUTO_TRADING_DISABLED = -8
RES_E_UNSUPPORTED = -7
RES_E_AUTH_FAILED = -6
RES_E_INVALID_VERSION = -5
RES_E_NOT_FOUND = -4
RES_E_NO_MEMORY = -3
RES_E_FAIL = -1
RES_E_INVALID_PARAMS = -2
RES_S_OK = 1
SYMBOL_CALC_MODE_FOREX = 0
SYMBOL_CALC_MODE_FUTURES = 1
SYMBOL_CALC_MODE_CFD = 2
SYMBOL_CALC_MODE_CFDINDEX = 3
SYMBOL_CALC_MODE_CFDLEVERAGE = 4
SYMBOL_CALC_MODE_FOREX_NO_LEVERAGE = 5
SYMBOL_CALC_MODE_EXCH_STOCKS = 32
SYMBOL_CALC_MODE_EXCH_FUTURES = 33
SYMBOL_CALC_MODE_EXCH_OPTIONS = 34
SYMBOL_CALC_MODE_EXCH_OPTIONS_MARGIN = 36
SYMBOL_CALC_MODE_EXCH_BONDS = 37
SYMBOL_CALC_MODE_EXCH_STOCKS_MOEX = 38
SYMBOL_CALC_MODE_EXCH_BONDS_MOEX = 39
SYMBOL_CALC_MODE_SERV_COLLATERAL = 64
SYMBOL_CHART_MODE_BID = 0
SYMBOL_CHART_MODE_LAST = 1
SYMBOL_OPTION_MODE_EUROPEAN = 0
SYMBOL_OPTION_MODE_AMERICAN = 1
SYMBOL_OPTION_RIGHT_CALL = 0
SYMBOL_OPTION_RIGHT_PUT = 1
SYMBOL_ORDERS_GTC = 0
SYMBOL_ORDERS_DAILY = 1
SYMBOL_ORDERS_DAILY_NO_STOPS = 2
SYMBOL_SWAP_MODE_DISABLED = 0
SYMBOL_SWAP_MODE_POINTS = 1
SYMBOL_SWAP_MODE_CURRENCY_SYMBOL = 2
SYMBOL_SWAP_MODE_CURRENCY_MARGIN = 3
SYMBOL_SWAP_MODE_CURRENCY_DEPOSIT = 4
SYMBOL_SWAP_MODE_INTEREST_CURRENT = 5
SYMBOL_SWAP_MODE_INTEREST_OPEN = 6
SYMBOL_SWAP_MODE_REOPEN_CURRENT = 7
SYMBOL_SWAP_MODE_REOPEN_BID = 8
SYMBOL_TRADE_EXECUTION_REQUEST = 0
SYMBOL_TRADE_EXECUTION_INSTANT = 1
SYMBOL_TRADE_EXECUTION_MARKET = 2
SYMBOL_TRADE_EXECUTION_EXCHANGE = 3
SYMBOL_TRADE_MODE_DISABLED = 0
SYMBOL_TRADE_MODE_LONGONLY = 1
SYMBOL_TRADE_MODE_SHORTONLY = 2
SYMBOL_TRADE_MODE_CLOSEONLY = 3
SYMBOL_TRADE_MODE_FULL = 4
TICK_FLAG_BID = 2
TICK_FLAG_ASK = 4
TICK_FLAG_LAST = 8
TICK_FLAG_VOLUME = 16
TICK_FLAG_BUY = 32
TICK_FLAG_SELL = 64
# TIMEFRAME
# 1 minute
TIMEFRAME_M1 = 1
# 2 minutes
TIMEFRAME_M2 = 2
# 3 minutes
TIMEFRAME_M3 = 3
# 4 minutes
TIMEFRAME_M4 = 4
# 5 minutes
TIMEFRAME_M5 = 5
# 6 minutes
TIMEFRAME_M6 = 6
# 10 minutes
TIMEFRAME_M10 = 10
# 12 minutes
TIMEFRAME_M12 = 12
# 15 minutes
TIMEFRAME_M15 = 15
# 20 minutes
TIMEFRAME_M20 = 20
# 30 minutes
TIMEFRAME_M30 = 30
# 1 hour
TIMEFRAME_H1 = 16385
# 2 hours
TIMEFRAME_H2 = 16386
# 3 hours
TIMEFRAME_H3 = 16387
# 4 hours
TIMEFRAME_H4 = 16388
# 6 hours
TIMEFRAME_H6 = 16390
# 8 hours
TIMEFRAME_H8 = 16392
# 12 hours
TIMEFRAME_H12 = 16396
# 1 day
TIMEFRAME_D1 = 16408
# 1 week
TIMEFRAME_W1 = 32769
# 1 month
TIMEFRAME_MN1 = 49153
# Requote
TRADE_RETCODE_REQUOTE = 10004
# Request rejected
TRADE_RETCODE_REJECT = 10006
# Request canceled by trader
TRADE_RETCODE_CANCEL = 10007
# Order placed
TRADE_RETCODE_PLACED = 10008
# Request completed
TRADE_RETCODE_DONE = 10009
# Only part of the request was completed
TRADE_RETCODE_DONE_PARTIAL = 10010
# Request processing error
TRADE_RETCODE_ERROR = 10011
# Request canceled by timeout
TRADE_RETCODE_TIMEOUT = 10012
# Invalid request
TRADE_RETCODE_INVALID = 10013
# Invalid volume in the request
TRADE_RETCODE_INVALID_VOLUME = 10014
# Invalid price in the request
TRADE_RETCODE_INVALID_PRICE = 10015
# Invalid stops in the request
TRADE_RETCODE_INVALID_STOPS = 10016
# Trade is disabled
TRADE_RETCODE_TRADE_DISABLED = 10017
# Market is closed
TRADE_RETCODE_MARKET_CLOSED = 10018
# There is not enough money to complete the request
TRADE_RETCODE_NO_MONEY = 10019
# Prices changed
TRADE_RETCODE_PRICE_CHANGED = 10020
# There are no quotes to process the request
TRADE_RETCODE_PRICE_OFF = 10021
# Invalid order expiration date in the request
TRADE_RETCODE_INVALID_EXPIRATION = 10022
# Order state changed
TRADE_RETCODE_ORDER_CHANGED = 10023
# Too frequent requests
TRADE_RETCODE_TOO_MANY_REQUESTS = 10024
# No changes in request
TRADE_RETCODE_NO_CHANGES = 10025
# Autotrading disabled by server
TRADE_RETCODE_SERVER_DISABLES_AT = 10026
# Autotrading disabled by client terminal
TRADE_RETCODE_CLIENT_DISABLES_AT = 10027
# Request locked for processing
TRADE_RETCODE_LOCKED = 10028
# Order or position frozen
TRADE_RETCODE_FROZEN = 10029
# Invalid order filling type
TRADE_RETCODE_INVALID_FILL = 10030
# No connection with the trade server
TRADE_RETCODE_CONNECTION = 10031
# Operation is allowed only for live accounts
TRADE_RETCODE_ONLY_REAL = 10032
# The number of pending orders has reached the limit
TRADE_RETCODE_LIMIT_ORDERS = 10033
# The volume of orders and positions for the symbol has reached the limit
TRADE_RETCODE_LIMIT_VOLUME = 10034
# Incorrect or prohibited order type
TRADE_RETCODE_INVALID_ORDER = 10035
# Position with the specified POSITION_IDENTIFIER has already been closed
TRADE_RETCODE_POSITION_CLOSED = 10036
# A close volume exceeds the current position volume
TRADE_RETCODE_INVALID_CLOSE_VOLUME = 10038
# A close order already exists for a specified position. This may happen when working in the hedging system:
# i) when attempting to close a position with an opposite one, while close orders for the position already exist;
# ii) when attempting to fully or partially close a position if the total volume of the already present close orders and the newly placed one exceeds the current position volume;
TRADE_RETCODE_CLOSE_ORDER_EXIST = 10039
# The number of open positions simultaneously present on an account can be limited by the server settings. After a limit is reached, the server returns the TRADE_RETCODE_LIMIT_POSITIONS error when attempting to place an order. The limitation operates differently depending on the position accounting type:
# Netting — number of open positions is considered. When a limit is reached, the platform does not let placing new orders whose execution may increase the number of open positions. In fact, the platform allows placing orders only for the symbols that already have open positions. The current pending orders are not considered since their execution may lead to changes in the current positions but it cannot increase their number.
# Hedging — pending orders are considered together with open positions, since a pending order activation always leads to opening a new position. When a limit is reached, the platform does not allow placing both new market orders for opening positions and pending orders.
TRADE_RETCODE_LIMIT_POSITIONS = 10040
# The pending order activation request is rejected, the order is canceled
TRADE_RETCODE_REJECT_CANCEL = 10041
# The request is rejected, because the "Only long positions are allowed" rule is set for the symbol (POSITION_TYPE_BUY)
TRADE_RETCODE_LONG_ONLY = 10042
# The request is rejected, because the "Only short positions are allowed" rule is set for the symbol (POSITION_TYPE_SELL)
TRADE_RETCODE_SHORT_ONLY = 10043
# The request is rejected, because the "Only position closing is allowed" rule is set for the symbol
TRADE_RETCODE_CLOSE_ONLY = 10044
# The request is rejected, because "Position closing is allowed only by FIFO rule" flag is set for the trading account (ACCOUNT_FIFO_CLOSE=true)
TRADE_RETCODE_FIFO_CLOSE = 10045
# The request is rejected, because the "Opposite positions on a single symbol are disabled" rule is set for the trading account. For example, if the account has a Buy position, then a user cannot open a Sell position or place a pending sell order. The rule is only applied to accounts with hedging accounting system (ACCOUNT_MARGIN_MODE=ACCOUNT_MARGIN_MODE_RETAIL_HEDGING).
TRADE_RETCODE_HEDGE_PROHIBITED = 10046
# Sell order (Offer)
BOOK_TYPE_SELL = 1
# Buy order (Bid)
BOOK_TYPE_BUY = 2
# Sell order by Market
BOOK_TYPE_SELL_MARKET = 3
# Buy order by Market
BOOK_TYPE_BUY_MARKET = 4
# Market buy order
ORDER_TYPE_BUY = 0
# Market sell order
ORDER_TYPE_SELL = 1
# Buy Limit pending order
ORDER_TYPE_BUY_LIMIT = 2
# Sell Limit pending order
ORDER_TYPE_SELL_LIMIT = 3
# Buy Stop pending order
ORDER_TYPE_BUY_STOP = 4
# Sell Stop pending order
ORDER_TYPE_SELL_STOP = 5
# Upon reaching the order price, Buy Limit pending order is placed at StopLimit price
ORDER_TYPE_BUY_STOP_LIMIT = 6
# Upon reaching the order price, Sell Limit pending order is placed at StopLimit price
ORDER_TYPE_SELL_STOP_LIMIT = 7
# Order for closing a position by an opposite one
ORDER_TYPE_CLOSE_BY = 8
# Place an order for an instant deal with the specified parameters (set a market order)
TRADE_ACTION_DEAL = 1
# Place an order for performing a deal at specified conditions (pending order)
TRADE_ACTION_PENDING = 5
# Change open position Stop Loss and Take Profit
TRADE_ACTION_SLTP = 6
# Change parameters of the previously placed trading order
TRADE_ACTION_MODIFY = 7
# Remove previously placed pending order
TRADE_ACTION_REMOVE = 8
# Close a position by an opposite one
TRADE_ACTION_CLOSE_BY = 10
# This execution policy means that an order can be executed only in the specified volume. If the necessary amount of a financial instrument is currently unavailable in the market, the order will not be executed. The desired volume can be made up of several available offers.
ORDER_FILLING_FOK = 0
# An agreement to execute a deal at the maximum volume available in the market within the volume specified in the order. If the request cannot be filled completely, an order with the available volume will be executed, and the remaining volume will be canceled.
ORDER_FILLING_IOC = 1
# This policy is used only for market (ORDER_TYPE_BUY and ORDER_TYPE_SELL), limit and stop limit orders (ORDER_TYPE_BUY_LIMIT, ORDER_TYPE_SELL_LIMIT, ORDER_TYPE_BUY_STOP_LIMIT and ORDER_TYPE_SELL_STOP_LIMIT) and only for the symbols with Market or Exchange execution modes. If filled partially, a market or limit order with the remaining volume is not canceled, and is processed further. During activation of the ORDER_TYPE_BUY_STOP_LIMIT and ORDER_TYPE_SELL_STOP_LIMIT orders, an appropriate limit order ORDER_TYPE_BUY_LIMIT/ORDER_TYPE_SELL_LIMIT with the ORDER_FILLING_RETURN type is created.
ORDER_FILLING_RETURN = 2
# The order stays in the queue until it is manually canceled
ORDER_TIME_GTC = 0
# The order is active only during the current trading day
ORDER_TIME_DAY = 1
# The order is active until the specified date
ORDER_TIME_SPECIFIED = 2
# The order is active until 23:59:59 of the specified day. If this time appears to be out of a trading session, the expiration is processed at the nearest trading time.
ORDER_TIME_SPECIFIED_DAY = 3
def __init__(self,host='localhost',port=18812):
'''
host: str
default = localhost
port: int
default = 18812
'''
self.__conn = rpyc.classic.connect(host,port)
self.__conn.execute('import MetaTrader5 as mt5')
def __del__(self):
pass
def initialize(self,*args,**kwargs):
r'''
# initialize
Establish a connection with the MetaTrader 5 terminal. There are three call options.
Call without parameters. The terminal for connection is found automatically.
```python
initialize()
```
Call specifying the path to the MetaTrader 5 terminal we want to connect to.
```python
initialize(
path # path to the MetaTrader 5 terminal EXE file
)
```
Call specifying the trading account path and parameters.
```python
initialize(
path, # path to the MetaTrader 5 terminal EXE file
login=LOGIN, # account number
password="PASSWORD", # password
server="SERVER", # server name as it is specified in the terminal
timeout=TIMEOUT, # timeout
portable=False # portable mode
)
```
## Parameters
- path
[in] Path to the metatrader.exe or metatrader64.exe file. Optional unnamed parameter. It is indicated first without a parameter name. If the path is not specified, the module attempts to find the executable file on its own.
- login=LOGIN
[in] Trading account number. Optional named parameter. If not specified, the last trading account is used.
- password="PASSWORD"
[in] Trading account password. Optional named parameter. If the password is not set, the password for a specified trading account saved in the terminal database is applied automatically.
- server="SERVER"
[in] Trade server name. Optional named parameter. If the server is not set, the server for a specified trading account saved in the terminal database is applied automatically.
- timeout=TIMEOUT
[in] Connection timeout in milliseconds. Optional named parameter. If not specified, the value of 60 000 (60 seconds) is applied.
- portable=False
[in] Flag of the terminal launch in portable mode. Optional named parameter. If not specified, the value of False is used.
## Return Value
Returns True in case of successful connection to the MetaTrader 5 terminal, otherwise - False.
## Note
If required, the MetaTrader 5 terminal is launched to establish connection when executing the initialize() call.
## Example:
```python
import MetaTrader5 as mt5
# display data on the MetaTrader 5 package
print("MetaTrader5 package author: ",mt5.__author__)
print("MetaTrader5 package version: ",mt5.__version__)
# establish MetaTrader 5 connection to a specified trading account
if not mt5.initialize(login=25115284, server="MetaQuotes-Demo",password="4zatlbqx"):
print("initialize() failed, error code =",mt5.last_error())
quit()
# display data on connection status, server name and trading account
print(mt5.terminal_info())
# display data on MetaTrader 5 version
print(mt5.version())
# shut down connection to the MetaTrader 5 terminal
mt5.shutdown()
```
## See also
`shutdown`, `terminal_info`, `version`
'''
code=f'mt5.initialize(*{args},**{kwargs})'
return self.__conn.eval(code)
def login(self,*args,**kwargs):
r'''
# login
Connect to a trading account using specified parameters.
```python
login(
login, # account number
password="PASSWORD", # password
server="SERVER", # server name as it is specified in the terminal
timeout=TIMEOUT # timeout
)
```
## Parameters
- login
[in] Trading account number. Required unnamed parameter.
- password
[in] Trading account password. Optional named parameter. If the password is not set, the password saved in the terminal database is applied automatically.
- server
[in] Trade server name. Optional named parameter. If no server is set, the last used server is applied automatically.
- timeout=TIMEOUT
[in] Connection timeout in milliseconds. Optional named parameter. If not specified, the value of 60 000 (60 seconds) is applied. If the connection is not established within the specified time, the call is forcibly terminated and the exception is generated.
## Return Value
True in case of a successful connection to the trade account, otherwise – False.
## Example:
```python
import MetaTrader5 as mt5
# display data on the MetaTrader 5 package
print("MetaTrader5 package author: ",mt5.__author__)
print("MetaTrader5 package version: ",mt5.__version__)
# establish connection to the MetaTrader 5 terminal
if not mt5.initialize():
print("initialize() failed, error code =",mt5.last_error())
quit()
# display data on MetaTrader 5 version
print(mt5.version())
# connect to the trade account without specifying a password and a server
account=17221085
authorized=mt5.login(account) # the terminal database password is applied if connection data is set to be remembered
if authorized:
print("connected to account #{}".format(account))
else:
print("failed to connect at account #{}, error code: {}".format(account, mt5.last_error()))
# now connect to another trading account specifying the password
account=25115284
authorized=mt5.login(account, password="gqrtz0lbdm")
if authorized:
# display trading account data 'as is'
print(mt5.account_info())
# display trading account data in the form of a list
print("Show account_info()._asdict():")
account_info_dict = mt5.account_info()._asdict()
for prop in account_info_dict:
print(" {}={}".format(prop, account_info_dict[prop]))
else:
print("failed to connect at account #{}, error code: {}".format(account, mt5.last_error()))
# shut down connection to the MetaTrader 5 terminal
mt5.shutdown()
```
## Result:
```
MetaTrader5 package author: MetaQuotes Software Corp.
MetaTrader5 package version: 5.0.29
[500, 2367, '23 Mar 2020']
connected to account #17221085
connected to account #25115284
AccountInfo(login=25115284, trade_mode=0, leverage=100, limit_orders=200, margin_so_mode=0, ...
account properties:
login=25115284
trade_mode=0
leverage=100
limit_orders=200
margin_so_mode=0
trade_allowed=True
trade_expert=True
margin_mode=2
currency_digits=2
fifo_close=False
balance=99588.33
credit=0.0
profit=-45.23
equity=99543.1
margin=54.37
margin_free=99488.73
margin_level=183084.6054809638
margin_so_call=50.0
margin_so_so=30.0
margin_initial=0.0
margin_maintenance=0.0
assets=0.0
liabilities=0.0
commission_blocked=0.0
name=James Smith
server=MetaQuotes-Demo
currency=USD
company=MetaQuotes Software Corp.
```
## See also
`initialize`, `shutdown`
'''
code=f'mt5.login(*{args},**{kwargs})'
return self.__conn.eval(code)
def shutdown(self,*args,**kwargs):
r'''
# shutdown
Close the previously established connection to the MetaTrader 5 terminal.
```python
shutdown()
```
## Return Value
None.
## Example:
```python
import MetaTrader5 as mt5
# display data on the MetaTrader 5 package
print("MetaTrader5 package author: ",mt5.__author__)
print("MetaTrader5 package version: ",mt5.__version__)
# establish connection to the MetaTrader 5 terminal
if not mt5.initialize():
print("initialize() failed")
quit()
# display data on connection status, server name and trading account
print(mt5.terminal_info())
# display data on MetaTrader 5 version
print(mt5.version())
# shut down connection to the MetaTrader 5 terminal
mt5.shutdown()
```
## See also
`initialize`, `login_py`, `terminal_info`, `version`
'''
code=f'mt5.shutdown(*{args},**{kwargs})'
return self.__conn.eval(code)
def version(self,*args,**kwargs):
r'''
# version
Return the MetaTrader 5 terminal version.
```python
version()
```
## Return Value
Return the MetaTrader 5 terminal version, build and release date. Return None in case of an error. The info on the error can be obtained using `last_error()`.
## Note
The `version()` function returns the terminal version, build and release date as a tuple of three values:
| Type | Description | Sample value |
|---------|-------------------------------|---------------|
| integer | MetaTrader 5 terminal version | 500 |
| integer | Build | 2007 |
| string | Build release date | '25 Feb 2019' |
## Example:
```python
import MetaTrader5 as mt5
import pandas as pd
# display data on the MetaTrader 5 package
print("MetaTrader5 package author: ",mt5.__author__)
print("MetaTrader5 package version: ",mt5.__version__)
# establish connection to the MetaTrader 5 terminal
if not mt5.initialize():
print("initialize() failed, error code =",mt5.last_error())
quit()
# display data on MetaTrader 5 version
print(mt5.version())
# display data on connection status, server name and trading account 'as is'
print(mt5.terminal_info())
print()
# get properties in the form of a dictionary
terminal_info_dict=mt5.terminal_info()._asdict()
# convert the dictionary into DataFrame and print
df=pd.DataFrame(list(terminal_info_dict.items()),columns=['property','value'])
print("terminal_info() as dataframe:")
print(df[:-1])
# shut down connection to the MetaTrader 5 terminal
mt5.shutdown()
```
## Result:
```
MetaTrader5 package author: MetaQuotes Software Corp.
MetaTrader5 package version: 5.0.29
[500, 2367, '23 Mar 2020']
TerminalInfo(community_account=True, community_connection=True, connected=True, dlls_allowed=False, trade_allowed=False, ...
terminal_info() as dataframe:
property value
0 community_account True
1 community_connection True
2 connected True
3 dlls_allowed False
4 trade_allowed False
5 tradeapi_disabled False
6 email_enabled False
7 ftp_enabled False
8 notifications_enabled False
9 mqid False
10 build 2367
11 maxbars 5000
12 codepage 1251
13 ping_last 77881
14 community_balance 707.107
15 retransmission 0
16 company MetaQuotes Software Corp.
17 name MetaTrader 5
18 language Russian
19 path E:\ProgramFiles\MetaTrader 5
20 data_path E:\ProgramFiles\MetaTrader 5
```
## See also
`initialize`, `shutdown`, `terminal_info`
'''
code=f'mt5.version(*{args},**{kwargs})'
return self.__conn.eval(code)
def last_error(self,*args,**kwargs):
r'''
# last_error
Return data on the last error.
```python
last_error()
```
## Return Value
Return the last error code and description as a tuple.
## Note
`last_error()` allows obtaining an error code in case of a failed execution of a MetaTrader 5 library function. It is similar to `GetLastError()`. However, it applies its own error codes. Possible values:
| Constant | Value | Description |
|-----------------------------|--------|----------------------------------|
| RES_S_OK | 1 | generic success |
| RES_E_FAIL | -1 | generic fail |
| RES_E_INVALID_PARAMS | -2 | invalid arguments/parameters |
| RES_E_NO_MEMORY | -3 | no memory condition |
| RES_E_NOT_FOUND | -4 | no history |
| RES_E_INVALID_VERSION | -5 | invalid version |
| RES_E_AUTH_FAILED | -6 | authorization failed |
| RES_E_UNSUPPORTED | -7 | unsupported method |
| RES_E_AUTO_TRADING_DISABLED | -8 | auto-trading disabled |
| RES_E_INTERNAL_FAIL | -10000 | internal IPC general error |
| RES_E_INTERNAL_FAIL_SEND | -10001 | internal IPC send failed |
| RES_E_INTERNAL_FAIL_RECEIVE | -10002 | internal IPC recv failed |
| RES_E_INTERNAL_FAIL_INIT | -10003 | internal IPC initialization fail |
| RES_E_INTERNAL_FAIL_CONNECT | -10003 | internal IPC no ipc |
| RES_E_INTERNAL_FAIL_TIMEOUT | -10005 | internal timeout |
## Example:
```python
import MetaTrader5 as mt5
# display data on the MetaTrader 5 package
print("MetaTrader5 package author: ",mt5.__author__)
print("MetaTrader5 package version: ",mt5.__version__)
# establish connection to the MetaTrader 5 terminal
if not mt5.initialize():
print("initialize() failed, error code =",mt5.last_error())
quit()
# shut down connection to the MetaTrader 5 terminal
mt5.shutdown()
```
## See also
`version`, `GetLastError`
'''
code=f'mt5.last_error(*{args},**{kwargs})'
return self.__conn.eval(code)
def account_info(self,*args,**kwargs):
r'''
# account_info
Get info on the current trading account.
```python
account_info()
```
## Return Value
Return info in the form of a named tuple structure (namedtuple). Return None in case of an error. The info on the error can be obtained using `last_error()`.
## Note
The function returns all data that can be obtained using `AccountInfoInteger`, `AccountInfoDouble` and `AccountInfoString` in one call.
## Example:
```python
import MetaTrader5 as mt5
import pandas as pd
# display data on the MetaTrader 5 package
print("MetaTrader5 package author: ",mt5.__author__)
print("MetaTrader5 package version: ",mt5.__version__)
# establish connection to the MetaTrader 5 terminal
if not mt5.initialize():
print("initialize() failed, error code =",mt5.last_error())
quit()
# connect to the trade account specifying a password and a server
authorized=mt5.login(25115284, password="gqz0343lbdm")
if authorized:
account_info=mt5.account_info()
if account_info!=None:
# display trading account data 'as is'
print(account_info)
# display trading account data in the form of a dictionary
print("Show account_info()._asdict():")
account_info_dict = mt5.account_info()._asdict()
for prop in account_info_dict:
print(" {}={}".format(prop, account_info_dict[prop]))
print()
# convert the dictionary into DataFrame and print
df=pd.DataFrame(list(account_info_dict.items()),columns=['property','value'])
print("account_info() as dataframe:")
print(df)
else:
print("failed to connect to trade account 25115284 with password=gqz0343lbdm, error code =",mt5.last_error())
# shut down connection to the MetaTrader 5 terminal
mt5.shutdown()
```
## Result:
```
MetaTrader5 package author: MetaQuotes Software Corp.
MetaTrader5 package version: 5.0.29
AccountInfo(login=25115284, trade_mode=0, leverage=100, limit_orders=200, margin_so_mode=0, ....
Show account_info()._asdict():
login=25115284
trade_mode=0
leverage=100
limit_orders=200
margin_so_mode=0
trade_allowed=True
trade_expert=True
margin_mode=2
currency_digits=2
fifo_close=False
balance=99511.4
credit=0.0
profit=41.82
equity=99553.22
margin=98.18
margin_free=99455.04
margin_level=101398.67590140559
margin_so_call=50.0
margin_so_so=30.0
margin_initial=0.0
margin_maintenance=0.0
assets=0.0
liabilities=0.0
commission_blocked=0.0
name=MetaQuotes Dev Demo
server=MetaQuotes-Demo
currency=USD
company=MetaQuotes Software Corp.
account_info() as dataframe
property value
0 login 25115284
1 trade_mode 0
2 leverage 100
3 limit_orders 200
4 margin_so_mode 0
5 trade_allowed True
6 trade_expert True
7 margin_mode 2
8 currency_digits 2
9 fifo_close False
10 balance 99588.3
11 credit 0
12 profit -45.13
13 equity 99543.2
14 margin 54.37
15 margin_free 99488.8
16 margin_level 183085
17 margin_so_call 50
18 margin_so_so 30
19 margin_initial 0
20 margin_maintenance 0
21 assets 0
22 liabilities 0
23 commission_blocked 0
24 name James Smith
25 server MetaQuotes-Demo
26 currency USD
27 company MetaQuotes Software Corp.
```
## See also
`initialize`, `shutdown`, `login`
'''
code=f'mt5.account_info(*{args},**{kwargs})'
return self.__conn.eval(code)
def terminal_info(self,*args,**kwargs):
r'''
# terminal_info
Get the connected MetaTrader 5 client terminal status and settings.
```python
terminal_info()
```
## Return Value
Return info in the form of a named tuple structure (namedtuple). Return None in case of an error. The info on the error can be obtained using last_error().
## Note
The function returns all data that can be obtained using `TerminalInfoInteger`, `TerminalInfoDouble` and `TerminalInfoDouble` in one call.
## Example:
```python
import MetaTrader5 as mt5
import pandas as pd
# display data on the MetaTrader 5 package
print("MetaTrader5 package author: ",mt5.__author__)
print("MetaTrader5 package version: ",mt5.__version__)
# display data on the MetaTrader 5 package
print("MetaTrader5 package author: ",mt5.__author__)
print("MetaTrader5 package version: ",mt5.__version__)
# establish connection to the MetaTrader 5 terminal
if not mt5.initialize():
print("initialize() failed, error code =",mt5.last_error())
quit()
# display data on MetaTrader 5 version
print(mt5.version())
# display info on the terminal settings and status
terminal_info=mt5.terminal_info()
if terminal_info!=None:
# display the terminal data 'as is'
print(terminal_info)
# display data in the form of a list
print("Show terminal_info()._asdict():")
terminal_info_dict = mt5.terminal_info()._asdict()
for prop in terminal_info_dict:
print(" {}={}".format(prop, terminal_info_dict[prop]))
print()
# convert the dictionary into DataFrame and print
df=pd.DataFrame(list(terminal_info_dict.items()),columns=['property','value'])
print("terminal_info() as dataframe:")
print(df)
# shut down connection to the MetaTrader 5 terminal
mt5.shutdown()
```
## Result:
```
MetaTrader5 package author: MetaQuotes Software Corp.
MetaTrader5 package version: 5.0.29
[500, 2366, '20 Mar 2020']
TerminalInfo(community_account=True, community_connection=True, connected=True,....
Show terminal_info()._asdict():
community_account=True
community_connection=True
connected=True
dlls_allowed=False
trade_allowed=False
tradeapi_disabled=False
email_enabled=False
ftp_enabled=False
notifications_enabled=False
mqid=False
build=2366
maxbars=5000
codepage=1251
ping_last=77850
community_balance=707.10668201585
retransmission=0.0
company=MetaQuotes Software Corp.
name=MetaTrader 5
language=Russian
path=E:\ProgramFiles\MetaTrader 5
data_path=E:\ProgramFiles\MetaTrader 5
commondata_path=C:\Users\Rosh\AppData\Roaming\MetaQuotes\Terminal\Common
terminal_info() as dataframe:
property value
0 community_account True
1 community_connection True
2 connected True
3 dlls_allowed False
4 trade_allowed False
5 tradeapi_disabled False
6 email_enabled False
7 ftp_enabled False
8 notifications_enabled False
9 mqid False
10 build 2367
11 maxbars 5000
12 codepage 1251
13 ping_last 80953
14 community_balance 707.107
15 retransmission 0.063593
16 company MetaQuotes Software Corp.
17 name MetaTrader 5
18 language Russian
```
## See also
`initialize`, `shutdown`, `version`
'''
code=f'mt5.terminal_info(*{args},**{kwargs})'
return self.__conn.eval(code)
def symbols_total(self,*args,**kwargs):
r'''
# symbols_total
Get the number of all financial instruments in the MetaTrader 5 terminal.
```python
symbols_total()
```
## Return Value
Integer value.
## Note
The function is similar to `SymbolsTotal()`. However, it returns the number of all symbols including custom ones and the ones disabled in MarketWatch.
## Example:
```python
import MetaTrader5 as mt5
# display data on the MetaTrader 5 package
print("MetaTrader5 package author: ",mt5.__author__)
print("MetaTrader5 package version: ",mt5.__version__)
# establish connection to the MetaTrader 5 terminal
if not mt5.initialize():
print("initialize() failed, error code =",mt5.last_error())
quit()
# get the number of financial instruments
symbols=mt5.symbols_total()
if symbols>0:
print("Total symbols =",symbols)
else:
print("symbols not found")
# shut down connection to the MetaTrader 5 terminal
mt5.shutdown()
```
## See also
`symbols_get`, `symbol_select`, `symbol_info`
'''
code=f'mt5.symbols_total(*{args},**{kwargs})'
return self.__conn.eval(code)
def symbols_get(self,*args,**kwargs):
r'''
# symbols_get
Get all financial instruments from the MetaTrader 5 terminal.
```python
symbols_get(
group="GROUP" # symbol selection filter
)
```
- group="GROUP"
[in] The filter for arranging a group of necessary symbols. Optional parameter. If the group is specified, the function returns only symbols meeting a specified criteria.
## Return Value
Return symbols in the form of a tuple. Return None in case of an error. The info on the error can be obtained using `last_error()`.
## Note
The group parameter allows sorting out symbols by name. '*' can be used at the beginning and the end of a string.
The group parameter can be used as a named or an unnamed one. Both options work the same way. The named option (group="GROUP") makes the code easier to read.
The group parameter may contain several comma separated conditions. A condition can be set as a mask using '*'. The logical negation symbol '!' can be used for an exclusion. All conditions are applied sequentially, which means conditions of including to a group should be specified first followed by an exclusion condition. For example, group="*, !EUR" means that all symbols should be selected first and the ones containing "EUR" in their names should be excluded afterwards.
Unlike `symbol_info()`, the `symbols_get()` function returns data on all requested symbols within a single call.
## Example:
```python
import MetaTrader5 as mt5
# display data on the MetaTrader 5 package
print("MetaTrader5 package author: ",mt5.__author__)
print("MetaTrader5 package version: ",mt5.__version__)
# establish connection to the MetaTrader 5 terminal
if not mt5.initialize():
print("initialize() failed, error code =",mt5.last_error())
quit()
# get all symbols
symbols=mt5.symbols_get()
print('Symbols: ', len(symbols))
count=0
# display the first five ones
for s in symbols:
count+=1
print("{}. {}".format(count,s.name))
if count==5: break
print()
# get symbols containing RU in their names
ru_symbols=mt5.symbols_get("*RU*")
print('len(*RU*): ', len(ru_symbols))
for s in ru_symbols:
print(s.name)
print()
# get symbols whose names do not contain USD, EUR, JPY and GBP
group_symbols=mt5.symbols_get(group="*,!*USD*,!*EUR*,!*JPY*,!*GBP*")
print('len(*,!*USD*,!*EUR*,!*JPY*,!*GBP*):', len(group_symbols))
for s in group_symbols:
print(s.name,":",s)
# shut down connection to the MetaTrader 5 terminal
mt5.shutdown()
```
## Result:
```
MetaTrader5 package author: MetaQuotes Software Corp.
MetaTrader5 package version: 5.0.29
Symbols: 84
1. EURUSD
2. GBPUSD
3. USDCHF
4. USDJPY
5. USDCNH
len(*RU*): 8
EURUSD
USDRUB
USDRUR
EURRUR
EURRUB
FORTS.RUB.M5
EURUSD_T20
EURUSD4
len(*,!*USD*,!*EUR*,!*JPY*,!*GBP*): 13
AUDCAD : SymbolInfo(custom=False, chart_mode=0, select=True, visible=True, session_deals=0, session_buy_orders=0, session...
AUDCHF : SymbolInfo(custom=False, chart_mode=0, select=False, visible=False, session_deals=0, session_buy_orders=0, sessi...
AUDNZD : SymbolInfo(custom=False, chart_mode=0, select=False, visible=False, session_deals=0, session_buy_orders=0, sessi...
CADCHF : SymbolInfo(custom=False, chart_mode=0, select=False, visible=False, session_deals=0, session_buy_orders=0, sessi...
NZDCAD : SymbolInfo(custom=False, chart_mode=0, select=False, visible=False, session_deals=0, session_buy_orders=0, sessi...
NZDCHF : SymbolInfo(custom=False, chart_mode=0, select=False, visible=False, session_deals=0, session_buy_orders=0, sessi...
NZDSGD : SymbolInfo(custom=False, chart_mode=0, select=False, visible=False, session_deals=0, session_buy_orders=0, sessi...
CADMXN : SymbolInfo(custom=False, chart_mode=0, select=False, visible=False, session_deals=0, session_buy_orders=0, sessi...
CHFMXN : SymbolInfo(custom=False, chart_mode=0, select=False, visible=False, session_deals=0, session_buy_orders=0, sessi...
NZDMXN : SymbolInfo(custom=False, chart_mode=0, select=False, visible=False, session_deals=0, session_buy_orders=0, sessi...
FORTS.RTS.M5 : SymbolInfo(custom=True, chart_mode=0, select=False, visible=False, session_deals=0, session_buy_orders=0, ...
FORTS.RUB.M5 : SymbolInfo(custom=True, chart_mode=0, select=False, visible=False, session_deals=0, session_buy_orders=0, ...
FOREX.CHF.M5 : SymbolInfo(custom=True, chart_mode=0, select=False, visible=False, session_deals=0, session_buy_orders=0, ...
```
## See also
`symbols_total`, `symbol_select`, `symbol_info`
'''
code=f'mt5.symbols_get(*{args},**{kwargs})'
return self.__conn.eval(code)
def symbol_info(self,*args,**kwargs):
r'''
# symbol_info
Get data on the specified financial instrument.
```python
symbol_info(
symbol # financial instrument name
)
```
- symbol
[in] Financial instrument name. Required unnamed parameter.
## Return Value
Return info in the form of a named tuple structure (namedtuple). Return None in case of an error. The info on the error can be obtained using `last_error()`.
## Note
The function returns all data that can be obtained using `SymbolInfoInteger`, `SymbolInfoDouble` and `SymbolInfoString` in one call.
## Example:
```python
import MetaTrader5 as mt5
# display data on the MetaTrader 5 package
print("MetaTrader5 package author: ",mt5.__author__)
print("MetaTrader5 package version: ",mt5.__version__)
# establish connection to the MetaTrader 5 terminal
if not mt5.initialize():
print("initialize() failed, error code =",mt5.last_error())
quit()
# attempt to enable the display of the EURJPY symbol in MarketWatch
selected=mt5.symbol_select("EURJPY",True)
if not selected:
print("Failed to select EURJPY")
mt5.shutdown()
quit()
# display EURJPY symbol properties
symbol_info=mt5.symbol_info("EURJPY")
if symbol_info!=None:
# display the terminal data 'as is'
print(symbol_info)
print("EURJPY: spread =",symbol_info.spread," digits =",symbol_info.digits)
# display symbol properties as a list
print("Show symbol_info(\"EURJPY\")._asdict():")
symbol_info_dict = mt5.symbol_info("EURJPY")._asdict()
for prop in symbol_info_dict:
print(" {}={}".format(prop, symbol_info_dict[prop]))
# shut down connection to the MetaTrader 5 terminal
mt5.shutdown()
```
## Result:
```
MetaTrader5 package author: MetaQuotes Software Corp.
MetaTrader5 package version: 5.0.29
SymbolInfo(custom=False, chart_mode=0, select=True, visible=True, session_deals=0, session_buy_orders=0, session_sell_orders=0, ...
EURJPY: spread = 17 digits = 3
Show symbol_info()._asdict():
custom=False
chart_mode=0
select=True
visible=True
session_deals=0
session_buy_orders=0
session_sell_orders=0
volume=0
volumehigh=0
volumelow=0
time=1585069682
digits=3
spread=17
spread_float=True
ticks_bookdepth=10
trade_calc_mode=0
trade_mode=4
start_time=0
expiration_time=0
trade_stops_level=0
trade_freeze_level=0
trade_exemode=1
swap_mode=1
swap_rollover3days=3
margin_hedged_use_leg=False
expiration_mode=7
filling_mode=1
order_mode=127
order_gtc_mode=0
option_mode=0
option_right=0
bid=120.024
bidhigh=120.506
bidlow=118.798
ask=120.041
askhigh=120.526
asklow=118.828
last=0.0
lasthigh=0.0
lastlow=0.0
volume_real=0.0
volumehigh_real=0.0
volumelow_real=0.0
option_strike=0.0
point=0.001
trade_tick_value=0.8977708350166538
trade_tick_value_profit=0.8977708350166538
trade_tick_value_loss=0.8978272580355541
trade_tick_size=0.001
trade_contract_size=100000.0
trade_accrued_interest=0.0
trade_face_value=0.0
trade_liquidity_rate=0.0
volume_min=0.01
volume_max=500.0
volume_step=0.01
volume_limit=0.0
swap_long=-0.2
swap_short=-1.2
margin_initial=0.0
margin_maintenance=0.0
session_volume=0.0
session_turnover=0.0
session_interest=0.0
session_buy_orders_volume=0.0
session_sell_orders_volume=0.0
session_open=0.0
session_close=0.0
session_aw=0.0
session_price_settlement=0.0
session_price_limit_min=0.0
session_price_limit_max=0.0
margin_hedged=100000.0
price_change=0.0
price_volatility=0.0
price_theoretical=0.0
price_greeks_delta=0.0
price_greeks_theta=0.0
price_greeks_gamma=0.0
price_greeks_vega=0.0
price_greeks_rho=0.0
price_greeks_omega=0.0
price_sensitivity=0.0
basis=
category=
currency_base=EUR
currency_profit=JPY
currency_margin=EUR
bank=
description=Euro vs Japanese Yen
exchange=
formula=
isin=
name=EURJPY
page=http://www.google.com/finance?q=EURJPY
path=Forex\EURJPY
```
## See also
`account_info`, `terminal_info`
'''
code=f'mt5.symbol_info(*{args},**{kwargs})'
return self.__conn.eval(code)
def symbol_info_tick(self,*args,**kwargs):
r'''
# symbol_info_tick
Get the last tick for the specified financial instrument.
```python
symbol_info_tick(
symbol # financial instrument name
)
```
- symbol
[in] Financial instrument name. Required unnamed parameter.
## Return Value
Return info in the form of a tuple. Return None in case of an error. The info on the error can be obtained using `last_error()`.
## Note
The function is similar to SymbolInfoTick.
## Example:
```python
import MetaTrader5 as mt5
# display data on the MetaTrader 5 package
print("MetaTrader5 package author: ",mt5.__author__)
print("MetaTrader5 package version: ",mt5.__version__)
# establish connection to the MetaTrader 5 terminal
if not mt5.initialize():
print("initialize() failed, error code =",mt5.last_error())
quit()
# attempt to enable the display of the GBPUSD in MarketWatch
selected=mt5.symbol_select("GBPUSD",True)
if not selected:
print("Failed to select GBPUSD")
mt5.shutdown()
quit()
# display the last GBPUSD tick
lasttick=mt5.symbol_info_tick("GBPUSD")
print(lasttick)
# display tick field values in the form of a list
print("Show symbol_info_tick(\"GBPUSD\")._asdict():")
symbol_info_tick_dict = mt5.symbol_info_tick("GBPUSD")._asdict()
for prop in symbol_info_tick_dict:
print(" {}={}".format(prop, symbol_info_tick_dict[prop]))
# shut down connection to the MetaTrader 5 terminal
mt5.shutdown()
```
## Result:
```
MetaTrader5 package author: MetaQuotes Software Corp.
MetaTrader5 package version: 5.0.29
Tick(time=1585070338, bid=1.17264, ask=1.17279, last=0.0, volume=0, time_msc=1585070338728, flags=2, volume_real=0.0)
Show symbol_info_tick._asdict():
time=1585070338
bid=1.17264
ask=1.17279
last=0.0
volume=0
time_msc=1585070338728
flags=2
volume_real=0.0
```
## See also
``symbol_info`
'''
code=f'mt5.symbol_info_tick(*{args},**{kwargs})'
return self.__conn.eval(code)
def symbol_select(self,*args,**kwargs):
r'''
# symbol_select
Select a symbol in the MarketWatch window or remove a symbol from the window.
```python
symbol_select(
symbol, # financial instrument name
enable # enable or disable
)
```
- symbol
[in] Financial instrument name. Required unnamed parameter.
- enable
[in] Switch. Optional unnamed parameter. If 'false', a symbol should be removed from the MarketWatch window. Otherwise, it should be selected in the MarketWatch window. A symbol cannot be removed if open charts with this symbol are currently present or positions are opened on it.
## Return Value
`True` if successful, otherwise – `False`.
## Note
The function is similar to `SymbolSelect`.
## Example:
```python
import MetaTrader5 as mt5
import pandas as pd
# display data on the MetaTrader 5 package
print("MetaTrader5 package author: ",mt5.__author__)
print("MetaTrader5 package version: ",mt5.__version__)
print()
# establish connection to the MetaTrader 5 terminal
if not mt5.initialize(login=25115284, server="MetaQuotes-Demo",password="4zatlbqx"):
print("initialize() failed, error code =",mt5.last_error())
quit()
# attempt to enable the display of the EURCAD in MarketWatch
selected=mt5.symbol_select("EURCAD",True)
if not selected:
print("Failed to select EURCAD, error code =",mt5.last_error())
else:
symbol_info=mt5.symbol_info("EURCAD")
print(symbol_info)
print("EURCAD: currency_base =",symbol_info.currency_base," currency_profit =",symbol_info.currency_profit," currency_margin =",symbol_info.currency_margin)
print()
# get symbol properties in the form of a dictionary
print("Show symbol_info()._asdict():")
symbol_info_dict = symbol_info._asdict()
for prop in symbol_info_dict:
print(" {}={}".format(prop, symbol_info_dict[prop]))
print()
# convert the dictionary into DataFrame and print
df=pd.DataFrame(list(symbol_info_dict.items()),columns=['property','value'])
print("symbol_info_dict() as dataframe:")
print(df)
# shut down connection to the MetaTrader 5 terminal
mt5.shutdown()
```
## Result:
```
MetaTrader5 package author: MetaQuotes Software Corp.
MetaTrader5 package version: 5.0.29
SymbolInfo(custom=False, chart_mode=0, select=True, visible=True, session_deals=0, session_buy_orders=0, session_sell_orders=0, volume=0, volumehigh=0, ....
EURCAD: currency_base = EUR currency_profit = CAD currency_margin = EUR
Show symbol_info()._asdict():
custom=False
chart_mode=0
select=True
visible=True
session_deals=0
session_buy_orders=0
session_sell_orders=0
volume=0
volumehigh=0
volumelow=0
time=1585217595
digits=5
spread=39
spread_float=True
ticks_bookdepth=10
trade_calc_mode=0
trade_mode=4
start_time=0
expiration_time=0
trade_stops_level=0
trade_freeze_level=0
trade_exemode=1
swap_mode=1
swap_rollover3days=3
margin_hedged_use_leg=False
expiration_mode=7
filling_mode=1
order_mode=127
order_gtc_mode=0
option_mode=0
option_right=0
bid=1.55192
bidhigh=1.55842
bidlow=1.5419800000000001
ask=1.5523099999999999
askhigh=1.55915
asklow=1.5436299999999998
last=0.0
lasthigh=0.0
lastlow=0.0
volume_real=0.0
volumehigh_real=0.0
volumelow_real=0.0
option_strike=0.0
point=1e-05
trade_tick_value=0.7043642408362214
trade_tick_value_profit=0.7043642408362214
trade_tick_value_loss=0.7044535553770941
trade_tick_size=1e-05
trade_contract_size=100000.0
trade_accrued_interest=0.0
trade_face_value=0.0
trade_liquidity_rate=0.0
volume_min=0.01
volume_max=500.0
volume_step=0.01
volume_limit=0.0
swap_long=-1.1
swap_short=-0.9
margin_initial=0.0
margin_maintenance=0.0
session_volume=0.0
session_turnover=0.0
session_interest=0.0
session_buy_orders_volume=0.0
session_sell_orders_volume=0.0
session_open=0.0
session_close=0.0
session_aw=0.0
session_price_settlement=0.0
session_price_limit_min=0.0
session_price_limit_max=0.0
margin_hedged=100000.0
price_change=0.0
price_volatility=0.0
price_theoretical=0.0
price_greeks_delta=0.0
price_greeks_theta=0.0
price_greeks_gamma=0.0
price_greeks_vega=0.0
price_greeks_rho=0.0
price_greeks_omega=0.0
price_sensitivity=0.0
basis=
category=
currency_base=EUR
currency_profit=CAD
currency_margin=EUR
bank=
description=Euro vs Canadian Dollar
exchange=
formula=
isin=
name=EURCAD
page=http://www.google.com/finance?q=EURCAD
path=Forex\EURCAD
symbol_info_dict() as dataframe:
property value
0 custom False
1 chart_mode 0
2 select True
3 visible True
4 session_deals 0
.. ... ...
91 formula
92 isin
93 name EURCAD
94 page http://www.google.com/finance?q=EURCAD
95 path Forex\EURCAD
[96 rows x 2 columns]
```
## See also
`symbol_info`
'''
code=f'mt5.symbol_select(*{args},**{kwargs})'
return self.__conn.eval(code)
def market_book_add(self,*args,**kwargs):
r'''
# market_book_add
Subscribes the MetaTrader 5 terminal to the Market Depth change events for a specified symbol.
```python
market_book_add(
symbol # financial instrument name
)
```
- symbol
[in] Financial instrument name. Required unnamed parameter.
## Return Value
`True` if successful, otherwise – `False`.
## Note
The function is similar to `MarketBookAdd`.
## See also
`market_book_get`, `market_book_release`, Market Depth structure
'''
code=f'mt5.market_book_add(*{args},**{kwargs})'
return self.__conn.eval(code)
def market_book_get(self,*args,**kwargs):
r'''
# market_book_get
Returns a tuple from `BookInfo` featuring Market Depth entries for the specified symbol.
```python
market_book_get(
symbol # financial instrument name
)
```
- symbol
[in] Financial instrument name. Required unnamed parameter.
## Return Value
Returns the Market Depth content as a tuple from `BookInfo` entries featuring order type, price and volume in lots. `BookInfo` is similar to the `MqlBookInfo` structure.
Return None in case of an error. The info on the error can be obtained using `last_error()`.
## Note
The subscription to the Market Depth change events should be preliminarily performed using the `market_book_add()` function.
The function is similar to `MarketBookGet`.
## Example:
```python
import MetaTrader5 as mt5
import time
# display data on the MetaTrader 5 package
print("MetaTrader5 package author: ",mt5.__author__)
print("MetaTrader5 package version: ",mt5.__version__)
print("")
# establish connection to the MetaTrader 5 terminal
if not mt5.initialize():
print("initialize() failed, error code =",mt5.last_error())
# shut down connection to the MetaTrader 5 terminal
mt5.shutdown()
quit()
# subscribe to market depth updates for EURUSD (Depth of Market)
if mt5.market_book_add('EURUSD'):
# get the market depth data 10 times in a loop
for i in range(10):
# get the market depth content (Depth of Market)
items = mt5.market_book_get('EURUSD')
# display the entire market depth 'as is' in a single string
print(items)
# now display each order separately for more clarity
if items:
for it in items:
# order content
print(it._asdict())
# pause for 5 seconds before the next request of the market depth data
time.sleep(5)
# cancel the subscription to the market depth updates (Depth of Market)
mt5.market_book_release('EURUSD')
else:
print("mt5.market_book_add('EURUSD') failed, error code =",mt5.last_error())
# shut down connection to the MetaTrader 5 terminal
mt5.shutdown()
```
## Result:
```
MetaTrader5 package author: MetaQuotes Software Corp.
MetaTrader5 package version: 5.0.34
(BookInfo(type=1, price=1.20038, volume=250, volume_dbl=250.0), BookInfo(type=1, price=1.20032, volume=100, volume...
{'type': 1, 'price': 1.20038, 'volume': 250, 'volume_dbl': 250.0}
{'type': 1, 'price': 1.20032, 'volume': 100, 'volume_dbl': 100.0}
{'type': 1, 'price': 1.2003, 'volume': 50, 'volume_dbl': 50.0}
{'type': 1, 'price': 1.20028, 'volume': 36, 'volume_dbl': 36.0}
{'type': 2, 'price': 1.20026, 'volume': 36, 'volume_dbl': 36.0}
{'type': 2, 'price': 1.20025, 'volume': 50, 'volume_dbl': 50.0}
{'type': 2, 'price': 1.20023, 'volume': 100, 'volume_dbl': 100.0}
{'type': 2, 'price': 1.20017, 'volume': 250, 'volume_dbl': 250.0}
(BookInfo(type=1, price=1.2004299999999999, volume=250, volume_dbl=250.0), BookInfo(type=1, price=1.20037, volume...
{'type': 1, 'price': 1.2004299999999999, 'volume': 250, 'volume_dbl': 250.0}
{'type': 1, 'price': 1.20037, 'volume': 100, 'volume_dbl': 100.0}
{'type': 1, 'price': 1.20036, 'volume': 50, 'volume_dbl': 50.0}
{'type': 1, 'price': 1.20034, 'volume': 36, 'volume_dbl': 36.0}
{'type': 2, 'price': 1.20031, 'volume': 36, 'volume_dbl': 36.0}
{'type': 2, 'price': 1.20029, 'volume': 50, 'volume_dbl': 50.0}
{'type': 2, 'price': 1.20028, 'volume': 100, 'volume_dbl': 100.0}
{'type': 2, 'price': 1.20022, 'volume': 250, 'volume_dbl': 250.0}
(BookInfo(type=1, price=1.2004299999999999, volume=250, volume_dbl=250.0), BookInfo(type=1, price=1.20037, volume...
{'type': 1, 'price': 1.2004299999999999, 'volume': 250, 'volume_dbl': 250.0}
{'type': 1, 'price': 1.20037, 'volume': 100, 'volume_dbl': 100.0}
{'type': 1, 'price': 1.20036, 'volume': 50, 'volume_dbl': 50.0}
{'type': 1, 'price': 1.20034, 'volume': 36, 'volume_dbl': 36.0}
{'type': 2, 'price': 1.20031, 'volume': 36, 'volume_dbl': 36.0}
{'type': 2, 'price': 1.20029, 'volume': 50, 'volume_dbl': 50.0}
{'type': 2, 'price': 1.20028, 'volume': 100, 'volume_dbl': 100.0}
{'type': 2, 'price': 1.20022, 'volume': 250, 'volume_dbl': 250.0}
(BookInfo(type=1, price=1.20036, volume=250, volume_dbl=250.0), BookInfo(type=1, price=1.20029, volume=100, volume...
{'type': 1, 'price': 1.20036, 'volume': 250, 'volume_dbl': 250.0}
{'type': 1, 'price': 1.20029, 'volume': 100, 'volume_dbl': 100.0}
{'type': 1, 'price': 1.20028, 'volume': 50, 'volume_dbl': 50.0}
{'type': 1, 'price': 1.20026, 'volume': 36, 'volume_dbl': 36.0}
{'type': 2, 'price': 1.20023, 'volume': 36, 'volume_dbl': 36.0}
{'type': 2, 'price': 1.20022, 'volume': 50, 'volume_dbl': 50.0}
{'type': 2, 'price': 1.20021, 'volume': 100, 'volume_dbl': 100.0}
{'type': 2, 'price': 1.20014, 'volume': 250, 'volume_dbl': 250.0}
(BookInfo(type=1, price=1.20035, volume=250, volume_dbl=250.0), BookInfo(type=1, price=1.20029, volume=100, volume...
{'type': 1, 'price': 1.20035, 'volume': 250, 'volume_dbl': 250.0}
{'type': 1, 'price': 1.20029, 'volume': 100, 'volume_dbl': 100.0}
{'type': 1, 'price': 1.20027, 'volume': 50, 'volume_dbl': 50.0}
{'type': 1, 'price': 1.20025, 'volume': 36, 'volume_dbl': 36.0}
{'type': 2, 'price': 1.20023, 'volume': 36, 'volume_dbl': 36.0}
{'type': 2, 'price': 1.20022, 'volume': 50, 'volume_dbl': 50.0}
{'type': 2, 'price': 1.20021, 'volume': 100, 'volume_dbl': 100.0}
{'type': 2, 'price': 1.20014, 'volume': 250, 'volume_dbl': 250.0}
(BookInfo(type=1, price=1.20037, volume=250, volume_dbl=250.0), BookInfo(type=1, price=1.20031, volume=100, volume...
{'type': 1, 'price': 1.20037, 'volume': 250, 'volume_dbl': 250.0}
{'type': 1, 'price': 1.20031, 'volume': 100, 'volume_dbl': 100.0}
{'type': 1, 'price': 1.2003, 'volume': 50, 'volume_dbl': 50.0}
{'type': 1, 'price': 1.20028, 'volume': 36, 'volume_dbl': 36.0}
{'type': 2, 'price': 1.20025, 'volume': 36, 'volume_dbl': 36.0}
{'type': 2, 'price': 1.20023, 'volume': 50, 'volume_dbl': 50.0}
{'type': 2, 'price': 1.20022, 'volume': 100, 'volume_dbl': 100.0}
{'type': 2, 'price': 1.20016, 'volume': 250, 'volume_dbl': 250.0}
```
## See also
`market_book_add`, `market_book_release`, Market Depth structure
'''
code=f'mt5.market_book_get(*{args},**{kwargs})'
return self.__conn.eval(code)
def market_book_release(self,symbol):
r'''
# market_book_release
Cancels subscription of the MetaTrader 5 terminal to the Market Depth change events for a specified symbol.
```python
market_book_release(
symbol # financial instrument name
)
```
- symbol
[in] Financial instrument name. Required unnamed parameter.
## Return Value
`True` if successful, otherwise – `False`.
## Note
The function is similar to `MarketBookRelease`.
## See also
`market_book_add`, `market_book_get`, Market Depth structure
'''
code=f'mt5.market_book_release(symbol)'
return self.__conn.eval(code)
def copy_rates_from(self,symbol, timeframe, date_from, count):
r'''
# copy_rates_from
Get bars from the MetaTrader 5 terminal starting from the specified date.
```python
copy_rates_from(
symbol, # symbol name
timeframe, # timeframe
date_from, # initial bar open date
count # number of bars
)
```
## Parameters
- symbol
[in] Financial instrument name, for example, "EURUSD". Required unnamed parameter.
- timeframe
[in] Timeframe the bars are requested for. Set by a value from the TIMEFRAME enumeration. Required unnamed parameter.
- date_from
[in] Date of opening of the first bar from the requested sample. Set by the 'datetime' object or as a number of seconds elapsed since 1970.01.01. Required unnamed parameter.
- count
[in] Number of bars to receive. Required unnamed parameter.
## Return Value
Returns bars as the numpy array with the named time, open, high, low, close, tick_volume, spread and real_volume columns. Return None in case of an error. The info on the error can be obtained using `last_error()`.
## Note
See the `CopyRates()` function for more information.
MetaTrader 5 terminal provides bars only within a history available to a user on charts. The number of bars available to users is set in the "Max. bars in chart" parameter.
When creating the 'datetime' object, Python uses the local time zone, while MetaTrader 5 stores tick and bar open time in UTC time zone (without the shift). Therefore, 'datetime' should be created in UTC time for executing functions that use time. Data received from the MetaTrader 5 terminal has UTC time.
TIMEFRAME is an enumeration with possible chart period values
| ID | Description |
|---------------|-------------|
| TIMEFRAME_M1 | 1 minute |
| TIMEFRAME_M2 | 2 minutes |
| TIMEFRAME_M3 | 3 minutes |
| TIMEFRAME_M4 | 4 minutes |
| TIMEFRAME_M5 | 5 minutes |
| TIMEFRAME_M6 | 6 minutes |
| TIMEFRAME_M10 | 10 minutes |
| TIMEFRAME_M12 | 12 minutes |
| TIMEFRAME_M12 | 15 minutes |
| TIMEFRAME_M20 | 20 minutes |
| TIMEFRAME_M30 | 30 minutes |
| TIMEFRAME_H1 | 1 hour |
| TIMEFRAME_H2 | 2 hours |
| TIMEFRAME_H3 | 3 hours |
| TIMEFRAME_H4 | 4 hours |
| TIMEFRAME_H6 | 6 hours |
| TIMEFRAME_H8 | 8 hours |
| TIMEFRAME_H12 | 12 hours |
| TIMEFRAME_D1 | 1 day |
| TIMEFRAME_W1 | 1 week |
| TIMEFRAME_MN1 | 1 month |
## Example:
```python
from datetime import datetime
import MetaTrader5 as mt5
# display data on the MetaTrader 5 package
print("MetaTrader5 package author: ",mt5.__author__)
print("MetaTrader5 package version: ",mt5.__version__)
# import the 'pandas' module for displaying data obtained in the tabular form
import pandas as pd
pd.set_option('display.max_columns', 500) # number of columns to be displayed
pd.set_option('display.width', 1500) # max table width to display
# import pytz module for working with time zone
import pytz
# establish connection to MetaTrader 5 terminal
if not mt5.initialize():
print("initialize() failed, error code =",mt5.last_error())
quit()
# set time zone to UTC
timezone = pytz.timezone("Etc/UTC")
# create 'datetime' object in UTC time zone to avoid the implementation of a local time zone offset
utc_from = datetime(2020, 1, 10, tzinfo=timezone)
# get 10 EURUSD H4 bars starting from 01.10.2020 in UTC time zone
rates = mt5.copy_rates_from("EURUSD", mt5.TIMEFRAME_H4, utc_from, 10)
# shut down connection to the MetaTrader 5 terminal
mt5.shutdown()
# display each element of obtained data in a new line
print("Display obtained data 'as is'")
for rate in rates:
print(rate)
# create DataFrame out of the obtained data
rates_frame = pd.DataFrame(rates)
# convert time in seconds into the datetime format
rates_frame['time']=pd.to_datetime(rates_frame['time'], unit='s')
# display data
print("\nDisplay dataframe with data")
print(rates_frame)
```
## Result:
```
MetaTrader5 package author: MetaQuotes Software Corp.
MetaTrader5 package version: 5.0.29
Display obtained data 'as is'
(1578484800, 1.11382, 1.11385, 1.1111, 1.11199, 9354, 1, 0)
(1578499200, 1.11199, 1.11308, 1.11086, 1.11179, 10641, 1, 0)
(1578513600, 1.11178, 1.11178, 1.11016, 1.11053, 4806, 1, 0)
(1578528000, 1.11053, 1.11193, 1.11033, 1.11173, 3480, 1, 0)
(1578542400, 1.11173, 1.11189, 1.11126, 1.11182, 2236, 1, 0)
(1578556800, 1.11181, 1.11203, 1.10983, 1.10993, 7984, 1, 0)
(1578571200, 1.10994, 1.11173, 1.10965, 1.11148, 7406, 1, 0)
(1578585600, 1.11149, 1.11149, 1.10923, 1.11046, 7468, 1, 0)
(1578600000, 1.11046, 1.11097, 1.11033, 1.11051, 3450, 1, 0)
(1578614400, 1.11051, 1.11093, 1.11017, 1.11041, 2448, 1, 0)
Display dataframe with data
time open high low close tick_volume spread real_volume
0 2020-01-08 12:00:00 1.11382 1.11385 1.11110 1.11199 9354 1 0
1 2020-01-08 16:00:00 1.11199 1.11308 1.11086 1.11179 10641 1 0
2 2020-01-08 20:00:00 1.11178 1.11178 1.11016 1.11053 4806 1 0
3 2020-01-09 00:00:00 1.11053 1.11193 1.11033 1.11173 3480 1 0
4 2020-01-09 04:00:00 1.11173 1.11189 1.11126 1.11182 2236 1 0
5 2020-01-09 08:00:00 1.11181 1.11203 1.10983 1.10993 7984 1 0
6 2020-01-09 12:00:00 1.10994 1.11173 1.10965 1.11148 7406 1 0
7 2020-01-09 16:00:00 1.11149 1.11149 1.10923 1.11046 7468 1 0
8 2020-01-09 20:00:00 1.11046 1.11097 1.11033 1.11051 3450 1 0
9 2020-01-10 00:00:00 1.11051 1.11093 1.11017 1.11041 2448 1 0
```
## See also
`CopyRates`, `copy_rates_from_pos`, `copy_rates_range`, `copy_ticks_from`, `copy_ticks_range`
'''
code=f'mt5.copy_rates_from("{symbol}", {timeframe}, {repr(date_from.astimezone())}, {count})'
return rpyc.classic.obtain(self.__conn.eval(code))
def copy_rates_from_pos(self,symbol,timeframe,start_pos,count):
r'''
# copy_rates_from_pos
Get bars from the MetaTrader 5 terminal starting from the specified index.
```python
copy_rates_from_pos(
symbol, # symbol name
timeframe, # timeframe
start_pos, # initial bar index
count # number of bars
)
```
## Parameters
- symbol
[in] Financial instrument name, for example, "EURUSD". Required unnamed parameter.
- timeframe
[in] Timeframe the bars are requested for. Set by a value from the TIMEFRAME enumeration. Required unnamed parameter.
- start_pos
[in] Initial index of the bar the data are requested from. The numbering of bars goes from present to past. Thus, the zero bar means the current one. Required unnamed parameter.
- count
[in] Number of bars to receive. Required unnamed parameter.
## Return Value
Returns bars as the numpy array with the named time, open, high, low, close, tick_volume, spread and real_volume columns. Returns None in case of an error. The info on the error can be obtained using `last_error()`.
## Note
See the `CopyRates()` function for more information.
MetaTrader 5 terminal provides bars only within a history available to a user on charts. The number of bars available to users is set in the "Max. bars in chart" parameter.
## Example:
```python
from datetime import datetime
import MetaTrader5 as mt5
# display data on the MetaTrader 5 package
print("MetaTrader5 package author: ",mt5.__author__)
print("MetaTrader5 package version: ",mt5.__version__)
# import the 'pandas' module for displaying data obtained in the tabular form
import pandas as pd
pd.set_option('display.max_columns', 500) # number of columns to be displayed
pd.set_option('display.width', 1500) # max table width to display
# establish connection to MetaTrader 5 terminal
if not mt5.initialize():
print("initialize() failed, error code =",mt5.last_error())
quit()
# get 10 GBPUSD D1 bars from the current day
rates = mt5.copy_rates_from_pos("GBPUSD", mt5.TIMEFRAME_D1, 0, 10)
# shut down connection to the MetaTrader 5 terminal
mt5.shutdown()
# display each element of obtained data in a new line
print("Display obtained data 'as is'")
for rate in rates:
print(rate)
# create DataFrame out of the obtained data
rates_frame = pd.DataFrame(rates)
# convert time in seconds into the datetime format
rates_frame['time']=pd.to_datetime(rates_frame['time'], unit='s')
# display data
print("\nDisplay dataframe with data")
print(rates_frame)
```
## Result:
```
MetaTrader5 package author: MetaQuotes Software Corp.
MetaTrader5 package version: 5.0.29
Display obtained data 'as is'
(1581552000, 1.29568, 1.30692, 1.29441, 1.30412, 68228, 0, 0)
(1581638400, 1.30385, 1.30631, 1.3001, 1.30471, 56498, 0, 0)
(1581897600, 1.30324, 1.30536, 1.29975, 1.30039, 49400, 0, 0)
(1581984000, 1.30039, 1.30486, 1.29705, 1.29952, 62288, 0, 0)
(1582070400, 1.29952, 1.3023, 1.29075, 1.29187, 57909, 0, 0)
(1582156800, 1.29186, 1.29281, 1.28489, 1.28792, 61033, 0, 0)
(1582243200, 1.28802, 1.29805, 1.28746, 1.29566, 66386, 0, 0)
(1582502400, 1.29426, 1.29547, 1.28865, 1.29283, 66933, 0, 0)
(1582588800, 1.2929, 1.30178, 1.29142, 1.30037, 80121, 0, 0)
(1582675200, 1.30036, 1.30078, 1.29136, 1.29374, 49286, 0, 0)
Display dataframe with data
time open high low close tick_volume spread real_volume
0 2020-02-13 1.29568 1.30692 1.29441 1.30412 68228 0 0
1 2020-02-14 1.30385 1.30631 1.30010 1.30471 56498 0 0
2 2020-02-17 1.30324 1.30536 1.29975 1.30039 49400 0 0
3 2020-02-18 1.30039 1.30486 1.29705 1.29952 62288 0 0
4 2020-02-19 1.29952 1.30230 1.29075 1.29187 57909 0 0
5 2020-02-20 1.29186 1.29281 1.28489 1.28792 61033 0 0
6 2020-02-21 1.28802 1.29805 1.28746 1.29566 66386 0 0
7 2020-02-24 1.29426 1.29547 1.28865 1.29283 66933 0 0
8 2020-02-25 1.29290 1.30178 1.29142 1.30037 80121 0 0
9 2020-02-26 1.30036 1.30078 1.29136 1.29374 49286 0 0
```
## See also
`CopyRates`, `copy_rates_from`, `copy_rates_range`, `copy_ticks_from`, `copy_ticks_range`
'''
code=f'mt5.copy_rates_from_pos("{symbol}",{timeframe},{start_pos},{count})'
return rpyc.utils.classic.obtain(self.__conn.eval(code))
def copy_rates_range(self,symbol, timeframe, date_from, date_to):
r'''
# copy_rates_range
Get bars in the specified date range from the MetaTrader 5 terminal.
```python
copy_rates_range(
symbol, # symbol name
timeframe, # timeframe
date_from, # date the bars are requested from
date_to # date, up to which the bars are requested
)
```
## Parameters
- symbol
[in] Financial instrument name, for example, "EURUSD". Required unnamed parameter.
- timeframe
[in] Timeframe the bars are requested for. Set by a value from the TIMEFRAME enumeration. Required unnamed parameter.
- date_from
[in] Date the bars are requested from. Set by the 'datetime' object or as a number of seconds elapsed since 1970.01.01. Bars with the open time >= date_from are returned. Required unnamed parameter.
- date_to
[in] Date, up to which the bars are requested. Set by the 'datetime' object or as a number of seconds elapsed since 1970.01.01. Bars with the open time <= date_to are returned. Required unnamed parameter.
## Return Value
Returns bars as the numpy array with the named time, open, high, low, close, tick_volume, spread and real_volume columns. Returns None in case of an error. The info on the error can be obtained using `last_error()`.
## Note
See the `CopyRates()` function for more information.
MetaTrader 5 terminal provides bars only within a history available to a user on charts. The number of bars available to users is set in the "Max. bars in chart" parameter.
When creating the 'datetime' object, Python uses the local time zone, while MetaTrader 5 stores tick and bar open time in UTC time zone (without the shift). Therefore, 'datetime' should be created in UTC time for executing functions that use time. Data received from the MetaTrader 5 terminal has UTC time.
## Example:
```python
from datetime import datetime
import MetaTrader5 as mt5
# display data on the MetaTrader 5 package
print("MetaTrader5 package author: ",mt5.__author__)
print("MetaTrader5 package version: ",mt5.__version__)
# import the 'pandas' module for displaying data obtained in the tabular form
import pandas as pd
pd.set_option('display.max_columns', 500) # number of columns to be displayed
pd.set_option('display.width', 1500) # max table width to display
# import pytz module for working with time zone
import pytz
# establish connection to MetaTrader 5 terminal
if not mt5.initialize():
print("initialize() failed, error code =",mt5.last_error())
quit()
# set time zone to UTC
timezone = pytz.timezone("Etc/UTC")
# create 'datetime' objects in UTC time zone to avoid the implementation of a local time zone offset
utc_from = datetime(2020, 1, 10, tzinfo=timezone)
utc_to = datetime(2020, 1, 11, hour = 13, tzinfo=timezone)
# get bars from USDJPY M5 within the interval of 2020.01.10 00:00 - 2020.01.11 13:00 in UTC time zone
rates = mt5.copy_rates_range("USDJPY", mt5.TIMEFRAME_M5, utc_from, utc_to)
# shut down connection to the MetaTrader 5 terminal
mt5.shutdown()
# display each element of obtained data in a new line
print("Display obtained data 'as is'")
counter=0
for rate in rates:
counter+=1
if counter<=10:
print(rate)
# create DataFrame out of the obtained data
rates_frame = pd.DataFrame(rates)
# convert time in seconds into the 'datetime' format
rates_frame['time']=pd.to_datetime(rates_frame['time'], unit='s')
# display data
print("\nDisplay dataframe with data")
print(rates_frame.head(10))
```
## Result:
```
MetaTrader5 package author: MetaQuotes Software Corp.
MetaTrader5 package version: 5.0.29
Display obtained data 'as is'
(1578614400, 109.513, 109.527, 109.505, 109.521, 43, 2, 0)
(1578614700, 109.521, 109.549, 109.518, 109.543, 215, 8, 0)
(1578615000, 109.543, 109.543, 109.466, 109.505, 98, 10, 0)
(1578615300, 109.504, 109.534, 109.502, 109.517, 155, 8, 0)
(1578615600, 109.517, 109.539, 109.513, 109.527, 71, 4, 0)
(1578615900, 109.526, 109.537, 109.484, 109.52, 106, 9, 0)
(1578616200, 109.52, 109.524, 109.508, 109.51, 205, 7, 0)
(1578616500, 109.51, 109.51, 109.491, 109.496, 44, 8, 0)
(1578616800, 109.496, 109.509, 109.487, 109.5, 85, 5, 0)
(1578617100, 109.5, 109.504, 109.487, 109.489, 82, 7, 0)
Display dataframe with data
time open high low close tick_volume spread real_volume
0 2020-01-10 00:00:00 109.513 109.527 109.505 109.521 43 2 0
1 2020-01-10 00:05:00 109.521 109.549 109.518 109.543 215 8 0
2 2020-01-10 00:10:00 109.543 109.543 109.466 109.505 98 10 0
3 2020-01-10 00:15:00 109.504 109.534 109.502 109.517 155 8 0
4 2020-01-10 00:20:00 109.517 109.539 109.513 109.527 71 4 0
5 2020-01-10 00:25:00 109.526 109.537 109.484 109.520 106 9 0
6 2020-01-10 00:30:00 109.520 109.524 109.508 109.510 205 7 0
7 2020-01-10 00:35:00 109.510 109.510 109.491 109.496 44 8 0
8 2020-01-10 00:40:00 109.496 109.509 109.487 109.500 85 5 0
9 2020-01-10 00:45:00 109.500 109.504 109.487 109.489 82 7 0
```
## See also
`CopyRates`, `copy_rates_from`, `copy_rates_range`, `copy_ticks_from`, `copy_ticks_range`
'''
code=f'mt5.copy_rates_range("{symbol}", {timeframe}, {repr(date_from.astimezone())}, {date_to})'
return rpyc.utils.classic.obtain(self.__conn.eval(code))
def copy_ticks_from(self,symbol, date_from, count, flags):
r'''
# copy_ticks_from
Get ticks from the MetaTrader 5 terminal starting from the specified date.
```python
copy_ticks_from(
symbol, # symbol name
date_from, # date the ticks are requested from
count, # number of requested ticks
flags # combination of flags defining the type of requested ticks
)
```
## Parameters
- symbol
[in] Financial instrument name, for example, "EURUSD". Required unnamed parameter.
- from
[in] Date the ticks are requested from. Set by the 'datetime' object or as a number of seconds elapsed since 1970.01.01. Required unnamed parameter.
- count
[in] Number of ticks to receive. Required unnamed parameter.
- flags
[in] A flag to define the type of the requested ticks. COPY_TICKS_INFO – ticks with Bid and/or Ask changes, COPY_TICKS_TRADE – ticks with changes in Last and Volume, COPY_TICKS_ALL – all ticks. Flag values are described in the COPY_TICKS enumeration. Required unnamed parameter.
## Return Value
Returns ticks as the numpy array with the named time, bid, ask, last and flags columns. The 'flags' value can be a combination of flags from the TICK_FLAG enumeration. Return None in case of an error. The info on the error can be obtained using `last_error()`.
## Note
See the CopyTicks function for more information.
When creating the 'datetime' object, Python uses the local time zone, while MetaTrader 5 stores tick and bar open time in UTC time zone (without the shift). Therefore, 'datetime' should be created in UTC time for executing functions that use time. Data received from the MetaTrader 5 terminal has UTC time.
COPY_TICKS defines the types of ticks that can be requested using the `copy_ticks_from()` and `copy_ticks_range()` functions.
| ID | Description |
|------------------|---------------------------------------------------|
| COPY_TICKS_ALL | all ticks |
| COPY_TICKS_INFO | ticks containing Bid and/or Ask price changes |
| COPY_TICKS_TRADE | ticks containing Last and/or Volume price changes |
TICK_FLAG defines possible flags for ticks. These flags are used to describe ticks obtained by the `copy_ticks_from()` and `copy_ticks_range()` functions.
| ID | Description |
|------------------|-------------------------|
| TICK_FLAG_BID | Bid price changed |
| TICK_FLAG_ASK | Ask price changed |
| TICK_FLAG_LAST | Last price changed |
| TICK_FLAG_VOLUME | Volume changed |
| TICK_FLAG_BUY | last Buy price changed |
| TICK_FLAG_SELL | last Sell price changed |
## Example:
```python
from datetime import datetime
import MetaTrader5 as mt5
# display data on the MetaTrader 5 package
print("MetaTrader5 package author: ",mt5.__author__)
print("MetaTrader5 package version: ",mt5.__version__)
# import the 'pandas' module for displaying data obtained in the tabular form
import pandas as pd
pd.set_option('display.max_columns', 500) # number of columns to be displayed
pd.set_option('display.width', 1500) # max table width to display
# import pytz module for working with time zone
import pytz
# establish connection to MetaTrader 5 terminal
if not mt5.initialize():
print("initialize() failed, error code =",mt5.last_error())
quit()
# set time zone to UTC
timezone = pytz.timezone("Etc/UTC")
# create 'datetime' object in UTC time zone to avoid the implementation of a local time zone offset
utc_from = datetime(2020, 1, 10, tzinfo=timezone)
# request 100 000 EURUSD ticks starting from 10.01.2019 in UTC time zone
ticks = mt5.copy_ticks_from("EURUSD", utc_from, 100000, mt5.COPY_TICKS_ALL)
print("Ticks received:",len(ticks))
# shut down connection to the MetaTrader 5 terminal
mt5.shutdown()
# display data on each tick on a new line
print("Display obtained ticks 'as is'")
count = 0
for tick in ticks:
count+=1
print(tick)
if count >= 10:
break
# create DataFrame out of the obtained data
ticks_frame = pd.DataFrame(ticks)
# convert time in seconds into the datetime format
ticks_frame['time']=pd.to_datetime(ticks_frame['time'], unit='s')
# display data
print("\nDisplay dataframe with ticks")
print(ticks_frame.head(10))
```
## Result:
```
MetaTrader5 package author: MetaQuotes Software Corp.
MetaTrader5 package version: 5.0.29
Ticks received: 100000
Display obtained ticks 'as is'
(1578614400, 1.11051, 1.11069, 0., 0, 1578614400987, 134, 0.)
(1578614402, 1.11049, 1.11067, 0., 0, 1578614402025, 134, 0.)
(1578614404, 1.1105, 1.11066, 0., 0, 1578614404057, 134, 0.)
(1578614404, 1.11049, 1.11067, 0., 0, 1578614404344, 134, 0.)
(1578614412, 1.11052, 1.11064, 0., 0, 1578614412106, 134, 0.)
(1578614418, 1.11039, 1.11051, 0., 0, 1578614418265, 134, 0.)
(1578614418, 1.1104, 1.1105, 0., 0, 1578614418905, 134, 0.)
(1578614419, 1.11039, 1.11051, 0., 0, 1578614419519, 134, 0.)
(1578614456, 1.11037, 1.11065, 0., 0, 1578614456011, 134, 0.)
(1578614456, 1.11039, 1.11051, 0., 0, 1578614456015, 134, 0.)
Display dataframe with ticks
time bid ask last volume time_msc flags volume_real
0 2020-01-10 00:00:00 1.11051 1.11069 0.0 0 1578614400987 134 0.0
1 2020-01-10 00:00:02 1.11049 1.11067 0.0 0 1578614402025 134 0.0
2 2020-01-10 00:00:04 1.11050 1.11066 0.0 0 1578614404057 134 0.0
3 2020-01-10 00:00:04 1.11049 1.11067 0.0 0 1578614404344 134 0.0
4 2020-01-10 00:00:12 1.11052 1.11064 0.0 0 1578614412106 134 0.0
5 2020-01-10 00:00:18 1.11039 1.11051 0.0 0 1578614418265 134 0.0
6 2020-01-10 00:00:18 1.11040 1.11050 0.0 0 1578614418905 134 0.0
7 2020-01-10 00:00:19 1.11039 1.11051 0.0 0 1578614419519 134 0.0
8 2020-01-10 00:00:56 1.11037 1.11065 0.0 0 1578614456011 134 0.0
9 2020-01-10 00:00:56 1.11039 1.11051 0.0 0 1578614456015 134 0.0
```
## See also
`CopyRates`, `copy_rates_from_pos`, `copy_rates_range`, `copy_ticks_from`, `copy_ticks_range`
'''
code=f'mt5.copy_ticks_from("{symbol}", {repr(date_from.astimezone())}, {count}, {flags})'
return rpyc.utils.classic.obtain(self.__conn.eval(code))
def copy_ticks_range(self,symbol, date_from, date_to, flags):
r'''
# copy_ticks_range
Get ticks for the specified date range from the MetaTrader 5 terminal.
```python
copy_ticks_range(
symbol, # symbol name
date_from, # date the ticks are requested from
date_to, # date, up to which the ticks are requested
flags # combination of flags defining the type of requested ticks
)
```
## Parameters
- symbol
[in] Financial instrument name, for example, "EURUSD". Required unnamed parameter.
- date_from
[in] Date the ticks are requested from. Set by the 'datetime' object or as a number of seconds elapsed since 1970.01.01. Required unnamed parameter.
- date_to
[in] Date, up to which the ticks are requested. Set by the 'datetime' object or as a number of seconds elapsed since 1970.01.01. Required unnamed parameter.
- flags
[in] A flag to define the type of the requested ticks. COPY_TICKS_INFO – ticks with Bid and/or Ask changes, COPY_TICKS_TRADE – ticks with changes in Last and Volume, COPY_TICKS_ALL – all ticks. Flag values are described in the COPY_TICKS enumeration. Required unnamed parameter.
## Return Value
Returns ticks as the numpy array with the named time, bid, ask, last and flags columns. The 'flags' value can be a combination of flags from the TICK_FLAG enumeration. Return None in case of an error. The info on the error can be obtained using `last_error()`.
## Note
See the CopyTicks function for more information.
When creating the 'datetime' object, Python uses the local time zone, while MetaTrader 5 stores tick and bar open time in UTC time zone (without the shift). Therefore, 'datetime' should be created in UTC time for executing functions that use time. The data obtained from MetaTrader 5 have UTC time, but Python applies the local time shift again when trying to print them. Thus, the obtained data should also be corrected for visual presentation.
## Example:
```python
from datetime import datetime
import MetaTrader5 as mt5
# display data on the MetaTrader 5 package
print("MetaTrader5 package author: ",mt5.__author__)
print("MetaTrader5 package version: ",mt5.__version__)
# import the 'pandas' module for displaying data obtained in the tabular form
import pandas as pd
pd.set_option('display.max_columns', 500) # number of columns to be displayed
pd.set_option('display.width', 1500) # max table width to display
# import pytz module for working with time zone
import pytz
# establish connection to MetaTrader 5 terminal
if not mt5.initialize():
print("initialize() failed, error code =",mt5.last_error())
quit()
# set time zone to UTC
timezone = pytz.timezone("Etc/UTC")
# create 'datetime' objects in UTC time zone to avoid the implementation of a local time zone offset
utc_from = datetime(2020, 1, 10, tzinfo=timezone)
utc_to = datetime(2020, 1, 11, tzinfo=timezone)
# request AUDUSD ticks within 11.01.2020 - 11.01.2020
ticks = mt5.copy_ticks_range("AUDUSD", utc_from, utc_to, mt5.COPY_TICKS_ALL)
print("Ticks received:",len(ticks))
# shut down connection to the MetaTrader 5 terminal
mt5.shutdown()
# display data on each tick on a new line
print("Display obtained ticks 'as is'")
count = 0
for tick in ticks:
count+=1
print(tick)
if count >= 10:
break
# create DataFrame out of the obtained data
ticks_frame = pd.DataFrame(ticks)
# convert time in seconds into the datetime format
ticks_frame['time']=pd.to_datetime(ticks_frame['time'], unit='s')
# display data
print("\nDisplay dataframe with ticks")
print(ticks_frame.head(10))
```
## Result:
```
MetaTrader5 package author: MetaQuotes Software Corp.
MetaTrader5 package version: 5.0.29
Ticks received: 37008
Display obtained ticks 'as is'
(1578614400, 0.68577, 0.68594, 0., 0, 1578614400820, 134, 0.)
(1578614401, 0.68578, 0.68594, 0., 0, 1578614401128, 130, 0.)
(1578614401, 0.68575, 0.68594, 0., 0, 1578614401128, 130, 0.)
(1578614411, 0.68576, 0.68594, 0., 0, 1578614411388, 130, 0.)
(1578614411, 0.68575, 0.68594, 0., 0, 1578614411560, 130, 0.)
(1578614414, 0.68576, 0.68595, 0., 0, 1578614414973, 134, 0.)
(1578614430, 0.68576, 0.68594, 0., 0, 1578614430188, 4, 0.)
(1578614450, 0.68576, 0.68595, 0., 0, 1578614450408, 4, 0.)
(1578614450, 0.68576, 0.68594, 0., 0, 1578614450519, 4, 0.)
(1578614456, 0.68575, 0.68594, 0., 0, 1578614456363, 130, 0.)
Display dataframe with ticks
time bid ask last volume time_msc flags volume_real
0 2020-01-10 00:00:00 0.68577 0.68594 0.0 0 1578614400820 134 0.0
1 2020-01-10 00:00:01 0.68578 0.68594 0.0 0 1578614401128 130 0.0
2 2020-01-10 00:00:01 0.68575 0.68594 0.0 0 1578614401128 130 0.0
3 2020-01-10 00:00:11 0.68576 0.68594 0.0 0 1578614411388 130 0.0
4 2020-01-10 00:00:11 0.68575 0.68594 0.0 0 1578614411560 130 0.0
5 2020-01-10 00:00:14 0.68576 0.68595 0.0 0 1578614414973 134 0.0
6 2020-01-10 00:00:30 0.68576 0.68594 0.0 0 1578614430188 4 0.0
7 2020-01-10 00:00:50 0.68576 0.68595 0.0 0 1578614450408 4 0.0
8 2020-01-10 00:00:50 0.68576 0.68594 0.0 0 1578614450519 4 0.0
9 2020-01-10 00:00:56 0.68575 0.68594 0.0 0 1578614456363 130 0.0
```
## See also
`CopyRates`, `copy_rates_from_pos`, `copy_rates_range`, `copy_ticks_from`, `copy_ticks_range`
'''
code=f'mt5.copy_ticks_range("{symbol}", {repr(date_from.astimezone())}, {repr(date_to.astimezone())}, {flags})'
return rpyc.utils.classic.obtain(self.__conn.eval(code))
def orders_total(self,*args,**kwargs):
r'''
# orders_total
Get the number of active orders.
```python
orders_total()
```
## Return Value
Integer value.
## Note
The function is similar to `OrdersTotal`.
## Example:
```python
import MetaTrader5 as mt5
# display data on the MetaTrader 5 package
print("MetaTrader5 package author: ",mt5.__author__)
print("MetaTrader5 package version: ",mt5.__version__)
# establish connection to MetaTrader 5 terminal
if not mt5.initialize():
print("initialize() failed, error code =",mt5.last_error())
quit()
# check the presence of active orders
orders=mt5.orders_total()
if orders>0:
print("Total orders=",orders)
else:
print("Orders not found")
# shut down connection to the MetaTrader 5 terminal
mt5.shutdown()
```
## See also
`orders_get`, `positions_total`
'''
code=f'mt5.orders_total(*{args},**{kwargs})'
return self.__conn.eval(code)
def orders_get(self,*args,**kwargs):
r'''
# orders_get
Get active orders with the ability to filter by symbol or ticket. There are three call options.
Call without parameters. Return active orders on all symbols.
```python
orders_get()
```
Call specifying a symbol active orders should be received for.
```python
orders_get(
symbol="SYMBOL" # symbol name
)
```
Call specifying a group of symbols active orders should be received for.
```python
orders_get(
group="GROUP" # filter for selecting orders for symbols
)
```
Call specifying the order ticket.
```python
orders_get(
ticket=TICKET # ticket
)
```
- symbol="SYMBOL"
[in] Symbol name. Optional named parameter. If a symbol is specified, the ticket parameter is ignored.
- group="GROUP"
[in] The filter for arranging a group of necessary symbols. Optional named parameter. If the group is specified, the function returns only active orders meeting a specified criteria for a symbol name.
- ticket=TICKET
[in] Order ticket (ORDER_TICKET). Optional named parameter.
## Return Value
Return info in the form of a named tuple structure (namedtuple). Return None in case of an error. The info on the error can be obtained using `last_error()`.
## Note
The function allows receiving all active orders within one call similar to the OrdersTotal and OrderSelect tandem.
The group parameter allows sorting out orders by symbols. '*' can be used at the beginning and the end of a string.
The group parameter may contain several comma separated conditions. A condition can be set as a mask using '*'. The logical negation symbol '!' can be used for an exclusion. All conditions are applied sequentially, which means conditions of including to a group should be specified first followed by an exclusion condition. For example, group="*, !EUR" means that orders for all symbols should be selected first and the ones containing "EUR" in symbol names should be excluded afterwards.
## Example:
```python
import MetaTrader5 as mt5
import pandas as pd
pd.set_option('display.max_columns', 500) # number of columns to be displayed
pd.set_option('display.width', 1500) # max table width to display
# display data on the MetaTrader 5 package
print("MetaTrader5 package author: ",mt5.__author__)
print("MetaTrader5 package version: ",mt5.__version__)
print()
# establish connection to the MetaTrader 5 terminal
if not mt5.initialize():
print("initialize() failed, error code =",mt5.last_error())
quit()
# display data on active orders on GBPUSD
orders=mt5.orders_get(symbol="GBPUSD")
if orders is None:
print("No orders on GBPUSD, error code={}".format(mt5.last_error()))
else:
print("Total orders on GBPUSD:",len(orders))
# display all active orders
for order in orders:
print(order)
print()
# get the list of orders on symbols whose names contain "*GBP*"
gbp_orders=mt5.orders_get(group="*GBP*")
if gbp_orders is None:
print("No orders with group=\"*GBP*\", error code={}".format(mt5.last_error()))
else:
print("orders_get(group=\"*GBP*\")={}".format(len(gbp_orders)))
# display these orders as a table using pandas.DataFrame
df=pd.DataFrame(list(gbp_orders),columns=gbp_orders[0]._asdict().keys())
df.drop(['time_done', 'time_done_msc', 'position_id', 'position_by_id', 'reason', 'volume_initial', 'price_stoplimit'], axis=1, inplace=True)
df['time_setup'] = pd.to_datetime(df['time_setup'], unit='s')
print(df)
# shut down connection to the MetaTrader 5 terminal
mt5.shutdown()
```
## Result:
```
MetaTrader5 package author: MetaQuotes Software Corp.
MetaTrader5 package version: 5.0.29
Total orders on GBPUSD: 2
TradeOrder(ticket=554733548, time_setup=1585153667, time_setup_msc=1585153667718, time_done=0, time_done_msc=0, time_expiration=0, type=3, type_time=0, ...
TradeOrder(ticket=554733621, time_setup=1585153671, time_setup_msc=1585153671419, time_done=0, time_done_msc=0, time_expiration=0, type=2, type_time=0, ...
orders_get(group="*GBP*")=4
ticket time_setup time_setup_msc time_expiration type type_time type_filling state magic volume_current price_open sl tp price_current symbol comment external_id
0 554733548 2020-03-25 16:27:47 1585153667718 0 3 0 2 1 0 0.2 1.25379 0.0 0.0 1.16803 GBPUSD
1 554733621 2020-03-25 16:27:51 1585153671419 0 2 0 2 1 0 0.2 1.14370 0.0 0.0 1.16815 GBPUSD
2 554746664 2020-03-25 16:38:14 1585154294401 0 3 0 2 1 0 0.2 0.93851 0.0 0.0 0.92428 EURGBP
3 554746710 2020-03-25 16:38:17 1585154297022 0 2 0 2 1 0 0.2 0.90527 0.0 0.0 0.92449 EURGBP
```
## See also
`orders_total`, `positions_get`
'''
code=f'mt5.orders_get(*{args},**{kwargs})'
return self.__conn.eval(code)
def order_calc_margin(self,*args,**kwargs):
r'''
# order_calc_margin
Return margin in the account currency to perform a specified trading operation.
```python
order_calc_margin(
action, # order type (ORDER_TYPE_BUY or ORDER_TYPE_SELL)
symbol, # symbol name
volume, # volume
price # open price
)
```
## Parameters
- action
[in] Order type taking values from the `ORDER_TYPE` enumeration. Required unnamed parameter.
- symbol
[in] Financial instrument name. Required unnamed parameter.
- volume
[in] Trading operation volume. Required unnamed parameter.
- price
[in] Open price. Required unnamed parameter.
## Return Value
Real value if successful, otherwise None. The error info can be obtained using `last_error()`.
## Note
The function allows estimating the margin necessary for a specified order type on the current account and in the current market environment without considering the current pending orders and open positions. The function is similar to `OrderCalcMargin`.
| ID | Description |
|----------------------------|--------------------------------------------------------------------------------------|
| ORDER_TYPE_BUY | Market buy order |
| ORDER_TYPE_SELL | Market sell order |
| ORDER_TYPE_BUY_LIMIT | Buy Limit pending order |
| ORDER_TYPE_SELL_LIMIT | Sell Limit pending order |
| ORDER_TYPE_BUY_STOP | Buy Stop pending order |
| ORDER_TYPE_SELL_STOP | Sell Stop pending order |
| ORDER_TYPE_BUY_STOP_LIMIT | Upon reaching the order price, Buy Limit pending order is placed at StopLimit price |
| ORDER_TYPE_SELL_STOP_LIMIT | Upon reaching the order price, Sell Limit pending order is placed at StopLimit price |
| ORDER_TYPE_CLOSE_BY | Order for closing a position by an opposite one |
## Example:
```python
import MetaTrader5 as mt5
# display data on the MetaTrader 5 package
print("MetaTrader5 package author: ",mt5.__author__)
print("MetaTrader5 package version: ",mt5.__version__)
# establish connection to MetaTrader 5 terminal
if not mt5.initialize():
print("initialize() failed, error code =",mt5.last_error())
quit()
# get account currency
account_currency=mt5.account_info().currency
print("Account сurrency:",account_currency)
# arrange the symbol list
symbols=("EURUSD","GBPUSD","USDJPY", "USDCHF","EURJPY","GBPJPY")
print("Symbols to check margin:", symbols)
action=mt5.ORDER_TYPE_BUY
lot=0.1
for symbol in symbols:
symbol_info=mt5.symbol_info(symbol)
if symbol_info is None:
print(symbol,"not found, skipped")
continue
if not symbol_info.visible:
print(symbol, "is not visible, trying to switch on")
if not mt5.symbol_select(symbol,True):
print("symbol_select({}}) failed, skipped",symbol)
continue
ask=mt5.symbol_info_tick(symbol).ask
margin=mt5.order_calc_margin(action,symbol,lot,ask)
if margin != None:
print(" {} buy {} lot margin: {} {}".format(symbol,lot,margin,account_currency));
else:
print("order_calc_margin failed: , error code =", mt5.last_error())
# shut down connection to the MetaTrader 5 terminal
mt5.shutdown()
```
## Result:
```
MetaTrader5 package author: MetaQuotes Software Corp.
MetaTrader5 package version: 5.0.29
Account сurrency: USD
Symbols to check margin: ('EURUSD', 'GBPUSD', 'USDJPY', 'USDCHF', 'EURJPY', 'GBPJPY')
EURUSD buy 0.1 lot margin: 109.91 USD
GBPUSD buy 0.1 lot margin: 122.73 USD
USDJPY buy 0.1 lot margin: 100.0 USD
USDCHF buy 0.1 lot margin: 100.0 USD
EURJPY buy 0.1 lot margin: 109.91 USD
GBPJPY buy 0.1 lot margin: 122.73 USD
```
## See also
`order_calc_profit`, `order_check`
'''
code=f'mt5.order_calc_margin(*{args},**{kwargs})'
return self.__conn.eval(code)
def order_calc_profit(self,*args,**kwargs):
r'''
# order_calc_profit
Return profit in the account currency for a specified trading operation.
```python
order_calc_profit(
action, # order type (ORDER_TYPE_BUY or ORDER_TYPE_SELL)
symbol, # symbol name
volume, # volume
price_open, # open price
price_close # close price
);
```
## Parameters
- action
[in] Order type may take one of the two `ORDER_TYPE` enumeration values: `ORDER_TYPE_BUY` or `ORDER_TYPE_SELL`. Required unnamed parameter.
- symbol
[in] Financial instrument name. Required unnamed parameter.
- volume
[in] Trading operation volume. Required unnamed parameter.
- price_open
[in] Open price. Required unnamed parameter.
- price_close
[in] Close price. Required unnamed parameter.
## Return Value
Real value if successful, otherwise None. The error info can be obtained using `last_error()`.
## Note
The function allows estimating a trading operation result on the current account and in the current trading environment. The function is similar to `OrderCalcProfit`.
## Example:
```python
import MetaTrader5 as mt5
# display data on the MetaTrader 5 package
print("MetaTrader5 package author: ",mt5.__author__)
print("MetaTrader5 package version: ",mt5.__version__)
# establish connection to MetaTrader 5 terminal
if not mt5.initialize():
print("initialize() failed, error code =",mt5.last_error())
quit()
# get account currency
account_currency=mt5.account_info().currency
print("Account сurrency:",account_currency)
# arrange the symbol list
symbols = ("EURUSD","GBPUSD","USDJPY")
print("Symbols to check margin:", symbols)
# estimate profit for buying and selling
lot=1.0
distance=300
for symbol in symbols:
symbol_info=mt5.symbol_info(symbol)
if symbol_info is None:
print(symbol,"not found, skipped")
continue
if not symbol_info.visible:
print(symbol, "is not visible, trying to switch on")
if not mt5.symbol_select(symbol,True):
print("symbol_select({}}) failed, skipped",symbol)
continue
point=mt5.symbol_info(symbol).point
symbol_tick=mt5.symbol_info_tick(symbol)
ask=symbol_tick.ask
bid=symbol_tick.bid
buy_profit=mt5.order_calc_profit(mt5.ORDER_TYPE_BUY,symbol,lot,ask,ask+distance*point)
if buy_profit!=None:
print(" buy {} {} lot: profit on {} points => {} {}".format(symbol,lot,distance,buy_profit,account_currency));
else:
print("order_calc_profit(ORDER_TYPE_BUY) failed, error code =",mt5.last_error())
sell_profit=mt5.order_calc_profit(mt5.ORDER_TYPE_SELL,symbol,lot,bid,bid-distance*point)
if sell_profit!=None:
print(" sell {} {} lots: profit on {} points => {} {}".format(symbol,lot,distance,sell_profit,account_currency));
else:
print("order_calc_profit(ORDER_TYPE_SELL) failed, error code =",mt5.last_error())
print()
# shut down connection to the MetaTrader 5 terminal
mt5.shutdown()
```
## Result:
```
MetaTrader5 package author: MetaQuotes Software Corp.
MetaTrader5 package version: 5.0.29
Account сurrency: USD
Symbols to check margin: ('EURUSD', 'GBPUSD', 'USDJPY')
buy EURUSD 1.0 lot: profit on 300 points => 300.0 USD
sell EURUSD 1.0 lot: profit on 300 points => 300.0 USD
buy GBPUSD 1.0 lot: profit on 300 points => 300.0 USD
sell GBPUSD 1.0 lot: profit on 300 points => 300.0 USD
buy USDJPY 1.0 lot: profit on 300 points => 276.54 USD
sell USDJPY 1.0 lot: profit on 300 points => 278.09 USD
```
## See also
`order_calc_margin`, `order_check`
'''
code=f'mt5.order_calc_profit(*{args},**{kwargs})'
return self.__conn.eval(code)
def order_check(self,*args,**kwargs):
r'''
# order_check
Check funds sufficiency for performing a required trading operation. Check result are returned as the MqlTradeCheckResult structure.
```python
order_check(
request # request structure
);
```
## Parameters
- request
[in] MqlTradeRequest type structure describing a required trading action. Required unnamed parameter. Example of filling in a request and the enumeration content are described below.
## Return Value
Check result as the `MqlTradeCheckResult` structure. The request field in the answer contains the structure of a trading request passed to `order_check()`.
## Note
Successful sending of a request does not entail that the requested trading operation will be executed successfully. The order_check function is similar to `OrderCheck`.
### TRADE_REQUEST_ACTIONS
| ID | Description |
|-----------------------|---------------------------------------------------------------------------------------|
| TRADE_ACTION_DEAL | Place an order for an instant deal with the specified parameters (set a market order) |
| TRADE_ACTION_PENDING | Place an order for performing a deal at specified conditions (pending order) |
| TRADE_ACTION_SLTP | Change open position Stop Loss and Take Profit |
| TRADE_ACTION_MODIFY | Change parameters of the previously placed trading order |
| TRADE_ACTION_REMOVE | Remove previously placed pending order |
| TRADE_ACTION_CLOSE_BY | Close a position by an opposite one |
### ORDER_TYPE_FILLING
| ID | Description |
|----------------------|------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| ORDER_FILLING_FOK | This execution policy means that an order can be executed only in the specified volume. If the necessary amount of a financial instrument is currently unavailable in the market, the order will not be executed. The desired volume can be made up of several available offers. |
| ORDER_FILLING_IOC | An agreement to execute a deal at the maximum volume available in the market within the volume specified in the order. If the request cannot be filled completely, an order with the available volume will be executed, and the remaining volume will be canceled. |
| ORDER_FILLING_RETURN | This policy is used only for market (ORDER_TYPE_BUY and ORDER_TYPE_SELL), limit and stop limit orders (ORDER_TYPE_BUY_LIMIT, ORDER_TYPE_SELL_LIMIT, ORDER_TYPE_BUY_STOP_LIMIT and ORDER_TYPE_SELL_STOP_LIMIT) and only for the symbols with Market or Exchange execution modes. If filled partially, a market or limit order with the remaining volume is not canceled, and is processed further. During activation of the ORDER_TYPE_BUY_STOP_LIMIT and ORDER_TYPE_SELL_STOP_LIMIT orders, an appropriate limit order ORDER_TYPE_BUY_LIMIT/ORDER_TYPE_SELL_LIMIT with the ORDER_FILLING_RETURN type is created. |
### ORDER_TYPE_TIME
| ID | Description |
|--------------------------|------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| ORDER_TIME_GTC | The order stays in the queue until it is manually canceled |
| ORDER_TIME_DAY | The order is active only during the current trading day |
| ORDER_TIME_SPECIFIED | The order is active until the specified date |
| ORDER_TIME_SPECIFIED_DAY | The order is active until 23:59:59 of the specified day. If this time appears to be out of a trading session, the expiration is processed at the nearest trading time. |
## Example:
```python
import MetaTrader5 as mt5
# display data on the MetaTrader 5 package
print("MetaTrader5 package author: ",mt5.__author__)
print("MetaTrader5 package version: ",mt5.__version__)
# establish connection to MetaTrader 5 terminal
if not mt5.initialize():
print("initialize() failed, error code =",mt5.last_error())
quit()
# get account currency
account_currency=mt5.account_info().currency
print("Account сurrency:",account_currency)
# prepare the request structure
symbol="USDJPY"
symbol_info = mt5.symbol_info(symbol)
if symbol_info is None:
print(symbol, "not found, can not call order_check()")
mt5.shutdown()
quit()
# if the symbol is unavailable in MarketWatch, add it
if not symbol_info.visible:
print(symbol, "is not visible, trying to switch on")
if not mt5.symbol_select(symbol,True):
print("symbol_select({}}) failed, exit",symbol)
mt5.shutdown()
quit()
# prepare the request
point=mt5.symbol_info(symbol).point
request = {
"action": mt5.TRADE_ACTION_DEAL,
"symbol": symbol,
"volume": 1.0,
"type": mt5.ORDER_TYPE_BUY,
"price": mt5.symbol_info_tick(symbol).ask,
"sl": mt5.symbol_info_tick(symbol).ask-100*point,
"tp": mt5.symbol_info_tick(symbol).ask+100*point,
"deviation": 10,
"magic": 234000,
"comment": "python script",
"type_time": mt5.ORDER_TIME_GTC,
"type_filling": mt5.ORDER_FILLING_RETURN,
}
# perform the check and display the result 'as is'
result = mt5.order_check(request)
print(result);
# request the result as a dictionary and display it element by element
result_dict=result._asdict()
for field in result_dict.keys():
print(" {}={}".format(field,result_dict[field]))
# if this is a trading request structure, display it element by element as well
if field=="request":
traderequest_dict=result_dict[field]._asdict()
for tradereq_filed in traderequest_dict:
print(" traderequest: {}={}".format(tradereq_filed,traderequest_dict[tradereq_filed]))
# shut down connection to the MetaTrader 5 terminal
mt5.shutdown()
```
## Result:
```
MetaTrader5 package author: MetaQuotes Software Corp.
MetaTrader5 package version: 5.0.29
Account сurrency: USD
retcode=0
balance=101300.53
equity=68319.53
profit=-32981.0
margin=51193.67
margin_free=17125.86
margin_level=133.45308121101692
comment=Done
request=TradeRequest(action=1, magic=234000, order=0, symbol='USDJPY', volume=1.0, ...
traderequest: action=1
traderequest: magic=234000
traderequest: order=0
traderequest: symbol=USDJPY
traderequest: volume=1.0
traderequest: price=108.081
traderequest: stoplimit=0.0
traderequest: sl=107.98100000000001
traderequest: tp=108.181
traderequest: deviation=10
traderequest: type=0
traderequest: type_filling=2
traderequest: type_time=0
traderequest: expiration=0
traderequest: comment=python script
traderequest: position=0
traderequest: position_by=0
```
## See also
`order_send`, `OrderCheck`, Trading operation types, Trading request structure, Structure of the trading request check results, Structure of the trading request result
'''
code=f'mt5.order_check(*{args},**{kwargs})'
return self.__conn.eval(code)
def order_send(self,request):
r'''
# order_send
Send a request to perform a trading operation from the terminal to the trade server. The function is similar to OrderSend.
```python
order_send(
request # request structure
);
```
## Parameters
request
[in] `MqlTradeRequest` type structure describing a required trading action. Required unnamed parameter. Example of filling in a request and the enumeration content are described below.
## Return Value
Execution result as the `MqlTradeResult` structure. The request field in the answer contains the structure of a trading request passed to `order_send()`.
The `MqlTradeRequest` trading request structure
| Field | Description |
|--------------|------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| action | Trading operation type. The value can be one of the values of the TRADE_REQUEST_ACTIONS enumeration |
| magic | EA ID. Allows arranging the analytical handling of trading orders. Each EA can set a unique ID when sending a trading request |
| order | Order ticket. Required for modifying pending orders |
| symbol | The name of the trading instrument, for which the order is placed. Not required when modifying orders and closing positions |
| volume | Requested volume of a deal in lots. A real volume when making a deal depends on an order execution type. |
| price | Price at which an order should be executed. The price is not set in case of market orders for instruments of the "Market Execution" (SYMBOL_TRADE_EXECUTION_MARKET) type having the TRADE_ACTION_DEAL type |
| stoplimit | A price a pending Limit order is set at when the price reaches the 'price' value (this condition is mandatory). The pending order is not passed to the trading system until that moment |
| sl | A price a Stop Loss order is activated at when the price moves in an unfavorable direction |
| tp | A price a Take Profit order is activated at when the price moves in a favorable direction |
| deviation | Maximum acceptable deviation from the requested price, specified in points |
| type | Order type. The value can be one of the values of the ORDER_TYPE enumeration |
| type_filling | Order filling type. The value can be one of the ORDER_TYPE_FILLING values |
| type_time | Order type by expiration. The value can be one of the ORDER_TYPE_TIME values |
| expiration | Pending order expiration time (for TIME_SPECIFIED type orders) |
| comment | Comment to an order |
| position | Position ticket. Fill it when changing and closing a position for its clear identification. Usually, it is the same as the ticket of the order that opened the position. |
| position_by | Opposite position ticket. It is used when closing a position by an opposite one (opened at the same symbol but in the opposite direction). |
## Note
A trading request passes several verification stages on the trade server. First, the validity of all the necessary request fields is checked. If there are no errors, the server accepts the order for further handling. See the OrderSend function description for the details about executing trading operations.
## Example:
```python
import time
import MetaTrader5 as mt5
# display data on the MetaTrader 5 package
print("MetaTrader5 package author: ", mt5.__author__)
print("MetaTrader5 package version: ", mt5.__version__)
# establish connection to the MetaTrader 5 terminal
if not mt5.initialize():
print("initialize() failed, error code =",mt5.last_error())
quit()
# prepare the buy request structure
symbol = "USDJPY"
symbol_info = mt5.symbol_info(symbol)
if symbol_info is None:
print(symbol, "not found, can not call order_check()")
mt5.shutdown()
quit()
# if the symbol is unavailable in MarketWatch, add it
if not symbol_info.visible:
print(symbol, "is not visible, trying to switch on")
if not mt5.symbol_select(symbol,True):
print("symbol_select({}}) failed, exit",symbol)
mt5.shutdown()
quit()
lot = 0.1
point = mt5.symbol_info(symbol).point
price = mt5.symbol_info_tick(symbol).ask
deviation = 20
request = {
"action": mt5.TRADE_ACTION_DEAL,
"symbol": symbol,
"volume": lot,
"type": mt5.ORDER_TYPE_BUY,
"price": price,
"sl": price - 100 * point,
"tp": price + 100 * point,
"deviation": deviation,
"magic": 234000,
"comment": "python script open",
"type_time": mt5.ORDER_TIME_GTC,
"type_filling": mt5.ORDER_FILLING_RETURN,
}
# send a trading request
result = mt5.order_send(request)
# check the execution result
print("1. order_send(): by {} {} lots at {} with deviation={} points".format(symbol,lot,price,deviation));
if result.retcode != mt5.TRADE_RETCODE_DONE:
print("2. order_send failed, retcode={}".format(result.retcode))
# request the result as a dictionary and display it element by element
result_dict=result._asdict()
for field in result_dict.keys():
print(" {}={}".format(field,result_dict[field]))
# if this is a trading request structure, display it element by element as well
if field=="request":
traderequest_dict=result_dict[field]._asdict()
for tradereq_filed in traderequest_dict:
print(" traderequest: {}={}".format(tradereq_filed,traderequest_dict[tradereq_filed]))
print("shutdown() and quit")
mt5.shutdown()
quit()
print("2. order_send done, ", result)
print(" opened position with POSITION_TICKET={}".format(result.order))
print(" sleep 2 seconds before closing position #{}".format(result.order))
time.sleep(2)
# create a close request
position_id=result.order
price=mt5.symbol_info_tick(symbol).bid
deviation=20
request={
"action": mt5.TRADE_ACTION_DEAL,
"symbol": symbol,
"volume": lot,
"type": mt5.ORDER_TYPE_SELL,
"position": position_id,
"price": price,
"deviation": deviation,
"magic": 234000,
"comment": "python script close",
"type_time": mt5.ORDER_TIME_GTC,
"type_filling": mt5.ORDER_FILLING_RETURN,
}
# send a trading request
result=mt5.order_send(request)
# check the execution result
print("3. close position #{}: sell {} {} lots at {} with deviation={} points".format(position_id,symbol,lot,price,deviation));
if result.retcode != mt5.TRADE_RETCODE_DONE:
print("4. order_send failed, retcode={}".format(result.retcode))
print(" result",result)
else:
print("4. position #{} closed, {}".format(position_id,result))
# request the result as a dictionary and display it element by element
result_dict=result._asdict()
for field in result_dict.keys():
print(" {}={}".format(field,result_dict[field]))
# if this is a trading request structure, display it element by element as well
if field=="request":
traderequest_dict=result_dict[field]._asdict()
for tradereq_filed in traderequest_dict:
print(" traderequest: {}={}".format(tradereq_filed,traderequest_dict[tradereq_filed]))
# shut down connection to the MetaTrader 5 terminal
mt5.shutdown()
```
# Result
```
MetaTrader5 package author: MetaQuotes Software Corp.
MetaTrader5 package version: 5.0.29
1. order_send(): by USDJPY 0.1 lots at 108.023 with deviation=20 points
2. order_send done, OrderSendResult(retcode=10009, deal=535084512, order=557416535, volume=0.1, price=108.023, ...
opened position with POSITION_TICKET=557416535
sleep 2 seconds before closing position #557416535
3. close position #557416535: sell USDJPY 0.1 lots at 108.018 with deviation=20 points
4. position #557416535 closed, OrderSendResult(retcode=10009, deal=535084631, order=557416654, volume=0.1, price=...
retcode=10009
deal=535084631
order=557416654
volume=0.1
price=108.015
bid=108.015
ask=108.02
comment=Request executed
request_id=55
retcode_external=0
request=TradeRequest(action=1, magic=234000, order=0, symbol='USDJPY', volume=0.1, price=108.018, stoplimit=0.0, ...
traderequest: action=1
traderequest: magic=234000
traderequest: order=0
traderequest: symbol=USDJPY
traderequest: volume=0.1
traderequest: price=108.018
traderequest: stoplimit=0.0
traderequest: sl=0.0
traderequest: tp=0.0
traderequest: deviation=20
traderequest: type=1
traderequest: type_filling=2
traderequest: type_time=0
traderequest: expiration=0
traderequest: comment=python script close
traderequest: position=557416535
traderequest: position_by=0
```
## See also
`order_check`, `OrderSend`,Trading operation types, Trading request structure, Structure of the trading request check results, Structure of the trading request result
'''
code=f'mt5.order_send({request})'
return self.__conn.eval(code)
def positions_total(self,*args,**kwargs):
r'''
# positions_total
Get the number of open positions.
```python
positions_total()
```
## Return Value
Integer value.
## Note
The function is similar to `PositionsTotal`.
## Example:
```python
import MetaTrader5 as mt5
# display data on the MetaTrader 5 package
print("MetaTrader5 package author: ",mt5.__author__)
print("MetaTrader5 package version: ",mt5.__version__)
# establish connection to MetaTrader 5 terminal
if not mt5.initialize():
print("initialize() failed, error code =",mt5.last_error())
quit()
# check the presence of open positions
positions_total=mt5.positions_total()
if positions_total>0:
print("Total positions=",positions_total)
else:
print("Positions not found")
# shut down connection to the MetaTrader 5 terminal
mt5.shutdown()
```
## See also
`positions_get`, `orders_total`
'''
code=f'mt5.positions_total(*{args},**{kwargs})'
return self.__conn.eval(code)
def positions_get(self,*args,**kwargs):
r'''
# positions_get
Get open positions with the ability to filter by symbol or ticket. There are three call options.
Call without parameters. Return open positions for all symbols.
```python
positions_get()
```
Call specifying a symbol open positions should be received for.
```python
positions_get(
symbol="SYMBOL" # symbol name
)
```
Call specifying a group of symbols open positions should be received for.
```python
positions_get(
group="GROUP" # filter for selecting positions by symbols
)
```
Call specifying a position ticket.
```python
positions_get(
ticket=TICKET # ticket
)
```
## Parameters
- symbol="SYMBOL"
[in] Symbol name. Optional named parameter. If a symbol is specified, the ticket parameter is ignored.
- group="GROUP"
[in] The filter for arranging a group of necessary symbols. Optional named parameter. If the group is specified, the function returns only positions meeting a specified criteria for a symbol name.
- ticket=TICKET
[in] Position ticket (`POSITION_TICKET`). Optional named parameter.
## Return Value
Return info in the form of a named tuple structure (namedtuple). Return None in case of an error. The info on the error can be obtained using `last_error()`.
## Note
The function allows receiving all open positions within one call similar to the `PositionsTotal` and `PositionSelect` tandem.
The group parameter may contain several comma separated conditions. A condition can be set as a mask using '*'. The logical negation symbol '!' can be used for an exclusion. All conditions are applied sequentially, which means conditions of including to a group should be specified first followed by an exclusion condition. For example, group="*, !EUR" means that positions for all symbols should be selected first and the ones containing "EUR" in symbol names should be excluded afterwards.
## Example:
```python
import MetaTrader5 as mt5
import pandas as pd
pd.set_option('display.max_columns', 500) # number of columns to be displayed
pd.set_option('display.width', 1500) # max table width to display
# display data on the MetaTrader 5 package
print("MetaTrader5 package author: ",mt5.__author__)
print("MetaTrader5 package version: ",mt5.__version__)
print()
# establish connection to the MetaTrader 5 terminal
if not mt5.initialize():
print("initialize() failed, error code =",mt5.last_error())
quit()
# get open positions on USDCHF
positions=mt5.positions_get(symbol="USDCHF")
if positions==None:
print("No positions on USDCHF, error code={}".format(mt5.last_error()))
elif len(positions)>0:
print("Total positions on USDCHF =",len(positions))
# display all open positions
for position in positions:
print(position)
# get the list of positions on symbols whose names contain "*USD*"
usd_positions=mt5.positions_get(group="*USD*")
if usd_positions==None:
print("No positions with group=\"*USD*\", error code={}".format(mt5.last_error()))
elif len(usd_positions)>0:
print("positions_get(group=\"*USD*\")={}".format(len(usd_positions)))
# display these positions as a table using pandas.DataFrame
df=pd.DataFrame(list(usd_positions),columns=usd_positions[0]._asdict().keys())
df['time'] = pd.to_datetime(df['time'], unit='s')
df.drop(['time_update', 'time_msc', 'time_update_msc', 'external_id'], axis=1, inplace=True)
print(df)
# shut down connection to the MetaTrader 5 terminal
mt5.shutdown()
```
## Result:
```
MetaTrader5 package author: MetaQuotes Software Corp.
MetaTrader5 package version: 5.0.29
positions_get(group="*USD*")=5
ticket time type magic identifier reason volume price_open sl tp price_current swap profit symbol comment
0 548297723 2020-03-18 15:00:55 1 0 548297723 3 0.01 1.09301 1.11490 1.06236 1.10104 -0.10 -8.03 EURUSD
1 548655158 2020-03-18 20:31:26 0 0 548655158 3 0.01 1.08676 1.06107 1.12446 1.10099 -0.08 14.23 EURUSD
2 548663803 2020-03-18 20:40:04 0 0 548663803 3 0.01 1.08640 1.06351 1.11833 1.10099 -0.08 14.59 EURUSD
3 548847168 2020-03-19 01:10:05 0 0 548847168 3 0.01 1.09545 1.05524 1.15122 1.10099 -0.06 5.54 EURUSD
4 548847194 2020-03-19 01:10:07 0 0 548847194 3 0.02 1.09536 1.04478 1.16587 1.10099 -0.08 11.26 EURUSD
```
## See also
`positions_total`, `orders_get`
'''
code=f'mt5.positions_get(*{args},**{kwargs})'
return self.__conn.eval(code)
def history_orders_total(self,date_from, date_to):
r'''
# history_orders_total
Get the number of orders in trading history within the specified interval.
```python
history_orders_total(
date_from, # date the orders are requested from
date_to # date, up to which the orders are requested
)
```
## Parameters
- date_from
[in] Date the orders are requested from. Set by the 'datetime' object or as a number of seconds elapsed since 1970.01.01. Required unnamed parameter.
- date_to
[in] Date, up to which the orders are requested. Set by the 'datetime' object or as a number of seconds elapsed since 1970.01.01. Required unnamed parameter.
## Return Value
Integer value.
## Note
The function is similar to `HistoryOrdersTotal`.
## Example:
```python
from datetime import datetime
import MetaTrader5 as mt5
# display data on the MetaTrader 5 package
print("MetaTrader5 package author: ",mt5.__author__)
print("MetaTrader5 package version: ",mt5.__version__)
# establish connection to MetaTrader 5 terminal
if not mt5.initialize():
print("initialize() failed, error code =",mt5.last_error())
quit()
# get the number of orders in history
from_date=datetime(2020,1,1)
to_date=datetime.now()
history_orders=mt5.history_orders_total(from_date, datetime.now())
if history_orders>0:
print("Total history orders=",history_orders)
else:
print("Orders not found in history")
# shut down connection to the MetaTrader 5 terminal
mt5.shutdown()
```
## See also
`history_orders_get`, `history_deals_total`
'''
code=f'mt5.history_orders_total({repr(date_from.astimezone())}, {repr(date_to.astimezone())})'
return self.__conn.eval(code)
def history_orders_get(self,*args,**kwargs):
r'''
#history_orders_get
Get orders from trading history with the ability to filter by ticket or position. There are three call options.
Call specifying a time interval. Return all orders falling within the specified interval.
```python
history_orders_get(
date_from, # date the orders are requested from
date_to, # date, up to which the orders are requested
group="GROUP" # filter for selecting orders by symbols
)
```
Call specifying the order ticket. Return an order with the specified ticket.
```python
positions_get(
ticket=TICKET # order ticket
)
```
Call specifying the position ticket. Return all orders with a position ticket specified in the ORDER_POSITION_ID property.
```python
positions_get(
position=POSITION # position ticket
)
```
## Parameters
- date_from
[in] Date the orders are requested from. Set by the 'datetime' object or as a number of seconds elapsed since 1970.01.01. Required unnamed parameter is specified first.
- date_to
[in] Date, up to which the orders are requested. Set by the 'datetime' object or as a number of seconds elapsed since 1970.01.01. Required unnamed parameter is specified second.
- group="GROUP"
[in] The filter for arranging a group of necessary symbols. Optional named parameter. If the group is specified, the function returns only orders meeting a specified criteria for a symbol name.
- ticket=TICKET
[in] Order ticket that should be received. Optional parameter. If not specified, the filter is not applied.
- position=POSITION
[in] Ticket of a position (stored in `ORDER_POSITION_ID`) all orders should be received for. Optional parameter. If not specified, the filter is not applied.
## Return Value
Return info in the form of a named tuple structure (namedtuple). Return None in case of an error. The info on the error can be obtained using `last_error()`.
## Note
The function allows receiving all history orders within a specified period in a single call similar to the HistoryOrdersTotal and HistoryOrderSelect tandem.
The group parameter may contain several comma separated conditions. A condition can be set as a mask using '*'. The logical negation symbol '!' can be used for an exclusion. All conditions are applied sequentially, which means conditions of including to a group should be specified first followed by an exclusion condition. For example, group="*, !EUR" means that deals for all symbols should be selected first and the ones containing "EUR" in symbol names should be excluded afterwards.
## Example:
```python
from datetime import datetime
import MetaTrader5 as mt5
import pandas as pd
pd.set_option('display.max_columns', 500) # number of columns to be displayed
pd.set_option('display.width', 1500) # max table width to display
# display data on the MetaTrader 5 package
print("MetaTrader5 package author: ",mt5.__author__)
print("MetaTrader5 package version: ",mt5.__version__)
print()
# establish connection to the MetaTrader 5 terminal
if not mt5.initialize():
print("initialize() failed, error code =",mt5.last_error())
quit()
# get the number of orders in history
from_date=datetime(2020,1,1)
to_date=datetime.now()
history_orders=mt5.history_orders_get(from_date, to_date, group="*GBP*")
if history_orders==None:
print("No history orders with group=\"*GBP*\", error code={}".format(mt5.last_error()))
elif len(history_orders)>0:
print("history_orders_get({}, {}, group=\"*GBP*\")={}".format(from_date,to_date,len(history_orders)))
print()
# display all historical orders by a position ticket
position_id=530218319
position_history_orders=mt5.history_orders_get(position=position_id)
if position_history_orders==None:
print("No orders with position #{}".format(position_id))
print("error code =",mt5.last_error())
elif len(position_history_orders)>0:
print("Total history orders on position #{}: {}".format(position_id,len(position_history_orders)))
# display all historical orders having a specified position ticket
for position_order in position_history_orders:
print(position_order)
print()
# display these orders as a table using pandas.DataFrame
df=pd.DataFrame(list(position_history_orders),columns=position_history_orders[0]._asdict().keys())
df.drop(['time_expiration','type_time','state','position_by_id','reason','volume_current','price_stoplimit','sl','tp'], axis=1, inplace=True)
df['time_setup'] = pd.to_datetime(df['time_setup'], unit='s')
df['time_done'] = pd.to_datetime(df['time_done'], unit='s')
print(df)
# shut down connection to the MetaTrader 5 terminal
mt5.shutdown()
```
## Result:
```
MetaTrader5 package author: MetaQuotes Software Corp.
MetaTrader5 package version: 5.0.29
history_orders_get(2020-01-01 00:00:00, 2020-03-25 17:17:32.058795, group="*GBP*")=14
Total history orders on position #530218319: 2
TradeOrder(ticket=530218319, time_setup=1582282114, time_setup_msc=1582282114681, time_done=1582303777, time_done_msc=1582303777582, time_expiration=0, ...
TradeOrder(ticket=535548147, time_setup=1583176242, time_setup_msc=1583176242265, time_done=1583176242, time_done_msc=1583176242265, time_expiration=0, ...
ticket time_setup time_setup_msc time_done time_done_msc type type_filling magic position_id volume_initial price_open price_current symbol comment external_id
0 530218319 2020-02-21 10:48:34 1582282114681 2020-02-21 16:49:37 1582303777582 2 2 0 530218319 0.01 0.97898 0.97863 USDCHF
1 535548147 2020-03-02 19:10:42 1583176242265 2020-03-02 19:10:42 1583176242265 1 0 0 530218319 0.01 0.95758 0.95758 USDCHF
```
## See also
`history_deals_total`, `history_deals_get`
'''
code=f'mt5.history_orders_get(*{args},**{kwargs})'
return self.__conn.eval(code)
def history_deals_total(self,date_from, date_to):
r'''
#history_deals_total
Get the number of deals in trading history within the specified interval.
```python
history_deals_total(
date_from, # date the deals are requested from
date_to # date, up to which the deals are requested
)
```
## Parameters
- date_from
[in] Date the deals are requested from. Set by the 'datetime' object or as a number of seconds elapsed since 1970.01.01. Required unnamed parameter.
- date_to
[in] Date, up to which the deals are requested. Set by the 'datetime' object or as a number of seconds elapsed since 1970.01.01. Required unnamed parameter.
## Return Value
Integer value.
## Note
The function is similar to `HistoryDealsTotal`.
## Example:
```python
from datetime import datetime
import MetaTrader5 as mt5
# display data on the MetaTrader 5 package
print("MetaTrader5 package author: ",mt5.__author__)
print("MetaTrader5 package version: ",mt5.__version__)
# establish connection to MetaTrader 5 terminal
if not mt5.initialize():
print("initialize() failed, error code =",mt5.last_error())
quit()
# get the number of deals in history
from_date=datetime(2020,1,1)
to_date=datetime.now()
deals=mt5.history_deals_total(from_date, to_date)
if deals>0:
print("Total deals=",deals)
else:
print("Deals not found in history")
# shut down connection to the MetaTrader 5 terminal
mt5.shutdown()
```
## See also
`history_deals_get`, `history_orders_total`
'''
code=f'mt5.history_deals_total({repr(date_from.astimezone())}, {repr(date_to.astimezone())})'
return self.__conn.eval(code)
def history_deals_get(self,*args,**kwargs):
r'''
#history_deals_get
Get deals from trading history within the specified interval with the ability to filter by ticket or position.
Call specifying a time interval. Return all deals falling within the specified interval.
```python
history_deals_get(
date_from, # date the deals are requested from
date_to, # date, up to which the deals are requested
group="GROUP" # filter for selecting deals for symbols
)
```
Call specifying the order ticket. Return all deals having the specified order ticket in the DEAL_ORDER property.
```python
history_deals_get(
ticket=TICKET # order ticket
)
```
Call specifying the position ticket. Return all deals having the specified position ticket in the DEAL_POSITION_ID property.
```python
history_deals_get(
position=POSITION # position ticket
)
```
## Parameters
- date_from
[in] Date the orders are requested from. Set by the 'datetime' object or as a number of seconds elapsed since 1970.01.01. Required unnamed parameter is specified first.
- date_to
[in] Date, up to which the orders are requested. Set by the 'datetime' object or as a number of seconds elapsed since 1970.01.01. Required unnamed parameter is specified second.
- group="GROUP"
[in] The filter for arranging a group of necessary symbols. Optional named parameter. If the group is specified, the function returns only deals meeting a specified criteria for a symbol name.
- ticket=TICKET
[in] Ticket of an order (stored in `DEAL_ORDER`) all deals should be received for. Optional parameter. If not specified, the filter is not applied.
- position=POSITION
[in] Ticket of a position (stored in `DEAL_POSITION_ID`) all deals should be received for. Optional parameter. If not specified, the filter is not applied.
## Return Value
Return info in the form of a named tuple structure (namedtuple). Return None in case of an error. The info on the error can be obtained using `last_error()`.
## Note
The function allows receiving all history deals within a specified period in a single call similar to the HistoryDealsTotal and `HistoryDealSelect` tandem.
The group parameter allows sorting out deals by symbols. '*' can be used at the beginning and the end of a string.
The group parameter may contain several comma separated conditions. A condition can be set as a mask using '*'. The logical negation symbol '!' can be used for an exclusion. All conditions are applied sequentially, which means conditions of including to a group should be specified first followed by an exclusion condition. For example, group="*, !EUR" means that deals for all symbols should be selected first and the ones containing "EUR" in symbol names should be excluded afterwards.
## Example:
```python
import MetaTrader5 as mt5
from datetime import datetime
import pandas as pd
pd.set_option('display.max_columns', 500) # number of columns to be displayed
pd.set_option('display.width', 1500) # max table width to display
# display data on the MetaTrader 5 package
print("MetaTrader5 package author: ",mt5.__author__)
print("MetaTrader5 package version: ",mt5.__version__)
print()
# establish connection to the MetaTrader 5 terminal
if not mt5.initialize():
print("initialize() failed, error code =",mt5.last_error())
quit()
# get the number of deals in history
from_date=datetime(2020,1,1)
to_date=datetime.now()
# get deals for symbols whose names contain "GBP" within a specified interval
deals=mt5.history_deals_get(from_date, to_date, group="*GBP*")
if deals==None:
print("No deals with group=\"*USD*\", error code={}".format(mt5.last_error()))
elif len(deals)> 0:
print("history_deals_get({}, {}, group=\"*GBP*\")={}".format(from_date,to_date,len(deals)))
# get deals for symbols whose names contain neither "EUR" nor "GBP"
deals = mt5.history_deals_get(from_date, to_date, group="*,!*EUR*,!*GBP*")
if deals == None:
print("No deals, error code={}".format(mt5.last_error()))
elif len(deals) > 0:
print("history_deals_get(from_date, to_date, group=\"*,!*EUR*,!*GBP*\") =", len(deals))
# display all obtained deals 'as is'
for deal in deals:
print(" ",deal)
print()
# display these deals as a table using pandas.DataFrame
df=pd.DataFrame(list(deals),columns=deals[0]._asdict().keys())
df['time'] = pd.to_datetime(df['time'], unit='s')
print(df)
print("")
# get all deals related to the position #530218319
position_id=530218319
position_deals = mt5.history_deals_get(position=position_id)
if position_deals == None:
print("No deals with position #{}".format(position_id))
print("error code =", mt5.last_error())
elif len(position_deals) > 0:
print("Deals with position id #{}: {}".format(position_id, len(position_deals)))
# display these deals as a table using pandas.DataFrame
df=pd.DataFrame(list(position_deals),columns=position_deals[0]._asdict().keys())
df['time'] = pd.to_datetime(df['time'], unit='s')
print(df)
# shut down connection to the MetaTrader 5 terminal
mt5.shutdown()
```
## Result:
```
MetaTrader5 package author: MetaQuotes Software Corp.
MetaTrader5 package version: 5.0.29
history_deals_get(from_date, to_date, group="*GBP*") = 14
history_deals_get(from_date, to_date, group="*,!*EUR*,!*GBP*") = 7
TradeDeal(ticket=506966741, order=0, time=1582202125, time_msc=1582202125419, type=2, entry=0, magic=0, position_id=0, reason=0, volume=0.0, pri ...
TradeDeal(ticket=507962919, order=530218319, time=1582303777, time_msc=1582303777582, type=0, entry=0, magic=0, position_id=530218319, reason=0, ...
TradeDeal(ticket=513149059, order=535548147, time=1583176242, time_msc=1583176242265, type=1, entry=1, magic=0, position_id=530218319, reason=0, ...
TradeDeal(ticket=516943494, order=539349382, time=1583510003, time_msc=1583510003895, type=1, entry=0, magic=0, position_id=539349382, reason=0, ...
TradeDeal(ticket=516943915, order=539349802, time=1583510025, time_msc=1583510025054, type=0, entry=0, magic=0, position_id=539349802, reason=0, ...
TradeDeal(ticket=517139682, order=539557870, time=1583520201, time_msc=1583520201227, type=0, entry=1, magic=0, position_id=539349382, reason=0, ...
TradeDeal(ticket=517139716, order=539557909, time=1583520202, time_msc=1583520202971, type=1, entry=1, magic=0, position_id=539349802, reason=0, ...
ticket order time time_msc type entry magic position_id reason volume price commission swap profit fee symbol comment external_id
0 506966741 0 2020-02-20 12:35:25 1582202125419 2 0 0 0 0 0.00 0.00000 0.0 0.0 100000.00 0.0
1 507962919 530218319 2020-02-21 16:49:37 1582303777582 0 0 0 530218319 0 0.01 0.97898 0.0 0.0 0.00 0.0 USDCHF
2 513149059 535548147 2020-03-02 19:10:42 1583176242265 1 1 0 530218319 0 0.01 0.95758 0.0 0.0 -22.35 0.0 USDCHF
3 516943494 539349382 2020-03-06 15:53:23 1583510003895 1 0 0 539349382 0 0.10 0.93475 0.0 0.0 0.00 0.0 USDCHF
4 516943915 539349802 2020-03-06 15:53:45 1583510025054 0 0 0 539349802 0 0.10 0.66336 0.0 0.0 0.00 0.0 AUDUSD
5 517139682 539557870 2020-03-06 18:43:21 1583520201227 0 1 0 539349382 0 0.10 0.93751 0.0 0.0 -29.44 0.0 USDCHF
6 517139716 539557909 2020-03-06 18:43:22 1583520202971 1 1 0 539349802 0 0.10 0.66327 0.0 0.0 -0.90 0.0 AUDUSD
Deals with position id #530218319: 2
ticket order time time_msc type entry magic position_id reason volume price commission swap profit fee symbol comment external_id
0 507962919 530218319 2020-02-21 16:49:37 1582303777582 0 0 0 530218319 0 0.01 0.97898 0.0 0.0 0.00 0.0 USDCHF
1 513149059 535548147 2020-03-02 19:10:42 1583176242265 1 1 0 530218319 0 0.01 0.95758 0.0 0.0 -22.35 0.0 USDCHF
```
## See also
`history_deals_total`, `history_orders_get`
'''
code=f'mt5.history_deals_get(*{args},**{kwargs})'
response = self.__conn.eval(code)
return response
def eval(self,command:str):
return self.__conn.eval(command)
def execute(self,command:str):
self.__conn.execute(command)
Reference in a new issue View git blame Copy permalink